#include "stdafx.h"
#include "encryption.h"
#include "KTSetting.h"
#include "AecDbBDPipeBase.h"
#include "AecDbX3dPart.h"
#include "AecDbX3dPartEntity.h"
#include "MFCDbDwgFiler.h"
#include "CoreTools.h"
#include "AecDbOpening.h"
#include "geometry2json.h"
#include "AecCoverBooleanOper.h"
#include "AcGiViewDraw.h"

static const Adesk::UInt16 kColorByBlock = 0;
static const Adesk::UInt16 kRed = 1;
static const Adesk::UInt16 kYellow = 2;
static const Adesk::UInt16 kGreen = 3;
static const Adesk::UInt16 kCyan = 4;
static const Adesk::UInt16 kBlue = 5;
static const Adesk::UInt16 kMagenta = 6;
static const Adesk::UInt16 kWhite = 7;
static const Adesk::UInt16 kColorByLayer = 256;

#define LAY_PIPE_OUTSIDE	_T("PIPE_OUT")

extern void DLLIMPEXP OrthoProjected3DSolid(AcDb3dSolid* pSolidClone,const AcGePlane& plan,AcGeMatrix3d& xformPlanToWorld,AcDbVoidPtrArray& arEntPtrs);
extern void RegionHatch(AcDbRegion* pRegionT,AcDbVoidPtrArray& arHatchPtrs,LPCTSTR pszPattern);
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb = NULL,bool bClose = true);
extern AcDbRegion* CreatePolygonRegionOnly(AcGePoint3d* pPoints,int nSize);
extern AcDbPolyline *FormatPolyline(AcGePoint3d *ppPts, int nCount);
extern void FillSolid(AcGePoint3d *pptGe, int nCount, AcDbVoidPtrArray &arHatchPtrs);

static void FreeBuffer(int n,AcArray<AecDbX3dPart*>& arPartPtrs)
{
	AecDbX3dPart* pEnt = NULL;
	while(arPartPtrs.length() > n )
	{
		pEnt = (AecDbX3dPart*)arPartPtrs.last();
		if (pEnt != NULL)
		{
			arPartPtrs.removeLast();
			delete pEnt;
		}
	}
}

static void FreeBuffer(int n, AcDbVoidPtrArray& arEntPtrs)
{
	AcDbEntity* pEnt = NULL;
	while (arEntPtrs.length() > n)
	{
		pEnt = (AcDbEntity*)arEntPtrs.last();
		DELETE_PTR(pEnt);
		arEntPtrs.removeLast();
	}
}

extern void transfromRegion(AcDbRegion *pRegion, const AcGePoint3d &ptOnRegion, const AcGeVector3d &vtNormal, const AcGePoint3d &ptOnPlan);

Adesk::UInt32 AecDbBDPipeBase::kCurrentVersionNumber = 1;

ACRX_DXF_DEFINE_MEMBERS (AecDbBDPipeBase, AecDbEwPipeBase,
						 AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 
						 AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning, 
						 AEC_BDPIPE,
						 "AecDbBDPipeBase"
						 "|Product Desc:     shanghua earthworm app obj"
						 "|Company:          shanghua inc"
						 "|WEB Address:      www.shanghuasoft.com")



AecDbBDPipeBase::AecDbBDPipeBase(void)
{
	memset(m_dRotate,0,sizeof(double) * 3);
}

AecDbBDPipeBase::~AecDbBDPipeBase(void)
{
	FreeBuffer(0,m_arX3DPartPtrs);
}

void AecDbBDPipeBase::AddX3dPart(AecDbX3dPart* pPart,int nBoolOper)
{
	AssertWriteEnabled();

	pPart->SetBoolOperFor(nBoolOper); 
	m_arX3DPartPtrs.append(pPart);
}

int  AecDbBDPipeBase::GetX3dPartCount() const
{
	assertReadEnabled();
	return m_arX3DPartPtrs.length();
}

bool AecDbBDPipeBase::RemoveX3dPart(int nIndex)
{
	AssertWriteEnabled();
	if (nIndex > -1 && nIndex < m_arX3DPartPtrs.length())
	{
		AecDbX3dPart* pPart = m_arX3DPartPtrs.at(nIndex);
		m_arX3DPartPtrs.removeAt(nIndex);
		if (pPart != NULL)
		{
			delete pPart;
		}
	}
	return false;
}

void AecDbBDPipeBase::RemoveAllX3dPart(bool bDelete)
{
	AssertWriteEnabled();
	while(!m_arX3DPartPtrs.isEmpty())
	{
		AecDbX3dPart* pPart = m_arX3DPartPtrs.last();
		m_arX3DPartPtrs.removeLast();

		if (bDelete)
		{
			delete pPart;
		}
	}
}

AecDbX3dPart* AecDbBDPipeBase::GetX3dPart(int nIndex) const
{
	assertReadEnabled();
	if (nIndex > -1 && nIndex < m_arX3DPartPtrs.length())
	{
		return m_arX3DPartPtrs.at(nIndex);
	}
	return NULL;
}

AecDbX3dPart* AecDbBDPipeBase::GetX3dPart(LPCTSTR pszID) const
{
	assertReadEnabled();
	if (!pszID) return NULL;
	AecDbX3dPart* pPart = NULL;
	for(int i = 0;i < m_arX3DPartPtrs.length();i++)
	{
		pPart = m_arX3DPartPtrs.at(i);
		if (_tcscmp(pPart->GetGUID(),pszID) == 0)
		{
			return pPart;
		}
	}
	return NULL;
}

//移除洞口,井结构
bool AecDbBDPipeBase::RemoveX3dPart(LPCTSTR pszGUID)
{
	AssertWriteEnabled();

	AecDbX3dPart* pPart = NULL;
	for (int i = 0;i < m_arX3DPartPtrs.length();i++)
	{
		pPart = m_arX3DPartPtrs.at(i);
		if ( _tcscmp(pPart->GetGUID(),pszGUID) == 0)
		{
			m_arX3DPartPtrs.removeAt(i);
			delete pPart;
			return true;
		}
	}
	return false;
}

void AecDbBDPipeBase::AddMove(LPCTSTR pszID, AcGeVector3d& vtMove)
{
	AssertWriteEnabled();
	AecDbX3dPart* pPart = GetX3dPart(pszID);
	if (pPart != NULL)
	{
		pPart->AddMove(vtMove);
	}
}

void AecDbBDPipeBase::ResetMove(LPCTSTR pszID)
{
	AssertWriteEnabled();
	AecDbX3dPart* pPart = GetX3dPart(pszID);
	if (pPart != NULL)
	{
		pPart->ResetMove();
	}
}

AcGePoint3d AecDbBDPipeBase::GetPosition() const
{
	assertReadEnabled();

	AcGePoint3d ptCenPos;
	m_mapSpecXData.GetAt(KEY_ORGPT,ptCenPos);
	return ptCenPos;
}

void AecDbBDPipeBase::SetPosition(const AcGePoint3d& ptPos)
{
	AssertWriteEnabled();

	//改变basecurve
	AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
	if (pLn != NULL)
	{
		AcGePoint3d ptSta = pLn->startPoint();
		AcGePoint3d ptEnd = pLn->endPoint();

		AcGeVector3d vt = ptEnd - ptSta;
		ptSta = ptPos;
		ptEnd = ptPos + vt;

		pLn->setStartPoint(ptSta);
		pLn->setEndPoint(ptEnd);

		m_mapSpecXData.SetAt(KEY_ORGPT,ptPos,TRUE);
	}
}

void AecDbBDPipeBase::SetRotation(int nAxisIndex,double dRotate)
{
	AssertWriteEnabled();
	if (nAxisIndex > -1 && nAxisIndex < 2)
	{
		m_dRotate[nAxisIndex] = dRotate;
	}
}

double AecDbBDPipeBase::GetRotation(int nAxisIndex) const
{
	assertReadEnabled();
	if (nAxisIndex > -1 && nAxisIndex < 2)
	{
		return m_dRotate[nAxisIndex];
	}
	return 0.0;
}

void AecDbBDPipeBase::ResetRotation(int nAxisIndex/* = -1*/)
{
	AssertWriteEnabled();
	if (nAxisIndex > -1 && nAxisIndex < 2)
	{
		m_dRotate[nAxisIndex] = 0.0;
	}
	else if (nAxisIndex == -1)
	{
		m_dRotate[X] = 0.0;
		m_dRotate[Y] = 0.0;
		m_dRotate[Z] = 0.0;
	}
}

void AecDbBDPipeBase::SetRotation(LPCTSTR pszID,int nAxis,double dRotateBy)
{
	AssertWriteEnabled();
	AecDbX3dPart* pPart = GetX3dPart(pszID);
	if (pPart != NULL)
	{
		pPart->AddRotate(nAxis,dRotateBy);
	}
}

void AecDbBDPipeBase::ResetRotation(LPCTSTR pszID,int nAxis)
{
	AssertWriteEnabled();
	AecDbX3dPart* pPart = GetX3dPart(pszID);
	if (pPart != NULL)
	{
		pPart->ResetRotate(nAxis);
	}
}

void AecDbBDPipeBase::DrawDTYG2D(AcGiDraw & dc) const
{
	assertReadEnabled();

	// 先判断缓存
	if (!m_arDTYG2DBufPtrs.isEmpty())
	{
		for (int i = 0; i < m_arDTYG2DBufPtrs.length(); ++i)
		{
			AcDbEntity *pEnt((AcDbEntity*)m_arDTYG2DBufPtrs[i]);
			dc.DrawEntity(*pEnt);
		}
		return;
	}

	// 在 3d buffers 里挑出来需要的 clone 一份
	AecDbObjXDataMap xdata;
	AcDbVoidPtrArray ar3d = Get3DBuffer();
	for (int i = 0; i < ar3d.length(); ++i)
	{
		AcDbEntity *pEnt((AcDbEntity*)ar3d[i]);
		AcDb3dSolid *pSolid = AcDb3dSolid::cast(pEnt);
		if (!pSolid) continue;
		xdata.Empty();
		if (!xdata.Read(pSolid, _T("DTYG"))) continue;
		AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
		dc.DrawEntity(*p);
		m_arDTYG2DBufPtrs.append(p);
	}
	if (!m_arDTYG2DBufPtrs.isEmpty()) return;

	// 如果都没有，新建

	int nVt;
	AcDbObjectId ltid(KTSetting::InitLineStyle(_T("CENTER")));
	for (int i = 0; i < m_arX3DPartPtrs.length(); ++i)
	{
		
		AecDbX3dPart *pPart(m_arX3DPartPtrs[i]);
		if (!pPart) continue;
		if (!pPart->GetSpecialtyData()->HasKey(_T("DTYG_TYPE"), nVt)) continue;

		CString sType(_T(""));
		pPart->GetSpecialtyData()->GetAt(_T("DTYG_TYPE"), sType);
		//if (sType == _T("切割")) continue;

		bool bSub = pPart->GetBoolOperFor() == AcDb::kBoolSubtract;

		AcDb3dSolid *pSolid = pPart->CreateDraw3dSolid();
		if (!pSolid)
		{
			pPart->Create();
			pSolid = pPart->CreateDraw3dSolid();
		}

		if (pSolid)
		{
			if (bSub && ltid.isValid())
				pSolid->setLinetype(ltid);
			dc.DrawEntity(*pSolid);
			m_arDTYG2DBufPtrs.append(pSolid);
		}
	}
}

Acad::ErrorStatus AecDbBDPipeBase::Draw2d(AcGiDraw &dc) const
{
	return AecDbEwPipeBase::Draw2d(dc);
}

Acad::ErrorStatus AecDbBDPipeBase::Draw3d(AcGiDraw &dc) const
{
	assertReadEnabled();
	if (g_BALock::instance().Draw() != BIT_SUCCESS)
		return Acad::eOk;

	////管线系统屏蔽掉
	if ( dc.IsDragging() )
	{
		//return Acad::eOk;
	}

	//图层
	AcDbObjectId idLay = dc.GetLayerId();
	dc.SetLayer(layerId());

	int nCrBk = dc.GetColor();

	int nColor = nCrBk;
	if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
	{
		dc.SetColor(nColor);
	}

	if (IsActive())
	{
		nColor = kMagenta;
		m_mapSpecXData.GetAt(KEY_ACTIVECR,nColor);
		dc.SetColor(nColor);
	}

	if (Has3DBuffer())
	{
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar3D = Get3DBuffer();
		for (int i = 0;i < ar3D.length();i++)
		{
			pEnt = (AcDbEntity*)ar3D.at(i);
			if ( IsActive() )
			{
				BackupColorIndex(pEnt);
				pEnt->setColorIndex(nColor);
			}
			else
			{
				SetBackupColorIndex(pEnt);
			}
			dc.DrawEntity(*pEnt);
		}

		dc.SetLayer(idLay);
		dc.SetColor(nCrBk);
		return Acad::eOk;
	}

	AcCmTransparency tr = transparency();
	AcDb3dSolid* pSolidDraw = GetDraw3dSolid(false, nColor);
	if (pSolidDraw != NULL)
	{
		pSolidDraw->setTransparency(tr);
		pSolidDraw->setLayer(layerId());
		//pSolidDraw->setColorIndex(nColor);
		dc.DrawEntity(pSolidDraw);
		Add3DBuffer(pSolidDraw);
	}

	dc.SetLayer(idLay);
	dc.SetColor(nCrBk);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbBDPipeBase::copyFrom(const AcRxObject* pSrc)
{
	assertWriteEnabled();
	
	AecDbEwPipeBase::copyFrom(pSrc);

	//?????需要测试 ---  通过dwgin/out复制了???
	/*AecDbBDPipeBase *pBDSrc = AecDbBDPipeBase::cast(pSrc);
	if (pBDSrc != NULL)
	{
		m_nActivePart = pBDSrc->m_nActivePart;
		memcpy(m_dRotate, pBDSrc->m_dRotate, sizeof(double) * 3);

		m_arX3DPartPtrs.removeAll();
		m_arX3DPartPtrs.append(pBDSrc->m_arX3DPartPtrs);

		m_arAssocPartEntIds.removeAll();
		m_arAssocPartEntIds.append(pBDSrc->m_arAssocPartEntIds);

		m_arDTYG2DBufPtrs.removeAll();
		m_arDTYG2DBufPtrs.append(pBDSrc->m_arDTYG2DBufPtrs);
	}*/

	return Acad::eOk;
}

int AecDbBDPipeBase::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const
{
	assertReadEnabled();

	AcDbObjectId idLay = layerId();

	AcDbEntity* pEnt = NULL,*pEntCln = NULL;
	const AcDbVoidPtrArray &ar2D = Get2DBuffer();
	for (int i = 0;i < ar2D.length();i++)
	{
		pEnt = (AcDbEntity*)ar2D.at(i);
		
		pEntCln = (AcDbEntity*)pEnt->clone();

		pEntCln->setLayer(idLay);
		arEntPtrs.append(pEntCln);
	}

	AcGePlane plan = AcGePlane::kXYPlane;

	AcGeMatrix3d xform;
	xform.setToPlaneToWorld(plan);
	xform.invert();

	AcDbVoidPtrArray arSubEntPtrs;

	for (int j = 0;j < m_arDTYG2DBufPtrs.length();j++)
	{
		pEnt = (AcDbEntity*)m_arDTYG2DBufPtrs.at(j);

		AcDb3dSolid* pSolid = AcDb3dSolid::cast(pEnt);
		if (pSolid != NULL)
		{
			//投影法
			OrthoProjected3DSolid(pSolid,plan,xform,arSubEntPtrs);
		}
	}

	for (int k = 0;k < arSubEntPtrs.length();k++)
	{
		pEnt = (AcDbEntity*)arSubEntPtrs.at(k);
		pEnt->setLayer(idLay);
		arEntPtrs.append(pEnt);
	}
	return arEntPtrs.length();
}

AcDb3dSolid* AecDbBDPipeBase::GetDraw3dSolid(bool bAttachBimInf, int nColor,bool bSubtractHole/* = true*/) const
{
	assertReadEnabled();

	//底板总
	AcDb3dSolid* pPipe = GetCreatPipe3dSolid();
	if (pPipe != NULL)
	{
		pPipe->setColorIndex(nColor);
		//旋转
		AcGePoint3d ptCen;
		m_mapSpecXData.GetAt(KEY_ORGPT,ptCen);

		AcGeMatrix3d xRote;
		xRote.setToRotation(m_dRotate[X],AcGeVector3d::kXAxis,ptCen);
		pPipe->transformBy(xRote);

		//原位置按轴旋转 轴Y
		xRote.setToRotation(m_dRotate[Y],AcGeVector3d::kYAxis,ptCen);
		pPipe->transformBy(xRote);

		//原位置按轴旋转 轴Z
		xRote.setToRotation(m_dRotate[Z],AcGeVector3d::kZAxis,ptCen);
		pPipe->transformBy(xRote);

		CString sGradX, sGradY;//ext. 1.5 dh / dl * 100 %
		if (m_mapSpecXData.GetAt(KEY_GRADX, sGradX))
		{
			double dA = atan(_ttof(sGradX) / 100.0);
			//绕Y
			xRote.setToRotation(dA, AcGeVector3d::kYAxis, ptCen);
			pPipe->transformBy(xRote);
		}

		if (m_mapSpecXData.GetAt(KEY_GRADY, sGradY))
		{
			double dB = atan(_ttof(sGradY) / 100.0);
			//绕X
			xRote.setToRotation(dB, AcGeVector3d::kXAxis, ptCen);
			pPipe->transformBy(xRote);
		}
	}

	//原点位置的单体异构
	AcDb3dSolid* pSolidDraw = GetBooleanPart3D(pPipe);
	
	//3.再开除关联的真实位置的part的对象
	if (bSubtractHole && pSolidDraw != NULL)
	{
		BoolSubtractAssoc(pSolidDraw);
	}

	if (bAttachBimInf)
	{
		m_mapSpecXData.Write(pSolidDraw,BIMDATA_APP);
	}
	return pSolidDraw;
}

//临时方法
void AecDbBDPipeBase::RemovePartForSlice()
{
	AssertWriteEnabled();

	int bSlice = 0;
	AecDbX3dPart* pPart = NULL;
	for (int i = 0;i < m_arX3DPartPtrs.length();i++)
	{
		pPart = (AecDbX3dPart*)m_arX3DPartPtrs.at(i);

		if ( pPart->GetSpecialtyData()->GetAt(KEY_FORSLICE,bSlice) )
		{
			m_arX3DPartPtrs.removeAt(i);
			i -= 1;
			delete pPart;
		}
	}
}

AcDb3dSolid* AecDbBDPipeBase::GetBooleanPart3D(AcDb3dSolid* pSolidAll) const
{
	assertReadEnabled();

	//1.合成全部整体
	Acad::ErrorStatus es = Acad::eOk;
	int nBoolOper = 0,bSlice = 0;
	AcDb3dSolid* pSolidPart = NULL;
	AecDbX3dPart* pPart = NULL;
	for (int i = 0;i < m_arX3DPartPtrs.length();i++)
	{
		pPart = (AecDbX3dPart*)m_arX3DPartPtrs.at(i);

		//融合PART需要slice 另行处理[Wall]
		bSlice = 0;
		if ( pPart->GetSpecialtyData()->GetAt(KEY_FORSLICE,bSlice) )
		{
			if (bSlice)
			{
				continue;
			}
			else
			{
				//...
			}
		}

		nBoolOper = pPart->GetBoolOperFor();
		if (nBoolOper == AcDb::kBoolUnite)
		{
			pSolidPart = pPart->CreateDraw3dSolid();
			if (pSolidPart == NULL)
			{
				pPart->Create();
				pSolidPart = pPart->CreateDraw3dSolid();
			}

			if (pSolidPart != NULL)
			{
				if (pSolidAll == NULL)
				{
					pSolidAll = pSolidPart;
					continue;
				}

				if ( Acad::eOk == (es = pSolidAll->booleanOper(AcDb::kBoolUnite,pSolidPart) ) )
				{
				}
				else
				{
					acutPrintf(_T("\nUnite Oper error:%d"),es);
				}
			}
		}
	}

	//2.再开除洞口
	for (int i = 0;i < m_arX3DPartPtrs.length();i++)
	{
		pPart = (AecDbX3dPart*)m_arX3DPartPtrs.at(i);

		nBoolOper = pPart->GetBoolOperFor();
		if (nBoolOper == AcDb::kBoolSubtract)
		{
			pSolidPart = pPart->CreateDraw3dSolid();
			if (pSolidPart == NULL)
			{
				pPart->Create();
				pSolidPart = pPart->CreateDraw3dSolid();
			}

			if (pSolidPart != NULL && pSolidAll != NULL)
			{
				if ( Acad::eOk == (es = pSolidAll->booleanOper(AcDb::kBoolSubtract,pSolidPart) ) )
				{
				}
				else
				{
					acutPrintf(_T("\nSubtract Oper error:%d"),es);
				}
			}
		}
	}

	//总体位置的移动和旋转
	if (pSolidAll != NULL)
	{
		AcGePoint3d ptCen;
		m_mapSpecXData.GetAt(KEY_ORGPT,ptCen);

		AcGeMatrix3d xRote;
		xRote.setToRotation(m_dRotate[X],AcGeVector3d::kXAxis,ptCen);
		pSolidAll->transformBy(xRote);

		//原位置按轴旋转 轴Y
		xRote.setToRotation(m_dRotate[Y],AcGeVector3d::kYAxis,ptCen);
		pSolidAll->transformBy(xRote);

		//原位置按轴旋转 轴Z
		xRote.setToRotation(m_dRotate[Z],AcGeVector3d::kZAxis,ptCen);
		pSolidAll->transformBy(xRote);
	}
	return pSolidAll;
}

Acad::ErrorStatus AecDbBDPipeBase::BoolSubtractAssoc(AcDb3dSolid* pSolidDraw) const
{
	assertReadEnabled();

	//3.再开除关联的part的对象
	Acad::ErrorStatus es;
	AcDbEntity* pEnt = NULL;
	AcDbObjectId id;
	for (int i = 0;i < m_arAssocPartEntIds.length();i++)
	{
		id = m_arAssocPartEntIds.at(i);
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead)))
		{
			AecDbX3dPartEntity* pPartEnt = AecDbX3dPartEntity::cast(pEnt);
			if (pPartEnt != NULL)
			{
				AcDbVoidPtrArray arSolidPtrs;
				pPartEnt->GetForHouseSubtract(arSolidPtrs);

				for(int ii = 0;ii < arSolidPtrs.length();ii++)
				{
					AcDb3dSolid* pSolidPart = (AcDb3dSolid*)arSolidPtrs.at(ii) ;
					if (pSolidPart != NULL)
					{
						//TEST
						//AddToModelSpace((AcDbEntity*)pSolidPart->clone());
						if ( Acad::eOk == (es = pSolidDraw->booleanOper(AcDb::kBoolSubtract,pSolidPart) ) )
						{
							//TEST
							//AddToModelSpace((AcDbEntity*)pSolidAll->clone());
						}
						else
						{
							acutPrintf(_T("\nSubtract Oper error:%d"),es);
						}
					}
				}
			}
			pEnt->close();
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbBDPipeBase::dwgInFields(AcDbDwgFiler* pFiler)
{
	AssertWriteEnabled();

	//----- Read parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	es = AecDbEwPipeBase::dwgInFields (pFiler) ;
	if ( es != Acad::eOk )
		return (es) ;
	
	//----- Object version number needs to be read first
	return _dwgInFields_for_DBWeir(pFiler);

}

Acad::ErrorStatus AecDbBDPipeBase::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	//----- Save parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	es = AecDbEwPipeBase::dwgOutFields (pFiler) ;
	if (es != Acad::eOk)
		return (es);

	//----- Object version number needs to be saved first
	return _dwgOutFields_for_DBWeir(pFiler);

}

Acad::ErrorStatus AecDbBDPipeBase::_dwgInFields_for_DBWeir(AcDbDwgFiler * pFiler)
{
	Acad::ErrorStatus es;
	Adesk::UInt32 version = 0;
	if ((es = pFiler->readUInt32(&version)) != Acad::eOk)
		return (es);

	if (version > AecDbBDPipeBase::kCurrentVersionNumber)
		return (Acad::eMakeMeProxy);

	TCHAR* pszTemp = NULL;
	pFiler->readString(&pszTemp);
	if (pszTemp != NULL)
	{
		m_sGUID = pszTemp;
		acutDelString(pszTemp);
	}

	pFiler->readDouble(&m_dRotate[X]);
	pFiler->readDouble(&m_dRotate[Y]);
	pFiler->readDouble(&m_dRotate[Z]);

	Adesk::UInt32 nLen = 0;
	pFiler->readUInt32(&nLen);

	m_arX3DPartPtrs.removeAll();
	AecDbX3dPart* pPart = NULL;
	for (int i = 0; i < nLen; i++)
	{
		pPart = new AecDbX3dPart;
		pPart->dwgInFields(pFiler);
		m_arX3DPartPtrs.append(pPart);
	}

	AcDbSoftPointerId id;
	m_arAssocPartEntIds.removeAll();

	nLen = 0;
	pFiler->readUInt32(&nLen);
	for (int i = 0; i < nLen; i++)
	{
		pFiler->readSoftPointerId(&id);

		if (m_arAssocPartEntIds.find(id) == -1)
			m_arAssocPartEntIds.append(id);
	}

	return (pFiler->filerStatus());
}

Acad::ErrorStatus AecDbBDPipeBase::_dwgOutFields_for_DBWeir(AcDbDwgFiler * pFiler) const
{
	Acad::ErrorStatus es;
	if ((es = pFiler->writeUInt32(AecDbBDPipeBase::kCurrentVersionNumber)) != Acad::eOk)
		return (es);

	pFiler->writeString((LPCTSTR)m_sGUID);

	pFiler->writeDouble(m_dRotate[X]);
	pFiler->writeDouble(m_dRotate[Y]);
	pFiler->writeDouble(m_dRotate[Z]);

	Adesk::UInt32 nLen = m_arX3DPartPtrs.length();
	pFiler->writeUInt32(nLen);
	for (int i = 0; i < nLen; i++)
	{
		const AecDbX3dPart* pPart = m_arX3DPartPtrs.at(i);
		pPart->dwgOutFields(pFiler);
	}

	AcDbObjectId id;
	AcDbObjectIdArray arAssocPartEntIds;

	//先清理掉无效的
	nLen = m_arAssocPartEntIds.length();
	for (int i = 0; i < nLen; i++)
	{
		id = m_arAssocPartEntIds.at(i);
		if (id.isValid())
		{
			if (arAssocPartEntIds.find(id) == -1)
				arAssocPartEntIds.append(id);
		}
	}

	nLen = arAssocPartEntIds.length();
	pFiler->writeUInt32(nLen);

	for (int i = 0; i < nLen; i++)
	{
		id = arAssocPartEntIds.at(i);
		pFiler->writeSoftPointerId(id);
	}
	return (pFiler->filerStatus());
}

Acad::ErrorStatus AecDbBDPipeBase::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbBDPipeBase::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eOk;
}

bool AecDbBDPipeBase::AppendAssocPart(const AcDbObjectId& id)
{
	AssertWriteEnabled();
	if (m_arAssocPartEntIds.find(id) == -1)
	{
		m_arAssocPartEntIds.append(id);
		return true;
	}
	return false;
}

bool AecDbBDPipeBase::RemoveAssocPart(int nIndex)
{
	AssertWriteEnabled();
	if (nIndex > -1 && nIndex < m_arAssocPartEntIds.length())
	{
		m_arAssocPartEntIds.removeAt(nIndex);
		return true;
	}
	return false;
}

bool AecDbBDPipeBase::RemoveAssocPart(const AcDbObjectId & id)
{
	AssertWriteEnabled();
	for (int i = 0; i < m_arAssocPartEntIds.length(); ++i)
	{
		if (id == m_arAssocPartEntIds[i])
			return RemoveAssocPart(i);
	}
	return false;
}

int  AecDbBDPipeBase::GetAssocPartCount() const
{
	assertReadEnabled();
	return m_arAssocPartEntIds.length();
}

bool AecDbBDPipeBase::GetAssocPart(int nIndex,AcDbObjectId& id) const
{
	assertReadEnabled();
	if (nIndex > -1 && nIndex < m_arAssocPartEntIds.length())
	{
		id = m_arAssocPartEntIds.at(nIndex);
		return true;
	}
	return false;
}

bool AecDbBDPipeBase::GetAssocPartIds(AcDbObjectIdArray& arIds) const
{
	assertReadEnabled();
	if (!m_arAssocPartEntIds.isEmpty())
		arIds.append(m_arAssocPartEntIds);
	return !arIds.isEmpty();
}

void AecDbBDPipeBase::AssertWriteEnabled(Adesk::Boolean autoUndo,Adesk::Boolean recordModified )
{
	AecDbEwPipeBase::AssertWriteEnabled(autoUndo,recordModified);
	deleteArrayVoidPtrs< AcDbEntity>(m_arDTYG2DBufPtrs);
}

Acad::ErrorStatus AecDbBDPipeBase::subTransformBy(const AcGeMatrix3d& xform)
{
	AssertWriteEnabled();

	AecDbEwPipeBase::subTransformBy(xform);

	AcDbObjectId id;
	AcDbEntity* pEnt = NULL;
	Acad::ErrorStatus es = Acad::eOk;

	//只处理移动情况
	AcGePoint3d ptOrg(0,0,0);
	ptOrg.transformBy(xform);
	
	int nvt(0);
	AecDbX3dPart* pPart = NULL;
	for (int i = 0;i < m_arX3DPartPtrs.length();i++)
	{
		pPart = (AecDbX3dPart*)m_arX3DPartPtrs.at(i);
		if (pPart->GetSpecialtyData()->HasKey(_T("DTYG_TYPE"), nvt))
		{
			if (pPart->GetX3dSolidCount() <= 0) continue;
			AcDbX3dSolid *pSolid(pPart->GetX3dSolid(0));
			if (!pSolid) continue;
			pSolid->TransformBy(xform);
			pPart->Create();
		}
		else
		{
			pPart->AddMove(ptOrg.asVector());
		}
	}

	return Acad::eOk;
}

void AecDbBDPipeBase::subList() const
{
	assertReadEnabled();
	AecDbEwPipeBase::subList();
	
	TCHAR szHandle[256];
	acutPrintf(_T("\n关联对象%d个."),m_arAssocPartEntIds.length());
	for(int i = 0;i < m_arAssocPartEntIds.length();i++)
	{

//#if ADS > 141		
//		m_arAssocPartEntIds.at(i).handle().getIntoAsciiBuffer(szHandle,256);
//#else
		m_arAssocPartEntIds.at(i).handle().getIntoAsciiBuffer(szHandle);
//#endif
		acutPrintf(_T("\n句柄 = %s"),szHandle);
	}

	for (int ii = 0;ii < m_arX3DPartPtrs.length();ii++)
	{
		const AecDbX3dPart* pPart = m_arX3DPartPtrs.at(ii);
		pPart->List();
	}
}

void AecDbBDPipeBase::GetDTYGs(std::vector<AecDbX3dPart*> &xparts)
{
	int nVt(0);
	CString sName(_T(""));
	AecDbX3dPart* pPart = NULL;
	for (int i = 0;i < m_arX3DPartPtrs.length();i++)
	{
		pPart = (AecDbX3dPart*)m_arX3DPartPtrs.at(i);
		if (!pPart) continue;
		if (pPart->GetSpecialtyData()->HasKey(_T("DTYG_TYPE"), nVt))
			xparts.push_back(pPart);
	}
}

void AecDbBDPipeBase::GetDTYGsByName(LPCTSTR pszName, std::vector<CString>& guids)
{
	if (!pszName) return;

	int nVt(0);
	CString sName(_T(""));
	AecDbX3dPart* pPart = NULL;
	for (int i = 0;i < m_arX3DPartPtrs.length();i++)
	{
		pPart = (AecDbX3dPart*)m_arX3DPartPtrs.at(i);
		if (!pPart) continue;
		if (!pPart->GetSpecialtyData()->HasKey(_T("DTYG_TYPE"), nVt)) continue;

		pPart->GetName(sName);

		nVt = sName.Find(pszName);
		if (nVt != -1)
			guids.push_back(pPart->GetGUID());
	}
}

bool AecDbBDPipeBase::TransformDTYGPartEnt(const AcGeMatrix3d & xform)
{
	if (!objectId().isValid()) return false;
	std::vector<AecDbX3dPart*> parts(0);
	GetDTYGs(parts);
	if (parts.empty()) return false;

	CString sType(_T("")), sReg(_T(""));
	std::vector<CString> regs1, regs2;
	AcGePoint3d pt1, pt2, pOrg;
	AcGeVector3d vt;
	double d1, d2;
	for (size_t i = 0; i < parts.size(); ++i)
	{
		AecDbX3dPart *pPart(parts[i]);
		if (!pPart) continue;
		if (pPart->GetX3dSolidCount() <= 0) continue;
		if (!pPart->GetSpecialtyData()->GetAt(_T("DTYG_TYPE"), sType)) continue;
		AcDbX3dSolid *pSolid(pPart->GetX3dSolid(0));
		if (!pSolid) continue;


		if (sType == _T("立方体")
			|| sType == _T("圆柱")
			|| sType == _T("圆台")
			|| sType == _T("四方台")
			|| sType == _T("楔形体")
			|| sType == _T("球台")
			|| sType == _T("球体") )
		{
			pOrg = pSolid->GetOrgPoint();
			pOrg.transformBy(xform);
			pSolid->SetOrgPoint(pOrg);
		}
		//else if (sType == _T("圆柱"))
		//{
		//}
		//else if (sType == _T("圆台"))
		//{
		//}
		//else if (sType == _T("四方台"))
		//{
		//}
		//else if (sType == _T("楔形体"))
		//{
		//}
		//else if (sType == _T("球台"))
		//{
		//}
		//else if (sType == _T("球体"))
		//{
		//}
		else if (sType == _T("拉伸体") || sType == _T("切割"))
		{
			if (!pSolid->GetExturd2Data(sReg, pt1, pt2)) continue;
			AcDbRegion *pReg = CoreTools::StringToRegion(sReg);
			if (pReg)
			{
				pReg->transformBy(xform);
				pt1.transformBy(xform);
				pt2.transformBy(xform);
				if (CoreTools::RegionToString(pReg, sReg))
					pSolid->SetExturd2Data(sReg, pt1, pt2);
				DELETE_PTR(pReg);
			}
		}
		else if (sType == _T("旋转体"))
		{
			if (!pSolid->GetRevolve2Data(sReg, pt1, vt, d1, d2)) continue;
			AcDbRegion *pReg = CoreTools::StringToRegion(sReg);
			if (pReg)
			{
				pReg->transformBy(xform);
				AcDbRay ray;
				ray.setUnitDir(vt);
				ray.setBasePoint(pt1);
				ray.transformBy(xform);
				vt = ray.unitDir();
				pt1 = ray.basePoint();
				if (CoreTools::RegionToString(pReg, sReg))
					pSolid->SetRevolve2Data(sReg, pt1, vt, d1, d2);
				DELETE_PTR(pReg);
			}
			
		}
		else if (sType == _T("放样体"))
		{
			regs1.clear();
			regs2.clear();
			if (!pSolid->GetLoftData(regs1)) continue;
			for (size_t i = 0; i < regs1.size(); ++i)
			{
				CString &s = regs1[i];
				AcDbRegion *pReg = CoreTools::StringToRegion(s);
				if (pReg)
				{
					pReg->transformBy(xform);
					if (CoreTools::RegionToString(pReg, sReg))
						regs2.push_back(sReg);
					DELETE_PTR(pReg);
				}
			}
			pSolid->SetLoftData(regs2);
		}
		else if (sType == _T("扫掠体"))
		{
			AcDbCurve *pCurve(NULL);
			if (pSolid->GetSweepData(sReg, pCurve))
			{
				AcDbRegion *pReg = CoreTools::StringToRegion(sReg);
				if (pReg)
				{
					pReg->transformBy(xform);
					pCurve->transformBy(xform);
					if (CoreTools::RegionToString(pReg, sReg))
						pSolid->SetSweepData(sReg, pCurve);
					DELETE_PTR(pReg);
				}
				DELETE_PTR(pCurve);
			}
		}
		else
		{
			continue;
		}
		pSolid->ReCreate();
		pPart->Create();
	}

	return true;
}

Acad::ErrorStatus AecDbBDPipeBase::TransformAssocPartEnt(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();

	AcDbObjectId id;
	AcDbEntity* pEnt = NULL;
	Acad::ErrorStatus es;

	if (objectId().isValid())
	{
		for (int i = 0;i < m_arAssocPartEntIds.length();i++)
		{
			id = m_arAssocPartEntIds.at(i);
			if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite)))
			{
				pEnt->transformBy(xform);
				pEnt->close();
			}
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbBDPipeBase::HoleAndPipeExtend(double dThickAdd,const AcGeVector3d& vtAdd)
{
	AcDbObjectId id;
	AcDbEntity* pEnt = NULL;
	Acad::ErrorStatus es;

	if (objectId().isValid())
	{
		for (int i = 0;i < m_arAssocPartEntIds.length();i++)
		{
			id = m_arAssocPartEntIds.at(i);
			if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite)))
			{
				AecDbX3dPartEntity* pPart = AecDbX3dPartEntity::cast(pEnt);
				if (pPart != NULL)
				{
					pPart->HoleAndPipeExtend(dThickAdd,vtAdd);
				}
				pEnt->close();
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbBDPipeBase::subGetOsnapPoints(  AcDb::OsnapMode     osnapMode,
													   INT_PTR             gsSelectionMark,
													   const AcGePoint3d&  pickPoint,
													   const AcGePoint3d&  lastPoint,
													   const AcGeMatrix3d& viewXform,
													   AcGePoint3dArray&   snapPoints,
													   AcDbIntArray&       geomIds) const
{
	assertReadEnabled();
	return AecDbEwPipeBase::subGetOsnapPoints(osnapMode,gsSelectionMark,pickPoint,lastPoint,viewXform,snapPoints,geomIds);
}

Acad::ErrorStatus AecDbBDPipeBase::subErase(Adesk::Boolean erasing)
{
	if (erasing)
	{
		AcDbObjectId id;
		AcDbEntity* pEnt = NULL;
		Acad::ErrorStatus es;

		for (int i = 0;i < m_arAssocPartEntIds.length();i++)
		{
			id = m_arAssocPartEntIds.at(i);
			if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite)))
			{
				pEnt->erase(erasing);
				pEnt->close();
			}
		}
	}
	return AecDbEwPipeBase::subErase(erasing);
}

void AecDbBDPipeBase::erased(const AcDbObject* dbObj,Adesk::Boolean pErasing/* = true*/)
{
	//acutPrintf(_T("ent:%s erased!"),dbObj->isA()->name());
	if (dbObj != NULL)
	{
		if (dbObj->isKindOf(AecDbX3dPartEntity::desc()))
		{
			//重新刷新三维
			Clean3DBuffer();

			if (!cloneMeForDragging())
			{
				acedPostCommand(_T("regen "));
			}
		}
	}
}

void AecDbBDPipeBase::modified(const AcDbObject* dbObj)
{
	if (dbObj != NULL)
	{
		if (dbObj->isKindOf(AecDbX3dPartEntity::desc()))
		{
			//重新刷新三维
			Clean3DBuffer();

			if (!cloneMeForDragging())
			{
				acedPostCommand(_T("regen "));
			}
		}
	}
}

void AecDbBDPipeBase::modifyUndone(const AcDbObject* dbObj)
{
	if (dbObj != NULL)
	{
		if (dbObj->isKindOf(AecDbX3dPartEntity::desc()))
		{
			//重新刷新三维
			Clean3DBuffer();
			if (!cloneMeForDragging())
			{
				acedPostCommand(_T("regen "));
			}
		}
	}
}

//添加套管符号
void AecDbBDPipeBase::AddTPipeDim(const AcGeVector3d& vtNorm,AcDbLine* pLnCen,AecDbObjXDataMap* pxDataT,AcDbVoidPtrArray& arEntPtrs,const AcGeMatrix3d& xform) const
{
	if (pLnCen != NULL && pxDataT != NULL)
	{
		AcDbObjectId idPipe = KTSetting::InitLayer(LAY_PIPE_OUTSIDE);

		AcGePoint3d ptS = pLnCen->startPoint();
		AcGePoint3d ptE = pLnCen->endPoint();

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

		if (vtLn.isPerpendicularTo(vtNorm))//
		{
			AcGeVector3d vtXY = vtLn.crossProduct(vtNorm);
			vtXY.normalize();

			AcGePoint3d pt1,pt2,ptGe[2];
			CString sType;
			int nShape = 0,bNoDraw = 0;
			pxDataT->GetAt(_T("nShape"),nShape);
			pxDataT->GetAt(KEY_CENNODRAW,bNoDraw);
			pxDataT->GetAt(KEY_PIPETYPE, sType);

			if (bNoDraw)//中心线不画标识
			{
				return;
			}

			if (nShape == eCircle)//circle
			{
				AcGePoint3d pts[2], pte[2];
				double dD = 0.0,dT = 0.0;
				pxDataT->GetAt(_T("dD"),dD);
				pxDataT->GetAt(_T("dH"),dT);

				pt1 = MidPoint(ptS,ptE);
				pt1 += vtXY * 0.5 * dD;

				ptGe[0] = pt1 - vtLn * 0.5 * dT;
				ptGe[1] = pt1 + vtLn * 0.5 * dT;
				AcDbLine* pLn = new AcDbLine(ptGe[0],ptGe[1]);
				pLn->transformBy(xform);
				pLn->setLayer(idPipe);

				if (pxDataT != NULL)
				{
					pxDataT->Write(pLn,BIMDATA_APP);
				}
				arEntPtrs.append(pLn);

				pts[0] = ptGe[0];
				pte[0] = ptGe[1];

				ptGe[0] = pt1;
				ptGe[1] = pt1 + vtXY * 0.15 * dD;
				pLn = new AcDbLine(ptGe[0],ptGe[1]);
				pLn->transformBy(xform);
				pLn->setLayer(idPipe);

				if (pxDataT != NULL)
				{
					pxDataT->Write(pLn,BIMDATA_APP);
				}
				arEntPtrs.append(pLn);

				pt1 -= vtXY * dD;
				ptGe[0] = pt1 - vtLn * 0.5 * dT;
				ptGe[1] = pt1 + vtLn * 0.5 * dT;
				pLn = new AcDbLine(ptGe[0],ptGe[1]);
				pLn->transformBy(xform);
				pLn->setLayer(idPipe);

				if (pxDataT != NULL)
				{
					pxDataT->Write(pLn,BIMDATA_APP);
				}
				arEntPtrs.append(pLn);

				pts[1] = ptGe[0];
				pte[1] = ptGe[1];

				ptGe[0] = pt1;
				ptGe[1] = pt1 - vtXY * 0.15 * dD;
				pLn = new AcDbLine(ptGe[0],ptGe[1]);
				pLn->transformBy(xform);
				pLn->setLayer(idPipe);

				if (pxDataT != NULL)
				{
					pxDataT->Write(pLn,BIMDATA_APP);
				}
				arEntPtrs.append(pLn);

				if (sType.Find(_T("柔性")) != -1)
				{
					ptGe[0] = pts[0];
					ptGe[1] = pts[0] + vtXY * 0.15 * dD;
					pLn = new AcDbLine(ptGe[0], ptGe[1]);
					pLn->transformBy(xform);
					pLn->setLayer(idPipe);

					if (pxDataT != NULL)
					{
						pxDataT->Write(pLn, BIMDATA_APP);
					}
					arEntPtrs.append(pLn);

					ptGe[0] = pte[0];
					ptGe[1] = pte[0] + vtXY * 0.15 * dD;
					pLn = new AcDbLine(ptGe[0], ptGe[1]);
					pLn->transformBy(xform);
					pLn->setLayer(idPipe);

					if (pxDataT != NULL)
					{
						pxDataT->Write(pLn, BIMDATA_APP);
					}
					arEntPtrs.append(pLn);

					ptGe[0] = pts[1];
					ptGe[1] = pts[1] - vtXY * 0.15 * dD;
					pLn = new AcDbLine(ptGe[0], ptGe[1]);
					pLn->transformBy(xform);
					pLn->setLayer(idPipe);

					if (pxDataT != NULL)
					{
						pxDataT->Write(pLn, BIMDATA_APP);
					}
					arEntPtrs.append(pLn);

					ptGe[0] = pte[1];
					ptGe[1] = pte[1] - vtXY * 0.15 * dD;
					pLn = new AcDbLine(ptGe[0], ptGe[1]);
					pLn->transformBy(xform);
					pLn->setLayer(idPipe);

					if (pxDataT != NULL)
					{
						pxDataT->Write(pLn, BIMDATA_APP);
					}
					arEntPtrs.append(pLn);
				}
			}
			else//rect
			{
				double dH = 0.0,dW = 0.0,dT = 0.0;
				pxDataT->GetAt(_T("dW"),dH);
				pxDataT->GetAt(_T("dL"),dW);
				pxDataT->GetAt(_T("dH"),dT);

				double dD = dH;
				if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))
					dD = dW;

				pt1 = MidPoint(ptS,ptE);
				pt1 += vtXY * 0.5 * dD;

				ptGe[0] = pt1 - vtLn * 0.5 * dT;
				ptGe[1] = pt1 + vtLn * 0.5 * dT;
				AcDbLine* pLn = new AcDbLine(ptGe[0],ptGe[1]);
				pLn->transformBy(xform);
				pLn->setLayer(idPipe);

				if (pxDataT != NULL)
				{
					pxDataT->Write(pLn,BIMDATA_APP);
				}
				arEntPtrs.append(pLn);

				ptGe[0] = pt1;
				ptGe[1] = pt1 + vtXY * 0.15 * dD;
				pLn = new AcDbLine(ptGe[0],ptGe[1]);
				pLn->transformBy(xform);
				pLn->setLayer(idPipe);

				if (pxDataT != NULL)
				{
					pxDataT->Write(pLn,BIMDATA_APP);
				}
				arEntPtrs.append(pLn);

				pt1 -= vtXY * dD;
				ptGe[0] = pt1 - vtLn * 0.5 * dT;
				ptGe[1] = pt1 + vtLn * 0.5 * dT;
				pLn = new AcDbLine(ptGe[0],ptGe[1]);
				pLn->transformBy(xform);
				pLn->setLayer(idPipe);

				if (pxDataT != NULL)
				{
					pxDataT->Write(pLn,BIMDATA_APP);
				}
				arEntPtrs.append(pLn);

				ptGe[0] = pt1;
				ptGe[1] = pt1 - vtXY * 0.15 * dD;
				pLn = new AcDbLine(ptGe[0],ptGe[1]);
				pLn->transformBy(xform);
				pLn->setLayer(idPipe);

				if (pxDataT != NULL)
				{
					pxDataT->Write(pLn,BIMDATA_APP);
				}
				arEntPtrs.append(pLn);
			}
		}
	}
}

void AddRegionPolyline(AcDbRegion *pRegionT, AcDbVoidPtrArray &arRegionPtrs, const AecDbObjXDataMap &mapSetup);
void ConvertToPolyline(const AecDbObjXDataMap &mapSetup,AcDbVoidPtrArray& arCurPtrs, AcDbVoidPtrArray &arRegionPtrs)
{
	double dWallW = 0.0;
	mapSetup.GetAt(KEY_WALLW, dWallW);

	AcDbEntity *pEnt = NULL;
	for (int i = 0; i < arCurPtrs.length(); i++)
	{
		pEnt = (AcDbEntity *)arCurPtrs.at(i);

		AcDbLine *pLn = AcDbLine::cast(pEnt);
		AcDbPolyline *pPlT = AcDbPolyline::cast(pEnt);
		AcDbRegion *pReg = AcDbRegion::cast(pEnt);
		AcDbSpline *pSp = AcDbSpline::cast(pEnt);

		//acutPrintf(_T("\nClass:%s"),pEnt->isA()->name());

		if (pLn != NULL)
		{
			AcDbPolyline *pPl = new AcDbPolyline;
			pPl->addVertexAt(0, pLn->startPoint().convert2d(AcGePlane::kXYPlane));
			pPl->addVertexAt(1, pLn->endPoint().convert2d(AcGePlane::kXYPlane));

			pPl->setConstantWidth(dWallW);

			arRegionPtrs.append(pPl);
		}
		else if (pPlT != NULL)
		{
			pPlT->setConstantWidth(dWallW);
			arRegionPtrs.append(pPlT);
		}
		else if (pReg != NULL)
		{
			AddRegionPolyline(pReg, arRegionPtrs, mapSetup);
		}
		else if (pSp != NULL)
		{
			AcDbCurve *pPlCrv = NULL;
			pSp->toPolyline(pPlCrv);

			if (pPlCrv != NULL)
			{
				AcDbPolyline *pPl = AcDbPolyline::cast(pPlCrv);
				if (pPl != NULL)
				{
					pPl->setConstantWidth(dWallW);
					arRegionPtrs.append(pPl);
				}
				else
				{
					//acutPrintf(_T("\nClass:%s"),pPlCrv->isA()->name());
					arRegionPtrs.append(pPlCrv);
				}
			}
		}
		else
		{
			//acutPrintf(_T("\nClass:%s"),pEnt->isA()->name());
			arRegionPtrs.append(pEnt);
		}
	}
}

void AddRegionPolyline(AcDbRegion* pRegionT,AcDbVoidPtrArray& arRegionPtrs,const AecDbObjXDataMap& mapSetup)
{
	if (pRegionT != NULL)
	{
		AcDbVoidPtrArray arCurPtrs;
		pRegionT->explode(arCurPtrs);

		ConvertToPolyline(mapSetup,arCurPtrs,arRegionPtrs);
	}
}

AcGeBoundBlock3d *CreateExtent3dBound(const AcGePoint3d &ptFr, const AcGePoint3d &ptTo, const AcGeVector3d &vtTo)
{
	AcGeVector3d vt1 = ptTo - ptFr;
	AcGeVector3d vtZ = vt1.crossProduct(vtTo);
	vtZ.normalize();

	AcGePoint3d ptGe[5];
	ptGe[0] = ptFr + vtZ * 1.e6;//1000米
	ptGe[1] = ptFr - vtZ * 1.e6;//1000米
	ptGe[2] = ptTo - vtZ * 1.e6;//1000米
	ptGe[3] = ptTo + vtZ * 1.e6;//1000米
	ptGe[4] = ptGe[0];

	vt1 = ptGe[1] - ptGe[0];
	AcGeVector3d vt2 = ptGe[3] - ptGe[0];
	AcGeVector3d vt3 = vtTo;

	AcGeBoundBlock3d *pBound = new AcGeBoundBlock3d;
	pBound->set(ptGe[0], vt1, vt2, vt3);
	return pBound;
}

AcDb3dSolid * CreateExtent3dBox(const AcGePoint3d& ptFr, const AcGePoint3d& ptTo, const AcGeVector3d& vtTo)
{
	AcGeVector3d vt1 = ptTo - ptFr;
	AcGeVector3d vtZ = vt1.crossProduct(vtTo);
	vtZ.normalize();

	AcGePoint3d ptGe[5];
	ptGe[0] = ptFr + vtZ * 1.e6;//1000米
	ptGe[1] = ptFr - vtZ * 1.e6;//1000米
	ptGe[2] = ptTo - vtZ * 1.e6;//1000米
	ptGe[3] = ptTo + vtZ * 1.e6;//1000米
	ptGe[4] = ptGe[0];

	AcGePoint3d ptS = MidPoint(ptGe[0], ptGe[2]);
	AcGePoint3d ptE = ptS + vtTo;

	AcDbLine ln;
	ln.setStartPoint(ptS);
	ln.setEndPoint(ptE);

	AcDbRegion *pRegionT = CreatePolygonRegionOnly(ptGe, 5);
	if (pRegionT != NULL)
	{
		AcDb3dSolid *pSolidBox = new AcDb3dSolid;
		if (Acad::eOk == pSolidBox->extrudeAlongPath(pRegionT, &ln))
		{
			delete pRegionT;
			return pSolidBox;
		}
		delete pRegionT;
	}
	return NULL;
}

//包含素砼的剖切
int AecDbBDPipeBase::GetSectionDraw(const AcGePoint3d &ptFr, const AcGePoint3d &ptTo, const AcGeVector3d &vtViewDir, const AcGeVector3d &vtTo, AcDbVoidPtrArray &arRegionPtrs) const
{
	assertReadEnabled();

	int nIndexFr = arRegionPtrs.length();

	AecDbObjXDataMap mapSetup;
	const AecDbObjXDataMap *pSpecXData = GetSpecialtyData();
	pSpecXData->GetAt(KEY_PQSZ, 9999, mapSetup);

	BOOL bHatch = FALSE;
	mapSetup.GetAt(KEY_QLBZHATCH, bHatch);
	bHatch = AecDbEwPipeBase::hasHatch(this, bHatch);

	//如果仅仅是切
	AcDb3dSolid *pDraw3dSolid = NULL;
	if (vtTo.isZeroLength())
	{
		if (Get3DBuffer().length() == 0)
		{
			AcGiViewDraw dc(NULL, NULL);
			Draw3d(dc);
		}

		pDraw3dSolid = GetDraw3dSolid(false);
		if (pDraw3dSolid != NULL)
		{
			//三维求交
			AcDb3dSolid *pSolid3dExt = CreateExtent3dBox(ptFr, ptTo, vtTo);
			if (pSolid3dExt != NULL)
			{
				if (Acad::eOk != pDraw3dSolid->booleanOper(AcDb::kBoolIntersect, pSolid3dExt))
				{
					pDraw3dSolid = GetDraw3dSolid(false);
				}
			}

			AcGeBoundBlock3d *pBound3d = CreateExtent3dBound(ptFr, ptTo, vtTo);

			AcDbRegion *pRegionT = NULL;

			AcGeVector3d vtLn = ptTo - ptFr;
			AcGeVector3d vtNorm = vtLn.crossProduct(vtViewDir);

			AcGePlane plan;
			plan.set(ptFr, vtNorm);

			pDraw3dSolid->getSection(plan, pRegionT);

			if (pRegionT != NULL)//可切
			{
				AcGeMatrix3d xformPlanToWorld;
				xformPlanToWorld.setToPlaneToWorld(plan);
				xformPlanToWorld.invert();

				pRegionT->transformBy(xformPlanToWorld);
				pRegionT->setLayer(layerId());

				AddRegionPolyline(pRegionT, arRegionPtrs, mapSetup);
				//arRegionPtrs.append(pRegionT);

				//填充
				AcDbVoidPtrArray arHatchPtrs;

				if (bHatch)
				{
					CString sPattern;
					GetSectionHatchPattern(sPattern);
					RegionHatch(pRegionT, arHatchPtrs, sPattern);
					if (!arHatchPtrs.isEmpty())
					{
						arRegionPtrs.append(arHatchPtrs);
					}
				}

				SetSectionLayer(nIndexFr, arRegionPtrs, layerId());

				nIndexFr = arRegionPtrs.length();

				//附属物
				AcDbVoidPtrArray arSolidPtrs, arCenLnPtrs;
				GetAllHolesSolid(arSolidPtrs, arCenLnPtrs, xformPlanToWorld, pBound3d);

				CString sName;
				AecDbObjXDataMap xDataT;

				AcDbLine *pLnCen = NULL;
				for (int ii = 0; ii < arCenLnPtrs.length(); ii++)
				{
					AcDbEntity *pCenEnt = (AcDbEntity *)arCenLnPtrs.at(ii);

					//根据arCenLnPtrs 绘制套管
					xDataT.Empty();
					xDataT.Read(pCenEnt, BIMDATA_APP);

					if (xDataT.GetAt(KEY_NAME, sName))
					{
						if (sName.CompareNoCase(_T("套管")) == 0)
						{
							//添加套管符号
							pLnCen = AcDbLine::cast(pCenEnt);
							if (pLnCen != NULL)
								AddTPipeDim(plan.normal(), pLnCen, &xDataT, arRegionPtrs, xformPlanToWorld);
						}
					}

					pCenEnt->transformBy(xformPlanToWorld);

					AcDbObjectId idLt = pCenEnt->linetypeId();
					if (idLt != KTSetting::InitLineStyle(_T("DASH")))
					{
						pCenEnt->setLayer(KTSetting::InitLayer(_T("LAY_CL"), true));
						pCenEnt->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
					}

					arRegionPtrs.append(pCenEnt);
				}

				AcDb3dSolid *pSolidT = NULL;
				AcDbEntity *pEntT = NULL;
				for (int k = 0; k < arSolidPtrs.length(); k++)
				{
					pEntT = (AcDbEntity *)arSolidPtrs.at(k);
					pSolidT = AcDb3dSolid::cast(pEntT);
					if (pSolidT != NULL)
					{
						pRegionT = NULL;
						pSolidT->getSection(plan, pRegionT);

						if (pRegionT != NULL)
						{
							pRegionT->transformBy(xformPlanToWorld);
							pRegionT->setLayer(pSolidT->layer());

							//如果是套管标注
							pRegionT->setLayer(layerId());
							arRegionPtrs.append(pRegionT);
						}
						delete pSolidT;
					}
				}
			}
			delete pDraw3dSolid;
			delete pBound3d;
		}
		return arRegionPtrs.length();
	}

	AcGePlane plan;
	AcGeVector3d vtU = ptTo - ptFr;

	Acad::ErrorStatus es = Acad::eOk;
	plan.set(ptFr, vtU, vtViewDir);

	if (AecDbEwPipeBase::GetSectionDraw(plan, vtTo, arRegionPtrs))
	{
		SetSectionLayer(nIndexFr, arRegionPtrs, layerId());
		return arRegionPtrs.length();
	}

	AcGePlane plan2;
	plan2.set(ptFr, vtTo);

	AcGeMatrix3d xform;
	xform.setToPlaneToWorld(plan);
	xform.invert();

	if (Get3DBuffer().length() == 0)
	{
		AcGiViewDraw dc(NULL, NULL);
		Draw3d(dc);
	}

	pDraw3dSolid = GetDraw3dSolid(false);
	if (pDraw3dSolid == NULL)
	{
		SetSectionLayer(nIndexFr, arRegionPtrs, layerId());
		return 0;
	}

	//三维求交
	AcDb3dSolid *pSolid3dExt = CreateExtent3dBox(ptFr, ptTo, vtTo);
	if (pSolid3dExt != NULL)
	{
		if (Acad::eOk != pDraw3dSolid->booleanOper(AcDb::kBoolIntersect, pSolid3dExt))
		{
			pDraw3dSolid = GetDraw3dSolid(false);
		}
	}

	AcDbExtents ext;
	pDraw3dSolid->getGeomExtents(ext);

	double dX = ext.maxPoint().x - ext.minPoint().x;
	double dY = ext.maxPoint().y - ext.minPoint().y;
	double dz = ext.maxPoint().z - ext.minPoint().z;
	double dMaxL = __max(dX, dY);
	dMaxL = __max(dMaxL, dz);
	dMaxL += 200.0;

	AcGePoint3d ptGe[5];

	ptGe[0] = ptFr;
	ptGe[1] = ptTo;
	ptGe[2] = ptTo + vtTo;
	ptGe[3] = ptFr + vtTo;
	ptGe[4] = ptGe[0];

	AcGeVector3d vtLook = vtViewDir;

	//提取8个点
	AcGePoint3d ptGeT[8];
	AcGePoint3dArray arBoxPts;

	ptGeT[0] = ext.minPoint();

	ptGeT[1] = ptGeT[0];
	ptGeT[1].x = ext.maxPoint().x;

	ptGeT[2] = ptGeT[1];
	ptGeT[2].y = ext.maxPoint().y;

	ptGeT[3] = ptGeT[0];
	ptGeT[3].y = ext.maxPoint().y;

	for (int i = 0; i < 4; i++)
	{
		arBoxPts.append(ptGeT[i]);
		ptGeT[i].z = ext.maxPoint().z;
		arBoxPts.append(ptGeT[i]);
	}

	AcDbLine ln3d;
	ln3d.setStartPoint(arBoxPts.first());
	AcGePoint3d ptE = arBoxPts.first() + vtViewDir * 1.5;
	ln3d.setEndPoint(ptE);

	AecCoverBooleanOper::SortPoints(arBoxPts, &ln3d, true);

	AcGePoint3d ptNear = arBoxPts.last();
	AcGePoint3d ptFar = arBoxPts.first();
	AcGePoint3d ptMid = MidPoint(ptNear, ptFar);

	AcGeVector3d vtN2F = ptFar - ptNear;
	vtN2F *= 0.6;
	ptFar = ptMid + vtN2F;
	ptNear = ptMid - vtN2F;
	vtN2F *= 2.0;

	AcGePlane planNear(ptNear, vtLook);
	AcGePoint3d ptOnMin;
	ptOnMin = planNear.closestPointTo(ptGe[0]);

	//调整到Near面
	AcGeVector3d vtM = ptOnMin - ptGe[0];
	for (int k = 0; k < 5; k++)
	{
		ptGe[k] += vtM;
	}

	//Near-->Far 拉伸路径
	AcDbLine lnPath;
	lnPath.setStartPoint(ptGe[0]);
	ptE = ptGe[0] + vtN2F;
	lnPath.setEndPoint(ptE);

	struct resbuf rb;
	acedGetVar(_T("useri3"), &rb);

	AcDbRegion *pRegionT = CreatePolygonRegionOnly(ptGe, 5);
	if (pRegionT != NULL)
	{
		AcDb3dSolid *pSolidBox = new AcDb3dSolid;
		if (Acad::eOk == pSolidBox->extrudeAlongPath(pRegionT, &lnPath))
		{
			pSolidBox->setColorIndex(kRed);

			if (rb.resval.rint == 1358)//特定情况下
			{
				//TEST
				AcDb3dSolid *pSolidBoxCn = (AcDb3dSolid *)pSolidBox->clone();
				pSolidBoxCn->setColorIndex(kRed);
				AddToModelSpace(pSolidBoxCn);
			}
		}
		else
		{
			if (rb.resval.rint == 1358)//特定情况下
			{
				//TEST
				pRegionT->setColorIndex(kRed);
				AddToModelSpace(pRegionT);
				return 0;
			}
		}

		AcGeBoundBlock3d* pBound3d = CreateExtent3dBound(ptFr,ptTo,vtTo);
		AcDb3dSolid *pSolidBoxCln = (AcDb3dSolid *)pSolidBox->clone();
		AcDb3dSolid *pSolidCln = (AcDb3dSolid *)pDraw3dSolid->clone();
		pSolidCln->setRecordHistory(true);
		pSolidCln->booleanOper(AcDb::kBoolIntersect, pSolidBox);

		AcDbVoidPtrArray arRegPtrs;

		//如果plan和 pSolidCln 相交
		//根据材质填充,如果切到的墙体
		AcDbRegion *pRegionSec = NULL;
		pSolidCln->getSection(plan, pRegionSec);
		if (pRegionSec != NULL)
		{
			pRegionSec->transformBy(xform);

			AddRegionPolyline(pRegionSec, arRegionPtrs, mapSetup);
			//arRegPtrs.append(pRegionSec);

			//由于pSolidCln->booleanOper(AcDb::kBoolIntersect, pSolidBox); 再投影补上洞口线
			AcDbVoidPtrArray arTemp;
			OrthoProjected3DSolid(pSolidCln, plan, xform, arTemp);
			ConvertToPolyline(mapSetup,arTemp, arRegionPtrs);

			AcDbVoidPtrArray arHatchPtrs;

			if (bHatch)
			{
				CString sPattern;
				GetSectionHatchPattern(sPattern);
				RegionHatch(pRegionSec, arHatchPtrs, sPattern);
				if (!arHatchPtrs.isEmpty())
				{
					arRegionPtrs.append(arHatchPtrs);
				}
			}

			delete pRegionSec;

			AcDbVoidPtrArray arSolidPtrs, arCenLnPtrs;
			GetAllHolesSolid(arSolidPtrs, arCenLnPtrs, xform,pBound3d);

			CString sName;
			AecDbObjXDataMap xDataT;

			AcDbLine *pLnCen = NULL;
			for (int ii = 0; ii < arCenLnPtrs.length(); ii++)
			{
				AcDbEntity *pCenEnt = (AcDbEntity *)arCenLnPtrs.at(ii);
				if (pCenEnt != NULL)
				{
					//根据arCenLnPtrs 绘制套管
					xDataT.Empty();
					xDataT.Read(pCenEnt, BIMDATA_APP);

					if (xDataT.GetAt(KEY_NAME, sName))
					{
						if (sName.CompareNoCase(_T("套管")) == 0)
						{
							//添加套管符号
							pLnCen = AcDbLine::cast(pCenEnt);
							if (pLnCen != NULL)
								AddTPipeDim(plan.normal(), pLnCen, &xDataT, arRegionPtrs, xform);
						}
					}

					pCenEnt->transformBy(xform);

					AcDbObjectId idLt = pCenEnt->linetypeId();
					if (idLt != KTSetting::InitLineStyle(_T("DASH")))
					{
						pCenEnt->setLayer(KTSetting::InitLayer(_T("LAY_CL"), true));
						pCenEnt->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
					}
					arRegPtrs.append(pCenEnt);
				}
			}

			AcDb3dSolid *pSolidT = NULL;
			AcDbEntity *pEntT = NULL;

			for (int k = 0; k < arSolidPtrs.length(); k++)
			{
				pEntT = (AcDbEntity *)arSolidPtrs.at(k);
				pSolidT = AcDb3dSolid::cast(pEntT);
				if (pSolidT != NULL)
				{
					//如果是门窗洞口,则不加getSection结果,门窗已经用符号代替
					if (pSolidT->visibility() == AcDb::kInvisible)
					{
						delete pSolidT;
						continue;
					}

					pRegionSec = NULL;
					pSolidT->getSection(plan, pRegionSec);

					if (pRegionSec != NULL)
					{
						pRegionSec->transformBy(xform);

						pRegionSec->setLayer(layerId());

						AddRegionPolyline(pRegionSec, arRegionPtrs, mapSetup);

						//arRegPtrs.append(pRegionSec);
						delete pRegionSec;
					}
					delete pSolidT;
				}
			}
		}
		else
		{
			//不科切，投影
			AcDbVoidPtrArray arSolidPtrs, arCenLnPtrs;
			GetAllHolesSolid(arSolidPtrs, arCenLnPtrs, xform, pBound3d);
			FreeBuffer(0, arSolidPtrs);

			CString sName;
			AecDbObjXDataMap xDataT;

			for (int kk = 0; kk < arCenLnPtrs.length(); kk++)
			{
				AcDbEntity *pEntT = (AcDbEntity *)arCenLnPtrs.at(kk);
				if (pEntT != NULL)
				{
					//根据arCenLnPtrs 绘制套管
					xDataT.Empty();
					xDataT.Read(pEntT, BIMDATA_APP);

					if (xDataT.GetAt(KEY_NAME, sName))
					{
						if (sName.CompareNoCase(_T("套管")) == 0)
						{
							//添加套管符号
							AcDbLine *pLn = AcDbLine::cast(pEntT);
							if (pLn != NULL)
								AddTPipeDim(plan.normal(), pLn, &xDataT, arRegPtrs, xform);
						}
					}
					pEntT->transformBy(xform);
				}
			}

			//投影
			OrthoProjected3DSolid(pSolidCln, plan, xform, arRegPtrs);

			if (!arCenLnPtrs.isEmpty())
				arRegPtrs.append(arCenLnPtrs);
		}

		if (rb.resval.rint == 1358)//特定情况下
		{
			//TEST
			pSolidCln->setColorIndex(kRed);
			AddToModelSpace(pSolidCln);
		}
		else
		{
			DELETE_PTR(pSolidCln);
		}
		DELETE_PTR(pRegionT);
		DELETE_PTR(pSolidBox);
		DELETE_PTR(pBound3d);

		if (!arRegPtrs.isEmpty())
		{
			arRegionPtrs.append(arRegPtrs);
		}

		if (rb.resval.rint == 1358)//特定情况下
		{
			//TEST
			pDraw3dSolid->setColorIndex(3);
			AddToModelSpace(pDraw3dSolid);
		}
		else
		{
			DELETE_PTR(pDraw3dSolid);
		}
	}
	SetSectionLayer(nIndexFr, arRegionPtrs, layerId());
	return arRegionPtrs.length();
}

Acad::ErrorStatus AecDbBDPipeBase::GetAllHolesSolid(AcDbVoidPtrArray& arSolidPtrs,AcDbVoidPtrArray& arCenLnPtrs,const AcGeMatrix3d& xform, AcGeBoundBlock3d* pExt3d/* = NULL*/) const
{
	assertReadEnabled();

	AcDb3dSolid* pSolidDraw = GetDraw3dSolid(false,0,false);
	if (pSolidDraw != NULL)
	{
		AcDb3dSolid* pSolidDrawCln = NULL;
		//开洞
		//2.在开除关联的part的对象
		AcDb3dSolid* pSolidPart = NULL;
		AcDbObjectId id;
		AcDbEntity* pEnt = NULL;
		Acad::ErrorStatus es;

		AcDb3dSolid* pSolidT = NULL;
		AcDbEntity* pEntT = NULL;

		double dH = 0.0;
		AcGeVector3d vtZ;
		CString sName;
		AcGePoint3d ptOrg,ptSta,ptEnd;

		for (int i = 0;i < m_arAssocPartEntIds.length();i++)
		{
			id = m_arAssocPartEntIds.at(i);
			if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead)))
			{
				AecDbX3dPartEntity* pPartEnt = AecDbX3dPartEntity::cast(pEnt);
				if (pPartEnt != NULL)
				{	
					sName = pPartEnt->GetName();

					//1.绘制洞口的中心线，符号线
					if ( pPartEnt->GetSpecialtyData(AcDb::kForRead)->GetAt(_T("vtDir"),vtZ) )
					{
						ptOrg = pPartEnt->GetOrgPoint(true);
						pPartEnt->GetSpecialtyData(AcDb::kForRead)->GetAt(_T("dH"),dH);

						if (pExt3d != NULL)
						{
							AcDbVoidPtrArray arSolidPtrs;
							pPartEnt->GetForHouseSubtract(arSolidPtrs);

							if (!arSolidPtrs.isEmpty())
							{
								AcDbEntity *pEntS = (AcDbEntity*)arSolidPtrs.first();

								AcDbExtents ext;
								pEntS->getGeomExtents(ext);

								AcGeBoundBlock3d blk;
								blk.set(ext.minPoint(), ext.maxPoint());

								if (pExt3d->isDisjoint(blk))
								{
									continue;
								}
							}
							FreeBuffer(0, arSolidPtrs);
						}

						vtZ.normalize();
						ptSta = ptOrg - vtZ * 1.2 * dH;
						ptEnd = ptOrg + vtZ * 1.2 * dH;
						AcDbLine* pLn = new AcDbLine(ptSta,ptEnd);//中心线
						pLn->setLayer(KTSetting::InitLayer(_T("LAY_CL"),true));
						pLn->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

						AcDbPoint *pPt = new AcDbPoint;
						pPt->setPosition(ptOrg);
						pPt->setNormal(vtZ);
						pPt->setLayer(KTSetting::InitLayer(_T("LAY_CL"), true));

						AecDbObjXDataMap* pXData = pPartEnt->GetSpecialtyData(AcDb::kForRead);
						if (pXData != NULL)
						{
							AecDbObjXDataMap xData;
							xData.CopyFrom(pXData);

							if (sName.CompareNoCase(_T("开洞")) == 0 || //开洞
								sName.CompareNoCase(_T("套管")) == 0)	//套管
							{
								//洞口或套管写标高
								AecInterface inf;
								if ( pPartEnt->GetInterface(0,inf) )
								{
									int nShap = 0;
									xData.GetAt(_T("nShape"),nShap);//圆

									if (inf.vtDir.isParallelTo(AcGeVector3d::kZAxis))
									{
										if (nShap == (int)eCircle)
										{
											xData.SetAt(KEY_CENEL,inf.ptPos.z);
										}
										else
										{
											xData.SetAt(KEY_BOTMEL,inf.ptPos.z);
										}
									}
									else
									{
										if (nShap == (int)eCircle)
										{
											xData.SetAt(KEY_CENEL,inf.ptPos.z);
										}
										else
										{
											xData.SetAt(KEY_BOTMEL,inf.ptPos.z - 0.5 * inf.dSize2);
										}
									}
								}
							}

							xData.SetAt(KEY_NAME,sName);
							xData.SetAt(KEY_ORGPT,ptOrg);
							xData.Write(pLn,BIMDATA_APP);
							xData.Write(pPt, BIMDATA_APP);
						}
						
						arCenLnPtrs.append(pLn);
						arCenLnPtrs.append(pPt);

						vtZ.transformBy(xform);
						AcGeLine3d ln(AcGePoint3d::kOrigin,vtZ);

						if (AcGePlane::kXYPlane.isPerpendicularTo(ln))//垂直XY面
						{
							ptSta = ptOrg - AcGeVector3d::kXAxis * 1.2 * dH;
							ptEnd = ptOrg + AcGeVector3d::kXAxis * 1.2 * dH;

							pLn = new AcDbLine(ptSta,ptEnd);//中心线
							pLn->setLayer(KTSetting::InitLayer(_T("LAY_CL"),true));
							pLn->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

							if (pXData != NULL)
							{
								AecDbObjXDataMap xData;
								xData.CopyFrom(pXData);
								xData.SetAt(KEY_NAME,sName);
								if (sName.CompareNoCase(_T("开洞")) == 0 || //开洞
									sName.CompareNoCase(_T("套管")) == 0)	//套管
								{
									//洞口或套管写标高
									AecInterface inf;
									if ( pPartEnt->GetInterface(0,inf) )
									{
										int nShap = 0;
										xData.GetAt(_T("nShape"),nShap);//圆

										if (inf.vtDir.isParallelTo(AcGeVector3d::kZAxis))
										{
											if (nShap == (int)eCircle)
											{
												xData.SetAt(KEY_CENEL,inf.ptPos.z);
											}
											else
											{
												xData.SetAt(KEY_BOTMEL,inf.ptPos.z);
											}
										}
										else
										{
											if (nShap == (int)eCircle)
											{
												xData.SetAt(KEY_CENEL,inf.ptPos.z);
											}
											else
											{
												xData.SetAt(KEY_BOTMEL,inf.ptPos.z - 0.5 * inf.dSize2);
											}
										}

										//垂直XY面 绘制洞口示意 V线 矩形洞; 
										if (nShap == (int)eRect && sName.CompareNoCase(_T("开洞")) == 0)
										{
											double dL = 0, dW = 0;
											xData.GetAt(_T("dL"), dL);
											xData.GetAt(_T("dW"), dW);
											xData.GetAt(_T("vtDir"), vtZ);

											AcGeLine3d lnZ;
											lnZ.set(ptOrg, vtZ);
											if (AcGePlane::kXYPlane.isParallelTo(lnZ)) //洞中心方向线水平
											{
												AcGeVector3d vtX = vtZ;
												vtX.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
												vtX.normalize();

												//绘制洞口示意 V线 按默认水平放置的洞口
												AcGePoint3d ptGe[5],pt1,pt2;
												ptGe[0] = ptOrg;
												ptGe[0] += vtX * 0.5 * dL;
												ptGe[0] += AcGeVector3d::kZAxis * 0.5 * dW;

												ptGe[1] = ptGe[0];
												ptGe[1] -= vtX * dL;

												ptGe[2] = ptGe[1];
												ptGe[2] -= AcGeVector3d::kZAxis * dW;

												pt1 = ptGe[1];
												pt1.rotateBy(-PI / 36.0, vtZ, ptGe[0]);

												pt2 = ptGe[1];
												pt2.rotateBy(PI / 36.0, vtZ, ptGe[2]);

												AcGeLine3d ln1(pt1, ptGe[0]);
												AcGeLine3d ln2(pt2, ptGe[2]);

												pt1 = ptGe[1];
												if (ln1.intersectWith(ln2, ptGe[1]))
												{
													pt2 = ptGe[1];

													AcDbLine* pLn1 = new AcDbLine(ptGe[0], ptGe[1]);
													pLn1->setLayer(pPartEnt->layerId());
													arCenLnPtrs.append(pLn1);

													AcDbLine *pLn2 = new AcDbLine(ptGe[1], ptGe[2]);
													pLn1->setLayer(pPartEnt->layerId());
													arCenLnPtrs.append(pLn2);

													CString sForUse;
													xData.GetAt(KEY_FORUSE, sForUse);

													if (sForUse.Find(_T("人孔")) != -1)
													{
														//人孔填充
														ptGe[1] = pt1;
														ptGe[3] = pt2;
														ptGe[4] = ptGe[0];

														//交叉设置点
														AcGePoint3d ptS[4];
														ptS[0] = ptGe[0];
														ptS[1] = ptGe[1];
														ptS[2] = ptGe[3];
														ptS[3] = ptGe[2];
														AcDbVoidPtrArray arHatchPtrs;
														FillSolid(ptS,4,arHatchPtrs);

														if (!arHatchPtrs.isEmpty())
														{
															arCenLnPtrs.append(arHatchPtrs);
														}
													}
												}
											}
										}
										else if (nShap == (int)eCircle && sName.CompareNoCase(_T("开洞")) == 0)
										{
											double dR = 0;
											xData.GetAt(_T("dRad"), dR);
											xData.GetAt(_T("vtDir"), vtZ);

											AcGeLine3d lnZ;
											lnZ.set(ptOrg, vtZ);
											if (AcGePlane::kXYPlane.isParallelTo(lnZ)) //洞中心方向线水平
											{
												CString sForUse;
												xData.GetAt(KEY_FORUSE, sForUse);

												if (sForUse.Find(_T("人孔")) != -1)
												{
													AcGeVector3d vtX = vtZ;
													vtX.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
													vtX.normalize();

													AcGePoint3d ptGe[5], ptTmp;
													AcGePoint2dArray vertices;
													AcGeDoubleArray  bulges;

													AcGePlane plan;
													plan.set(ptOrg, vtZ);

													double dEl = AcGePoint3d::kOrigin.distanceTo(AcGePoint3d::kOrigin.orthoProject(plan));

													AcGePoint3d ptOrgT = plan.closestPointTo(AcGePoint3d::kOrigin);
													AcGeVector3d vtOrg = ptOrgT.asVector();
													vtOrg.normalize();
													vtZ.normalize();

													if (!vtOrg.isCodirectionalTo(vtZ))
													{
														dEl *= -1.0;
													}

													AcDbHatch *pHatch = new AcDbHatch;
													pHatch->setElevation(dEl);
													pHatch->setNormal(vtZ);

													AcGeMatrix3d mxECS;
													pHatch->getEcs(mxECS);
													mxECS.invert();

													ptGe[0] = ptOrg;
													ptGe[0].z += dR;
													ptTmp = ptGe[0];
													vertices.append(ptTmp.transformBy(mxECS).convert2d(AcGePlane::kXYPlane));
													bulges.append(1.0);

													ptGe[1] = ptGe[0];
													ptGe[1].z -= 2.0 * dR;
													ptTmp = ptGe[1];
													vertices.append(ptTmp.transformBy(mxECS).convert2d(AcGePlane::kXYPlane));
													bulges.append(-tan(0.6));

													ptGe[2] = ptOrg;
													ptGe[2].z += dR;
													ptTmp = ptGe[2];
													vertices.append(ptTmp.transformBy(mxECS).convert2d(AcGePlane::kXYPlane));
													bulges.append(0.0);

													pHatch->setAssociative(Adesk::kFalse);
													pHatch->setPattern(AcDbHatch::kPreDefined, _T("SOLID"));
													pHatch->setHatchStyle(AcDbHatch::kNormal);
													pHatch->appendLoop(AcDbHatch::kExternal, vertices, bulges);
													pHatch->evaluateHatch();

													//TEST
													//AddToModelSpace(pHatch);
													arCenLnPtrs.append(pHatch);
												}
											}
										}
									}
								}
								xData.SetAt(KEY_ORGPT,ptOrg);
								xData.SetAt(KEY_CENNODRAW,TRUE);//中心线不画标识
								xData.Write(pLn,BIMDATA_APP);
							}
							arCenLnPtrs.append(pLn);

							ptSta = ptOrg - AcGeVector3d::kZAxis * 1.2 * dH;
							ptEnd = ptOrg + AcGeVector3d::kZAxis * 1.2 * dH;

							pLn = new AcDbLine(ptSta,ptEnd);//中心线
							pLn->setLayer(KTSetting::InitLayer(_T("LAY_CL"),true));
							pLn->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

							if (pXData != NULL)
							{
								AecDbObjXDataMap xData;
								xData.CopyFrom(pXData);
								xData.SetAt(KEY_NAME,sName);

								if (sName.CompareNoCase(_T("开洞")) == 0 || //开洞
									sName.CompareNoCase(_T("套管")) == 0)	//套管
								{
									//洞口或套管写标高
									AecInterface inf;
									if ( pPartEnt->GetInterface(0,inf) )
									{
										int nShap = 0;
										xData.GetAt(_T("nShape"),nShap);//圆

										if (inf.vtDir.isParallelTo(AcGeVector3d::kZAxis))
										{
											if (nShap == (int)eCircle)
											{
												xData.SetAt(KEY_CENEL,inf.ptPos.z);
											}
											else
											{
												xData.SetAt(KEY_BOTMEL,inf.ptPos.z);
											}
										}
										else
										{
											if (nShap == (int)eCircle)
											{
												xData.SetAt(KEY_CENEL,inf.ptPos.z);
											}
											else
											{
												xData.SetAt(KEY_BOTMEL,inf.ptPos.z - 0.5 * inf.dSize2);
											}
										}
									}
								}

								xData.SetAt(KEY_ORGPT,ptOrg);
								xData.SetAt(KEY_CENNODRAW,TRUE);//中心线不画标识
								xData.Write(pLn,BIMDATA_APP);
							}
							arCenLnPtrs.append(pLn);
						}
						else if (AcGePlane::kXYPlane.isParallelTo(ln))//平行XY面
						{
							AecDbObjXDataMap xData;
							xData.CopyFrom(pXData);
							xData.SetAt(KEY_NAME, sName);

							//平行XY面 绘制洞口示意 X 线
							AcGePoint3d ptGe[4];

							double dL = 0, dW = 0,dT = 0;
							xData.GetAt(_T("dL"), dL);
							xData.GetAt(_T("dW"), dW);
							xData.GetAt(_T("dH"), dT);
							xData.GetAt(_T("vtDir"), vtZ);

							AcGeLine3d lnZ;
							lnZ.set(ptOrg, vtZ);
							if (AcGePlane::kXYPlane.isParallelTo(lnZ)) //洞水平 X 线
							{
								AcGeVector3d vtX = vtZ;
								vtX.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
								vtX.normalize();

								ptGe[0] = ptOrg;
								ptGe[0] += AcGeVector3d::kZAxis * 0.5 * dW;
								ptGe[0] += vtZ * 0.5 * dT;

								ptGe[1] = ptGe[0];
								ptGe[1] -= vtZ * dT;

								ptGe[2] = ptGe[1];
								ptGe[2] -= AcGeVector3d::kZAxis * dW;

								ptGe[3] = ptGe[0];
								ptGe[3] -= AcGeVector3d::kZAxis * dW;

								int nShap = 0;
								xData.GetAt(_T("nShape"), nShap);//圆
								if (nShap == (int)eRect && sName.CompareNoCase(_T("开洞")) == 0)
								{
									AcDbLine *pLn1 = new AcDbLine(ptGe[0], ptGe[2]);
									pLn1->setLayer(layerId());
									pLn1->setLinetype(KTSetting::InitLineStyle(_T("DASH")));
									arCenLnPtrs.append(pLn1);

									AcDbLine *pLn2 = new AcDbLine(ptGe[1], ptGe[3]);
									pLn2->setLayer(layerId());
									pLn2->setLinetype(KTSetting::InitLineStyle(_T("DASH")));
									arCenLnPtrs.append(pLn2);

									AcDbLine *pLn3 = new AcDbLine(ptGe[0], ptGe[3]);
									pLn3->setLayer(layerId());
									pLn3->setLinetype(KTSetting::InitLineStyle(_T("DASH")));
									arCenLnPtrs.append(pLn3);

									AcDbLine *pLn4 = new AcDbLine(ptGe[1], ptGe[2]);
									pLn4->setLayer(layerId());
									pLn4->setLinetype(KTSetting::InitLineStyle(_T("DASH")));
									arCenLnPtrs.append(pLn4);
								}
							}
							else if (AcGePlane::kXYPlane.isPerpendicularTo(lnZ))
							{

							}
						}
					}

					//2.减去 开洞 套管 的 虚Solid
					if (sName.CompareNoCase(_T("开洞")) == 0 || //开洞
						sName.CompareNoCase(_T("套管")) == 0)	//套管
					{
						AcDbVoidPtrArray arSolids;
						pPartEnt->GetForHouseSubtract(arSolids);

						for (int k = 0;k < arSolids.length();k++)
						{
							pEntT = (AcDbEntity*)arSolids.at(k);
							pSolidT = AcDb3dSolid::cast(pEntT);
							if (pSolidT != NULL)
							{
								pSolidDrawCln = (AcDb3dSolid*)pSolidDraw->clone();
								if ( Acad::eOk == (es = pSolidT->booleanOper(AcDb::kBoolIntersect,pSolidDrawCln) ) )
								{
									pSolidT->setLayer(pPartEnt->layerId());
									arSolidPtrs.append(pSolidT);
								}
								else
								{
									delete pSolidDrawCln;
								}
							}
						}
					}
					
					if(sName.CompareNoCase(_T("套管")) == 0)//套管
					{
						AcDb3dSolid* p3DPipe = pPartEnt->CreateDraw3dSolid();
						if (p3DPipe != NULL)
						{
							p3DPipe->setLayer(pPartEnt->layerId());
							arSolidPtrs.append(p3DPipe);
						}
					}
				}

				AecDbXOpening* pOpen = AecDbXOpening::cast(pEnt);
				if (pOpen != NULL)
				{
					AcDbVoidPtrArray arSolids;
					pOpen->GetForHouseSubtract(arSolids);

					for (int k = 0;k < arSolids.length();k++)
					{
						pEntT = (AcDbEntity*)arSolids.at(k);
						pSolidT = AcDb3dSolid::cast(pEntT);
						if (pSolidT != NULL)
						{
							//求交获取精确的洞口。 主模型为了kBoolSubtract,洞口都是放大了一点,保证主模型kBoolSubtract洞口正确
							//完全匹配的洞口 主模型(pSolidDraw) kBoolSubtract洞口时，会出现结果两侧不彻底的情况，多余两个面,数学边界问题
							pSolidDrawCln = (AcDb3dSolid*)pSolidDraw->clone();
							if ( Acad::eOk == (es = pSolidT->booleanOper(AcDb::kBoolIntersect,pSolidDraw) ) )
							{
								pSolidT->setLayer(pOpen->layerId());
								pSolidT->setVisibility(AcDb::kInvisible);
								arSolidPtrs.append(pSolidT);
							}
							else
							{
								delete pSolidDrawCln;
							}
						}
					}
				}
				pEnt->close();
			}
		}	
		delete pSolidDraw;
	}
	return Acad::eOk;
}

SHJson::WValue& AecDbBDPipeBase::ToJson(bool bExprotGeo) const
{
	assertReadEnabled();

	using namespace SHJson;
	WValue &v = AecDbEwPipeBase::ToJson(bExprotGeo);

	WValue ar, sub;
	if (bExprotGeo)
	{
		ar.SetArray();
		for (size_t i = 0; i < m_arX3DPartPtrs.length(); ++i)
		{
			sub.SetNull();
			sub = m_arX3DPartPtrs[i]->ToJson();
			if (!sub.IsNull())
			{
				addMember(sub, _T("__owner__"), objectId().asOldId());
				pushBack(ar, sub);
			}
		}

		if (!ar.Empty())
			addMember(v, _T("__arX3DPartPtrs__"), ar);

		ar.SetArray();
		for (size_t i = 0; i < 3; ++i)
			pushBack(ar, m_dRotate[i]);
		if (!ar.Empty())
			addMember(v, _T("__dRotate__"), ar);
	}

	return v;
}

bool AecDbBDPipeBase::ByJson(const SHJson::WValue &v)
{
	AssertWriteEnabled();
	using namespace SHJson;
	if (!AecDbEwPipeBase::ByJson(v)) return false;

	MCIt it = v.FindMember(_T("__xRot__"));
	if (it == v.MemberEnd()) return false;
	m_dRotate[0] = it->value.GetDouble();

	it = v.FindMember(_T("__yRot__"));
	if (it == v.MemberEnd()) return false;
	m_dRotate[1] = it->value.GetDouble();

	it = v.FindMember(_T("__zRot__"));
	if (it == v.MemberEnd()) return false;
	m_dRotate[2] = it->value.GetDouble();

	it = v.FindMember(_T("__attachment__"));
	if (it == v.MemberEnd()) return false;
	if (!it->value.IsArray()) return false;

	deleteContainerOfArx<AecDbX3dPart>(m_arX3DPartPtrs);
	for (VCIt i = it->value.Begin();  i != it->value.End(); ++i)
	{
		AecDbX3dPart *pPart = new AecDbX3dPart();
		if (pPart->ByJson(*i))
			m_arX3DPartPtrs.append(pPart);
		else
			DELETE_PTR(pPart);
	}

	return true;
}