#include "stdafx.h"
#include "AecDbXBG.h"
#include "AcGiViewDraw.h"
#include "CoreTools.h"

namespace
{
	AcDbArc* createArcBy3Pt(const AcGePoint3d &pt1
		, const AcGePoint3d &pt
		, const AcGePoint3d &pt2)
	{

		AcGeCircArc3d geArc(pt1, pt, pt2);
		return CoreTools::geArc2DbArc(geArc);
	}

	AcDbPolyline* curves2Polyline(AcDbVoidPtrArray &ar)
	{
		std::vector<AcDbPolyline*> polys;
		CoreTools::MakePolyline(ar, polys);
		deleteArrayVoidPtrs< AcDbPolyline>(ar);
		if (polys.empty()) return NULL;
		AcDbPolyline *pPoly = (AcDbPolyline*)(polys[0]->clone());
		deleteContainerOfStd(polys);
		return pPoly;
	}

	AcDbPolyline* makeBaseCurve(const int &nType
		, const AcGePoint3d &Pos
		, const double &L
		, const double &W
		, const double &S)
	{
		AcGeVector3d X(AcGeVector3d::kXAxis), Z(AcGeVector3d::kZAxis), Y(AcGeVector3d::kYAxis);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcGePoint3d ptLB(Pos);
		ptLB -= X * L * .5;
		ptLB -= Y * W * .5;

		AcDbVoidPtrArray ar;
		if (nType == 0)			// 斜板管
		{
			AcGePoint3d pt(ptLB);
			// 六边形 边长l0，三点对角线长l3, 四点对角线长l4;
			double r(S);
			double l0 = 2 * (r / tan(CoreTools::A2R(60.)));
			double l3 = 2 * (l0 * sin(CoreTools::A2R(60.)));
			double l4 = 2 * (r / sin(CoreTools::A2R(60.)));

			//pt += X * l3 * .5;
			AcGePoint3d ptOld(pt);
			double segLen(l4 + l0);
			int count(int((W + l0) / segLen));
			int n((W + l0) / (l4 + l0));
			double dLen = W - (n * l4) - (n - 1) * l0;
			if (UP_ZERO(dLen))
			{
				AcGePoint3d pt1(pt), pt2(pt + Y * dLen * .5);
				ar.append(new AcDbLine(pt1, pt2));
				pt1 = pt2 + Y * ((n * l4) + (n - 1) * l0);
				pt2 = pt1 + Y * dLen * .5;
				ar.append(new AcDbLine(pt1, pt2));
				pt += Y * dLen * .5;
			}

			AcGeVector3d vt60(Y), vt30(X);
			vt60.rotateBy(CoreTools::A2R(60), Z);
			vt30.rotateBy(CoreTools::A2R(30), Z);
			for (int i = 0; i < n; ++i)
			{
				AcGePoint3d pt1(pt), pt2(pt + vt60 * l0);
				ar.append(new AcDbLine(pt1, pt2));

				pt1 = pt2;
				pt2 = pt1 + Y * l0;
				ar.append(new AcDbLine(pt1, pt2));

				pt1 = pt2;
				pt2 = pt1 + vt30 * l0;
				ar.append(new AcDbLine(pt1, pt2));

				if (i < n - 1)
				{
					pt1 = pt2;
					pt2 = pt1 + Y * l0;
					ar.append(new AcDbLine(pt1, pt2));
				}

				pt += Y * segLen;
			}
		}
		else if (nType == 1)	// 平行板
		{
			ar.append(new AcDbLine(ptLB, ptLB + Y * W));
		}
		else					// 波形板
		{
			// 先生成一条基础线,沿Y走向
			double r(S * .5), sp(S);
			AcGePoint3d pt(ptLB);
			AcGePoint3d ptOld(pt);

			int i = 0;
			while (sp <= W)
			{
				AcDbArc *pArc(NULL);

				AcGePoint3d pt1(pt);
				AcGePoint3d pt2(pt1 + Y * r);
				AcGePoint3d pt3(pt1 + Y * 2 * r);


				if (i % 2)
				{
					pt2 += X * r;
					pArc = createArcBy3Pt(pt1, pt2, pt3);
					pArc->setColorIndex(1);
				}
				else
				{
					pt2 -= X * r;
					pArc = createArcBy3Pt(pt3, pt2, pt1);
					pArc->setColorIndex(2);
				}

				ar.append(pArc);

				pt += Y * r * 2;
				sp += 2 * r;
				++i;
			}

			// 剩余长度,用直线补上,补在起始位置
			double dLen = W - int(W / (2 * r)) * 2 * r;

			if (UP_ZERO(dLen))
			{
				ar.insertAt(0, new AcDbLine(pt, pt + Y * dLen * .5));

				// 全部arc向Y方向 dLen
				AcGeMatrix3d mat;
				mat.setToTranslation(Y * dLen * .5);
				for (int i = 0; i < ar.length(); ++i)
				{
					AcDbEntity *pEnt((AcDbEntity *)ar[i]);
					pEnt->transformBy(mat);
				}

				ptOld.transformBy(mat);
				ar.append(new AcDbLine(ptOld, ptOld - Y * dLen * .5));
			}

		}

		AcDbPolyline *pPoly = curves2Polyline(ar);
		return pPoly;
	}

	AcDbRegion* makeCutRegion(AcDbPolyline *pPoly)
	{
		if (!pPoly) return NULL;

		if (pPoly->numVerts() < 3) return NULL;

		if (!pPoly->isClosed())
			pPoly->setClosed(true);

		AcDbRegion *pReg = CoreTools::createRegion(pPoly);
		if (!pReg) return NULL;

		AcDbExtents ext;
		pPoly->getGeomExtents(ext);
		AcGePoint3d ptMax(ext.maxPoint()), ptMin(ext.minPoint());
		double dY(ptMax.y - ptMin.y);

		AcDbRegion *pRegMax(NULL);
		{
			AcGePoint3d pt0(ptMin)
				, pt1(ptMin + AcGeVector3d::kYAxis * dY)
				, pt2(ptMax)
				, pt3(ptMax - AcGeVector3d::kYAxis * dY);

			AcDbVoidPtrArray ar;
			ar.append(new AcDbLine(pt0, pt1));
			ar.append(new AcDbLine(pt1, pt2));
			ar.append(new AcDbLine(pt2, pt3));
			ar.append(new AcDbLine(pt3, pt0));
			AcDbPolyline *pPoly = curves2Polyline(ar);
			if (!pPoly)
			{
				DELETE_PTR(pReg);
				return NULL;
			}
			pRegMax = CoreTools::createRegion(pPoly);
			DELETE_PTR(pPoly);
		}

		if (!pRegMax)
		{
			DELETE_PTR(pReg);
			return NULL;
		}

		if (pRegMax->booleanOper(AcDb::kBoolSubtract, pReg) == Acad::eOk)
		{
			DELETE_PTR(pReg);
			return pRegMax;
		}

		DELETE_PTR(pReg);
		return NULL;
	}

	AcDbRegion* makeMainRegion(int nType
		, AcDbPolyline *pPoly
		, const double &D
		, const double &T)
	{

		if (!pPoly) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Z(AcGeVector3d::kZAxis), Y(AcGeVector3d::kYAxis);

		AcDbExtents ext;
		pPoly->getGeomExtents(ext);
		AcGePoint3d ptMax(ext.maxPoint()), ptMin(ext.minPoint());
		AcGePoint3d Pos(CoreTools::MidPt(ptMax, ptMin));
		double W(ptMax.y - ptMin.y), L(ptMax.x - ptMin.x);

		AcDbPolyline *pBase(makeBaseCurve(nType, Pos, L, W, D));
		if (!pBase) return NULL;

		if (nType == 0)
		{
			double R(D);

			AcGePoint3d ptT(Pos + Y * .5 * W);
			ptT -= X * .5 * L;
			AcGePoint3d ptB(Pos - Y * .5 * W);
			ptB -= X * .5 * L;

			// 六边形 边长l0，三点对角线长l3, 四点对角线长l4;
			double r(R);
			double l0 = 2 * (r / tan(CoreTools::A2R(60.)));
			double l3 = 2 * (l0 * sin(CoreTools::A2R(60.)));
			double l4 = 2 * (r / sin(CoreTools::A2R(60.)));

			// 先向X方向镜像出一个
			AcDbPolyline *pBase2 = (AcDbPolyline*)pBase->clone();
			AcGeMatrix3d mat;
			mat.setToRotation(-PI, Y, ptB);
			pBase2->transformBy(mat);

			mat.setToTranslation(X * 3 * T);
			pBase2->transformBy(mat);


			AcDbVoidPtrArray ar, ar1;

			pBase->explode(ar1);
			ar.append(ar1);
			ar1.removeAll();	// 不能清理内存, ar 内统一清
			DELETE_PTR(pBase);

			pBase2->explode(ar1);
			ar.append(ar1);
			DELETE_PTR(pBase2);

			ar.append(new AcDbLine(ptT, ptT + X * 3 * T));
			ar.append(new AcDbLine(ptB, ptB + X * 3 * T));

			AcDbPolyline *pProfile = curves2Polyline(ar);
			if (!pProfile) return NULL;

			pProfile->getOffsetCurves(T, ar);
			if (ar.isEmpty())
			{
				DELETE_PTR(pProfile);
				return NULL;
			}

			AcDbPolyline *pProfile2 = (AcDbPolyline*)((AcDbEntity*)ar[0])->clone();
			deleteArrayVoidPtrs< AcDbEntity>(ar);

			double area1, area2;
			pProfile->getArea(area1);
			pProfile2->getArea(area2);
			if (area2 > area1)
			{
				AcDbPolyline *p(pProfile);
				pProfile = pProfile2;
				pProfile2 = p;
			}

			AcDbRegion *pRegBig = CoreTools::createRegion(pProfile);
			if (!pRegBig)
			{
				DELETE_PTR(pProfile);
				DELETE_PTR(pProfile2);
				return NULL;
			}

			AcDbRegion *pRegSml = CoreTools::createRegion(pProfile2);
			if (!pRegSml)
			{
				DELETE_PTR(pRegBig);
				DELETE_PTR(pProfile);
				DELETE_PTR(pProfile2);
				return NULL;
			}

			DELETE_PTR(pProfile);
			DELETE_PTR(pProfile2);


			if (pRegBig->booleanOper(AcDb::kBoolSubtract, pRegSml) != Acad::eOk)
			{
				DELETE_PTR(pRegBig);
				DELETE_PTR(pRegSml);
				return NULL;
			}

			DELETE_PTR(pRegSml);

			return pRegBig;
		}
		else
		{
			AcGePoint3d ptT(Pos + Y * .5 * W);
			ptT -= X * .5 * L;
			AcGePoint3d ptB(Pos - Y * .5 * W);
			ptB -= X * .5 * L;

			AcDbVoidPtrArray ar, ar1;
			pBase->explode(ar1);
			ar.append(ar1);
			ar1.removeAll();	// 不清理内存
			pBase->getOffsetCurves(T, ar1);
			if (ar1.isEmpty())
			{
				deleteArrayVoidPtrs< AcDbEntity>(ar);
				return NULL;
			}

			ar.append((AcDbEntity*)(((AcDbEntity*)ar1[0])->clone()));
			deleteArrayVoidPtrs< AcDbEntity>(ar1);

			ar.append(new AcDbLine(ptT, ptT + X * T));
			ar.append(new AcDbLine(ptB, ptB + X * T));

			AcDbRegion *pReg = CoreTools::createRegion(ar);
			deleteArrayVoidPtrs< AcDbEntity>(ar);

			return pReg;
		}
		return NULL;
	}

	AcDbPolyline* getOffsetOfPolyline(double dOffset, AcDbPolyline* pPoly)
	{
		if (!pPoly) return NULL;
		AcDbVoidPtrArray ar;
		pPoly->getOffsetCurves(dOffset, ar);
		if (ar.isEmpty()) return NULL;

		if (!pPoly->isClosed() && pPoly->numVerts() > 2)
		{
			pPoly->setClosed(true);
		}

		if (!pPoly->isClosed())
		{
			AcDbPolyline *p = (AcDbPolyline*)((AcDbEntity*)(ar[0]))->clone();
			deleteArrayVoidPtrs< AcDbEntity>(ar);
			return p;
		}

		double area1(.0), area2(.0);
		pPoly->getArea(area1);
		((AcDbPolyline*)(ar[0]))->getArea(area2);

		bool bReset(false);
		if (UP_ZERO(dOffset))	// 变大
		{
			if (area2 < area1)	// 没有变大，重新取curve
				bReset = true;
		}
		else					// 变小
		{
			if (area2 > area1)	// 没有变小,重新取curve
				bReset = true;
		}

		if (bReset)
		{
			deleteArrayVoidPtrs< AcDbEntity>(ar);
			pPoly->getOffsetCurves(-dOffset, ar);
			if (ar.isEmpty()) return NULL;
		}
		AcDbPolyline *p = (AcDbPolyline*)((AcDbEntity*)(ar[0]))->clone();
		deleteArrayVoidPtrs< AcDbEntity>(ar);
		return p;
	}
}

Adesk::UInt32 AecDbXBG::kCurrentVersionNumber = 1;

IMP_XDATA_KEY(AecDbXBG, _MATERIAL_);
IMP_XDATA_KEY(AecDbXBG, _TYPE_);
IMP_XDATA_KEY(AecDbXBG, _R_);
IMP_XDATA_KEY(AecDbXBG, _S_);
IMP_XDATA_KEY(AecDbXBG, _T_);
IMP_XDATA_KEY(AecDbXBG, _A_);
IMP_XDATA_KEY(AecDbXBG, _H_);
IMP_XDATA_KEY(AecDbXBG, _PROFILE_);

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


AecDbXBG::AecDbXBG(void)
{
	m_mapSpecXData.SetAt(KEY_NAME,_T("斜板管"));
}

AecDbXBG::~AecDbXBG(void)
{
}

Acad::ErrorStatus AecDbXBG::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
	Adesk::UInt32 version(0);
	if ((es = pFiler->readUInt32(&version)) != Acad::eOk)
		return (es);

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

	return Acad::eOk;
}

Acad::ErrorStatus AecDbXBG::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();

	//----- 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
	if ((es = pFiler->writeUInt32(AecDbXBG::kCurrentVersionNumber)) != Acad::eOk)
		return (es);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbXBG::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus AecDbXBG::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus AecDbXBG::subExplode(AcDbVoidPtrArray& entitySet) const
{
	return Acad::eOk;
}

void AecDbXBG::subList() const {}

Acad::ErrorStatus AecDbXBG::subTransformBy(const AcGeMatrix3d &mat)
{
	AssertWriteEnabled();
	CString sPoly;
	if (!m_mapSpecXData.GetAt(_T("_PROFILE_"), sPoly)) return Acad::eInvalidInput;
	AcDbPolyline *pProfile = CoreTools::StringToPolyline(sPoly);
	if (!pProfile) return Acad::eInvalidInput;

	pProfile->transformBy(mat);

	sPoly.Empty();
	CoreTools::PolylineToString(pProfile, sPoly);
	DELETE_PTR(pProfile);

	if (sPoly.IsEmpty()) return Acad::eInvalidInput;

	m_mapSpecXData.SetAt(_T("_PROFILE_"), sPoly);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbXBG::subGetGripPoints(AcGePoint3dArray&     gripPoints,
	AcDbIntArray&  osnapModes,
	AcDbIntArray&  geomIds) const
{
	assertReadEnabled();
	CString sPoly(_T(""));
	if (!m_mapSpecXData.GetAt(_T("_PROFILE_"), sPoly)) return Acad::eInvalidInput;
	AcDbPolyline *pProfile = CoreTools::StringToPolyline(sPoly);
	if (!pProfile) return Acad::eInvalidInput;

	pProfile->getGripPoints(gripPoints, osnapModes, geomIds);

	AcDbExtents ext;
	pProfile->getGeomExtents(ext);
	AcGePoint3d Pos(CoreTools::MidPt(ext.maxPoint(), ext.minPoint())), ptLB(ext.minPoint());

	gripPoints.append(Pos);
	
	DELETE_PTR(pProfile);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbXBG::subGetGripPoints(AcDbGripDataPtrArray& grips,
	const double curViewUnitSize,
	const int gripSize,
	const AcGeVector3d& curViewDir,
	const int bitflags) const { return Acad::eNotImplementedYet; }

Acad::ErrorStatus AecDbXBG::subMoveGripPointsAt(const AcDbVoidPtrArray& appData
	, const AcGeVector3d& offset
	, const int bitflags)
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbXBG::subMoveGripPointsAt(const AcDbIntArray &indices, const AcGeVector3d &offset)
{
	AcGeMatrix3d mat;
	mat.setTranslation(offset);
	return subTransformBy(mat);
}

void AecDbXBG::GetGripText(int nPos, CString& sText)
{
	return;
}

Acad::ErrorStatus AecDbXBG::subIntersectWith(const AcDbEntity*	pEnt,
	AcDb::Intersect		intType,
	AcGePoint3dArray&	points,
	INT_PTR				thisGsMarker,
	INT_PTR				otherGsMarker) const
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus AecDbXBG::subIntersectWith(const AcDbEntity*	pEnt,
	AcDb::Intersect		intType,
	const AcGePlane&	projPlane,
	AcGePoint3dArray&	points,
	INT_PTR				thisGsMarker,
	INT_PTR				otherGsMarker) const
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus AecDbXBG::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();

	int clr(256), oldclr;
	m_mapSpecXData.GetAt(_T("COLOR"), clr);
	oldclr = dc.GetColor();
	dc.SetColor(clr);

	if (Has2DBuffer())
	{
		Draw2DBuffers(dc);
		return Acad::eOk;
	}

	AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);

	CString sPoly(_T(""));
	if (!m_mapSpecXData.GetAt(_T("_PROFILE_"), sPoly)) return Acad::eInvalidInput;
	AcDbPolyline *pProfile = CoreTools::StringToPolyline(sPoly);
	if (!pProfile) return Acad::eInvalidInput;
	AcDbExtents ext;
	pProfile->getGeomExtents(ext);
	double L = ext.maxPoint().x - ext.minPoint().x;
	double W = ext.maxPoint().y - ext.minPoint().y;
	AcGePoint3d Pos(CoreTools::MidPt(ext.maxPoint(), ext.minPoint())), ptLB(ext.minPoint());

	AcDbRegion *pReg = makeMainRegion(GetType(), pProfile, GetType() == 0 ? GetR() : GetS(), T);
	if (!pReg)
	{
		DELETE_PTR(pProfile);
		return Acad::eInvalidInput;
	}
	pReg->getGeomExtents(ext);

	AcGeMatrix3d mat;
	mat.setToTranslation(X * (ptLB.x - ext.minPoint().x));
	pReg->transformBy(mat);

	int count(0);
	double l(.0);
	if (GetType() == 0)
	{
		l = ext.maxPoint().x - ext.minPoint().x;
		count = (int)(L / l + .01);
	}
	else
	{
		l = GetT() + GetS();
		count = int((L - GetS()) / l + .01);
	}

	double dLen = L - l * count;
	if (UP_ZERO(dLen))
	{
		mat.setToTranslation(X * dLen * .5);
		pReg->transformBy(mat);
	}
	pReg->getGeomExtents(ext);
	double xPos = ext.maxPoint().x;

	AcDbVoidPtrArray arRegs;
	arRegs.append(pReg);
	for (int i = 1; i < count; ++i)
	{
		AcDbRegion *p = (AcDbRegion*)pReg->clone();
		if (!p) continue;
		p->transformBy(X * l * i);
		arRegs.append(p);
	}

	AcDbRegion *pSubReg = makeCutRegion(pProfile);
	if (!pSubReg)
	{
		DELETE_PTR(pProfile);
		return Acad::eInvalidInput;
	}

	mat.setToTranslation(Z * GetH());
	for (int i = 0; i < arRegs.length(); ++i)
	{
		AcDbRegion *p((AcDbRegion*)arRegs[i]);
		AcDbRegion *pSub((AcDbRegion*)pSubReg->clone());
		if (p->booleanOper(AcDb::kBoolSubtract, pSub) != Acad::eOk)
		{
			continue;
		}
		DELETE_PTR(pSub);
		p->transformBy(mat);
		Add2DBuffer(p);
	}

	DELETE_PTR(pProfile);
	DELETE_PTR(pSubReg);

	
	Draw2DBuffers(dc);
	dc.SetColor(oldclr);
	return Acad::eOk;
}

Acad::ErrorStatus AecDbXBG::Draw3d(AcGiDraw &dc) const
{
	assertReadEnabled();
	AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);

	int clr(256), oldclr;
	m_mapSpecXData.GetAt(_T("COLOR"), clr);
	oldclr = dc.GetColor();
	dc.SetColor(clr);

	if (Has3DBuffer())
	{
		Draw3DBuffers(dc);
		return Acad::eOk;
	}

	if (!Has2DBuffer())
	{
		AcGiViewDraw dc1;
		Draw2d(dc1);
	}

	double H(GetH()), A(GetA());
	AcGeMatrix3d mat0;
	AcGeVector3d vtDir(AcGeVector3d::kXAxis);
	if (EQUAL_ZERO(A))
	{
		vtDir = Z * H;
		mat0.setToIdentity();
	}
	else
	{
		vtDir.rotateBy(CoreTools::A2R(A), -Y);
		vtDir.normalize();
		vtDir *= H / sin(CoreTools::A2R(A));
		mat0.setToTranslation(-X * (H / tan(CoreTools::A2R(A))));
	}

	const AcDbVoidPtrArray &ar = Get2DBuffer();

	AcDbExtents ext;
	AcGePoint3d pt;
	AcDbLine line;

	AcDb3dSolid *pSubSolid(NULL);
	if (!EQUAL_ZERO(A))
	{
		CString sPoly(_T(""));
		if (!m_mapSpecXData.GetAt(_T("_PROFILE_"), sPoly)) return Acad::eInvalidInput;
		AcDbPolyline *pProfile = CoreTools::StringToPolyline(sPoly);
		if (pProfile)
		{
			AcDbPolyline *pL = getOffsetOfPolyline(H / tan(CoreTools::A2R(A)), pProfile);
			if (pL)
			{
				AcDbRegion *pSubReg = CoreTools::createRegion(pL);
				if (pSubReg)
				{
					AcDbRegion *pSubReg2 = CoreTools::createRegion(pProfile);
					if (pSubReg2)
					{
						if (pSubReg->booleanOper(AcDb::kBoolSubtract, pSubReg2) == Acad::eOk)
						{
							pSubReg->getGeomExtents(ext);
							pt = CoreTools::MidPt(ext.minPoint(), ext.maxPoint());
							line.setStartPoint(pt);
							line.setEndPoint(pt + AcGeVector3d::kZAxis * H);

							pSubSolid = new AcDb3dSolid();
							if (pSubSolid->extrudeAlongPath(pSubReg, &line) != Acad::eOk)
								DELETE_PTR(pSubSolid);
						}
						DELETE_PTR(pSubReg2);
					}
					DELETE_PTR(pSubReg);
				}
				DELETE_PTR(pL);
			}
			DELETE_PTR(pProfile);
		}
	}

	for (int i(0); i < ar.length(); ++i)
	{
		AcDbRegion *pReg((AcDbRegion*)ar[i]);
		pReg->getGeomExtents(ext);
		pt = CoreTools::MidPt(ext.maxPoint(), ext.minPoint());
		line.setStartPoint(pt);
		line.setEndPoint(pt - vtDir);
		AcDb3dSolid *pSolid = new AcDb3dSolid();
		if (pSolid->extrudeAlongPath(pReg, &line) == Acad::eOk)
		{
			if (pSubSolid)
			{
				AcDb3dSolid *p((AcDb3dSolid*)pSubSolid->clone());
				pSolid->booleanOper(AcDb::kBoolSubtract, p);
				DELETE_PTR(p);
			}
			Add3DBuffer(pSolid);
		}
	}
	DELETE_PTR(pSubSolid);

	// 角度不为0，则进行切割

	const AcDbVoidPtrArray &ar3d = Get3DBuffer();
	for (int i(0); i < ar3d.length(); ++i)
	{
		AcDbEntity *pEnt((AcDbEntity*)ar3d[i]);
		pEnt->setTransparency(transparency());
	}
	
	
	Draw3DBuffers(dc);
	dc.SetColor(oldclr);
	return Acad::eOk;
}

bool AecDbXBG::TransformAssocInf(int nInf,const AcGeMatrix3d& xform)
{
	return false;
}

LPCTSTR	AecDbXBG::GetGripCmd() const
{
	return NULL;
}

bool AecDbXBG::GetSrcString(CString &src)
{
	assertReadEnabled();
	return m_mapSpecXData.GetAt(_T("_SRC_STRING_"), src) == 0 ? false : true;
}

void AecDbXBG::SetSrcString(LPCTSTR src)
{
	assertWriteEnabled();
	if (src && !CString(src).IsEmpty())
		m_mapSpecXData.SetAt(_T("_SRC_STRING_"), src);
}

SHJson::WValue& AecDbXBG::ToJson(bool bExprotGeo) const
{
	assertReadEnabled();
	return AecDbEwPipeBase::ToJson(bExprotGeo);
}

bool AecDbXBG::ByJson(const SHJson::WValue &v)
{
	AssertWriteEnabled();
	return AecDbEwPipeBase::ByJson(v);
}

double AecDbXBG::getElevation()
{
	assertReadEnabled();

	CString sPoly;
	if (!m_mapSpecXData.GetAt(_T("_PROFILE_"), sPoly)) return .0;
	AcDbPolyline *pProfile = CoreTools::StringToPolyline(sPoly);
	if (!pProfile) return .0;

	return pProfile->elevation();
}

void AecDbXBG::setElevation(const double &dElev)
{
	AssertWriteEnabled();
	CString sPoly;
	if (!m_mapSpecXData.GetAt(_T("_PROFILE_"), sPoly)) return;
	AcDbPolyline *pProfile = CoreTools::StringToPolyline(sPoly);
	if (!pProfile) return;

	pProfile->setElevation(dElev);

	sPoly.Empty();
	CoreTools::PolylineToString(pProfile, sPoly);
	DELETE_PTR(pProfile);

	if (sPoly.IsEmpty()) return;

	m_mapSpecXData.SetAt(_T("_PROFILE_"), sPoly);

	return;
}

#include "HlrCutOption.h"
void AecDbXBG::ProcessHlrResult(const AcArray<AcDbEntity *> &ar
	, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr
	, AcArray<AcDbEntity *> &output) const
{
	HlrCutOption::ProcessHlrResult(this
		, FALSE
		, .0
		, HlrCutOption::getHlrBLK_PARAEQU()
		, ar
		, preAr
		, output);
}