#include "stdafx.h"
#include "TAuxTools.h"
#include "math.h"
#include "TImpSpecFitting.h"
#include "TImpSpecEquipment.h"
using namespace std;

#define ZERO_AIR 1.0e-6

// 取得接口记录指针 外部使用
DLLIMPEXP TDbInterfaceRecord* GetInterfacePtr()
{
	return TAuxTools::GetIntfPtrFromDB();
}

// 写入暖通动态扩展数据到图纸中
DLLIMPEXP void SetTHvacParamToDwg(LPCTSTR pszKey = NULL)
{
	if(NULL == pszKey)
	{
		BOOL bShowCover = FALSE; // 显示遮挡
		GetGlobalContext()->GetAt(KEY_HIDEDRAW, bShowCover);
		TAuxTools::SetTHvacDataToDwg(KEY_HIDEDRAW, bShowCover);

		double dHideWidth = 0; // 打断间隙
		GetGlobalContext()->GetAt(HVAC_HIDEEXTENT, dHideWidth);
		TAuxTools::SetTHvacDataToDwg(HVAC_HIDEEXTENT, dHideWidth);

		BOOL bShowWidth = FALSE; // 是否加粗
		GetGlobalContext()->GetAt(HVAC_SHOWWIDTH, bShowWidth);
		TAuxTools::SetTHvacDataToDwg(HVAC_SHOWWIDTH, bShowWidth);

		double dBrWidth = 0; // 水管风管打断间隙
		GetGlobalContext()->GetAt(HVAC_PIPEHIDEWIDTH, dBrWidth);
		TAuxTools::SetTHvacDataToDwg(HVAC_PIPEHIDEWIDTH, dBrWidth);

		BOOL bPipeDuctBreak = FALSE; // 风管与水管打断
		GetGlobalContext()->GetAt(HVAC_PIPEDUCTBREAK, bPipeDuctBreak);
		TAuxTools::SetTHvacDataToDwg(HVAC_PIPEDUCTBREAK, bPipeDuctBreak);
	}
	else
	{
		if(0 == _tcscmp(pszKey, KEY_HIDEDRAW)
			|| 0 == _tcscmp(pszKey, HVAC_SHOWWIDTH)
			|| 0 == _tcscmp(pszKey, HVAC_PIPEDUCTBREAK))
		{
			BOOL bValue = FALSE;
			if(GetGlobalContext()->GetAt(pszKey, bValue))
			{
				TAuxTools::SetTHvacDataToDwg(pszKey, bValue);
			}
		}
		else if(0 == _tcscmp(pszKey, HVAC_HIDEEXTENT)
			|| 0 == _tcscmp(pszKey, HVAC_PIPEHIDEWIDTH))
		{
			double dValue = 0;
			if(GetGlobalContext()->GetAt(pszKey, dValue))
			{
				TAuxTools::SetTHvacDataToDwg(pszKey, dValue);
			}
		}
	}
}

// 从图纸中读取暖通风管遮挡参数
DLLIMPEXP void GetTHvacParamFromDwg()
{
	BOOL bShowCover = FALSE; // 显示遮挡
	if(TAuxTools::GetTHvacDataFromDwg(KEY_HIDEDRAW, bShowCover))
	{
		GetGlobalContext()->SetAt(KEY_HIDEDRAW, bShowCover);
	}

	double dHideWidth = 0; // 打断间隙
	if(TAuxTools::GetTHvacDataFromDwg(HVAC_HIDEEXTENT, dHideWidth))
	{
		// add by hh 2011-10-11 支持遮挡宽度随比例变化
		if(10 < dHideWidth)
		{
			// 兼容旧版图纸,宽度大于10时,认为是旧版数据,转换为新版的
			dHideWidth /= DocGetPScale();
			TAuxTools::SetTHvacDataToDwg(HVAC_HIDEEXTENT, dHideWidth);
		}
		GetGlobalContext()->SetAt(HVAC_HIDEEXTENT, dHideWidth);
	}

	BOOL bShowWidth = FALSE; // 是否加粗
	if(TAuxTools::GetTHvacDataFromDwg(HVAC_SHOWWIDTH, bShowWidth))
	{
		GetGlobalContext()->SetAt(HVAC_SHOWWIDTH, bShowWidth);
	}
	// add by hh 2011-01-05 兼容8.2版图纸
	else
	{
		AcDbBlockTable* pBlockTable = NULL;
		AcDbBlockTableRecord* pTableRecord = NULL;
		if(acdbHostApplicationServices()->workingDatabase()->getBlockTable(pBlockTable, AcDb::kForRead) != Acad::eOk)
			return;

		pBlockTable->close();
		if(pBlockTable->getAt(ACDB_MODEL_SPACE, pTableRecord, AcDb::kForRead) != Acad::eOk)
			return;

		pTableRecord->close();

		bShowWidth = (BOOL)_ttoi(TAuxTools::ReadXdata(pTableRecord->id(), HVAC_SHOWWIDTH));
		GetGlobalContext()->SetAt(HVAC_SHOWWIDTH, bShowWidth);

		// 将是否加粗标识写入动态扩展数据中 转换为8.5版图纸
		//bsl 2011.10.26 增加暖通判断
		// change by hh 2013-03-25 暖通标准版ID从6改成15
		// if (g_nProductId == 6 || g_nProductId == 5) 
		if (g_nProductId == 15 || g_nProductId == 5) 
			TAuxTools::SetTHvacDataToDwg(HVAC_SHOWWIDTH, bShowWidth);
	}

	double dBrWidth = 0; // 水管风管打断间隙
	if(TAuxTools::GetTHvacDataFromDwg(HVAC_PIPEHIDEWIDTH, dBrWidth))
	{
		GetGlobalContext()->SetAt(HVAC_PIPEHIDEWIDTH, dBrWidth);
	}

	BOOL bPipeDuctBreak = FALSE; // 风管与水管打断
	if(TAuxTools::GetTHvacDataFromDwg(HVAC_PIPEDUCTBREAK, bPipeDuctBreak))
	{
		GetGlobalContext()->SetAt(HVAC_PIPEDUCTBREAK, bPipeDuctBreak);
	}
}

AcGePoint3d TAuxTools::Mid(AcGePoint3d ptGe1, AcGePoint3d ptGe2)
{
	return AcGePoint3d((ptGe1.x + ptGe2.x) / 2.0,(ptGe1.y + ptGe2.y) / 2.0,(ptGe1.z + ptGe2.z) / 2.0);
}

/*	
两圆相交法求椭圆法点图

					  O2
							
					   D
					   |
					   |					   
		  A--O1--------O-----------B
				 	   |
				F	   |
					   C
 */
// int TAuxTools::GetEllipseFromCircle( AcGePoint3d ptCenter, double dDia, AcGeVector3d vtOrigNormal, 
// 									AcGeVector3d vtNewNormal, AcDbPolyline &polyLine, AcGeVector3d vtGet)
// {	
// 	vtOrigNormal.normalize();
// 	vtNewNormal.normalize();
// 
// 	double dRadius = dDia * 0.5;
// 	AcGePlane planStd;											// 椭圆投影所在标准面
// 	planStd.set(ptCenter, vtNewNormal);
// 	AcGePoint3d ptPrj = AcGePoint3d::kOrigin.orthoProject(planStd);
// 	planStd.set(ptPrj, vtNewNormal);
// 	double dEle = ptPrj.asVector().length();
// 	if (!ptPrj.asVector().isCodirectionalTo(planStd.normal()))
// 	{
// 		dEle *= -1.0;
// 	}
// 	if (vtNewNormal.isParallelTo(vtOrigNormal))					// 平行,还是圆
// 	{
// 		AcGePoint3d ptStart, ptEnd;
// 		if (vtGet.length() < 1e-6)								// 整个圆
// 		{
// 			AcGeVector3d vtPerl = vtOrigNormal.perpVector();
// 
// 			ptStart = ptCenter + dRadius * vtPerl;
// 			ptEnd = ptCenter - dRadius * vtPerl;
// 			polyLine.addVertexAt(0, ptStart.convert2d(planStd), 1.0);
// 			polyLine.addVertexAt(1, ptEnd.convert2d(planStd), 1.0);
// 			polyLine.setClosed(Adesk::kTrue);
// 		}
// 		else													// 半个圆
// 		{
// 			AcGeVector3d vtPerl = vtGet.orthoProject(vtNewNormal);
// 			vtPerl.rotateBy(-PI / 2, vtNewNormal);
// 			vtPerl.normalize();
// 
// 			ptStart = ptCenter + dRadius * vtPerl;
// 			ptEnd = ptCenter - dRadius * vtPerl;
// 			polyLine.addVertexAt(0, ptStart.convert2d(planStd), 1);
// 			polyLine.addVertexAt(1, ptEnd.convert2d(planStd), 0);
// 		}
//     
// 		polyLine.setElevation(dEle);
// 		polyLine.setNormal(vtNewNormal);
// 		return 0;
// 	}
// 	else if (vtNewNormal.isPerpendicularTo(vtOrigNormal))		// 垂直情况， 为直线
// 	{
// 		AcGeVector3d vtCrossPerl = vtOrigNormal.crossProduct(vtNewNormal);
// 		AcGePoint3d ptStart, ptEnd;
// 		ptStart = ptCenter + dRadius * vtCrossPerl;
// 		ptEnd = ptCenter - dRadius * vtCrossPerl;
// 		polyLine.addVertexAt(0, ptStart.convert2d(planStd));
// 		polyLine.addVertexAt(1, ptEnd.convert2d(planStd));
// 		polyLine.setElevation(dEle);
// 		polyLine.setNormal(vtNewNormal);
// 		return 1;
// 	}
// 	else														// 普通投影为椭圆情况
// 	{		
// 		// 长/短轴向量
// 		AcGeVector3d vtLong = vtOrigNormal.crossProduct(vtNewNormal);
// 		vtLong.normalize();
// 		AcGeVector3d vtShort = vtLong;
// 		vtShort.rotateBy(PI * 0.5, vtOrigNormal);
// 
// 		// 把向量投影到所给面上
// 		vtLong = vtLong.orthoProject(vtNewNormal);
// 		vtShort = vtShort.orthoProject(vtNewNormal);
// 
// 		AcGePoint3d ptO = ptCenter.orthoProject(planStd);	// 中心点
// 		AcGePoint3d ptA = ptO + dDia * 0.5 * vtLong;		// A
// 		AcGePoint3d ptB = ptA - dDia * vtLong;				// B
// 		AcGePoint3d ptC = ptO + dDia * 0.5 * vtShort;		// C
// 		AcGePoint3d ptD = ptC - dDia * vtShort;				// D
// 	
// 		double CF = dDia / 2 - ptC.distanceTo(ptD) / 2;	
// 		AcGeVector3d vtCF = ptA - ptC;
// 		vtCF.normalize();
// 		AcGePoint3d ptF = ptC + CF * vtCF;
// 		
// 		AcGeLine3d lineAB(ptA, ptB);
// 		AcGeLine3d lineCD(ptC, ptD);
// 		AcGeLine3d lineAF(ptA, ptF);
// 
// 		// 求线AF的中垂线
// 		AcGeVector3d vtAFPerl = ptF - ptA;
// 		vtAFPerl.rotateBy(PI * 0.5, vtNewNormal);
// 		AcGePoint3d ptAFMid = Mid(ptA, ptF);
// 		AcGeLine3d lineAFPerl(ptAFMid, ptAFMid + 100 * vtAFPerl);
// 		
// 		AcGePoint3d ptO1, ptO2;									// 两个辅助圆圆心O1 O2
// 		lineAFPerl.intersectWith(lineAB, ptO1);					
// 		lineAFPerl.intersectWith(lineCD, ptO2);	
// 		
// 		double dRad1 = ptO1.distanceTo(ptA);					// 两圆对应半径
// 		double dRad2 = ptO2.distanceTo(ptC);
// 		
// 		// 构造两个圆，求交点,为两弧邻接点
// 		AcGeCircArc3d cir1(ptO1, vtNewNormal, dRad1);
// 		AcGeCircArc3d cir2(ptO2, vtNewNormal, dRad2);
// 		AcGePoint3d ptCross, ptCross2;
// 		int nSucsId(0);
// 		cir1.intersectWith(cir2, nSucsId, ptCross, AcGePoint3d());
// 		
// 		if (nSucsId < 1)
// 			return -1;
// 
// 		// 镜像后得到其他3个邻接点
// 		AcGePoint3d ptCrossLongMir(ptCross), ptCrossShortMir(ptCross), ptCrossInclinMir;
// 		AcGePlane planAB(ptO, ptC - ptD);
// 		AcGePlane planCD(ptO, ptA - ptB);
// 		ptCrossLongMir.mirror(planAB);
// 		ptCrossShortMir.mirror(planCD);
// 		ptCrossInclinMir = ptCrossShortMir;
// 		ptCrossInclinMir.mirror(planAB);
// 	
// 		// 求两种弧bulge值
// 		AcGePoint3d ptMidCorss1 = Mid(ptCross, ptCrossLongMir);
// 		AcGePoint3d ptMidCorss2 = Mid(ptCross, ptCrossShortMir);
// 		double dBulge1 = ptMidCorss1.distanceTo(ptA) / ptMidCorss1.distanceTo(ptCross);
// 		double dBulge2 = ptMidCorss2.distanceTo(ptC) / ptMidCorss2.distanceTo(ptCross);
// 
// 		// 矫正Bulge正负值
// 		AcGeVector3d vtClockSta = ptCrossShortMir - ptCross;
// 		AcGeVector3d vtClockEnd = ptCrossLongMir - ptCross;
// 		AcGeVector3d vtClockPerl =  vtClockSta.crossProduct(vtClockEnd);
// 		if (!vtClockPerl.isCodirectionalTo(vtNewNormal))
// 		{
// 			dBulge1 *= -1;
// 			dBulge2 *= -1;
// 		}
// 
// 		if (vtGet.length() < 1e-6)
// 		{
// 			polyLine.addVertexAt(0, ptCross.convert2d(planStd), dBulge2);
// 			polyLine.addVertexAt(1, ptCrossShortMir.convert2d(planStd), dBulge1);
// 			polyLine.addVertexAt(2, ptCrossInclinMir.convert2d(planStd), dBulge2);
// 			polyLine.addVertexAt(3, ptCrossLongMir.convert2d(planStd), dBulge1);
// 			polyLine.setClosed(Adesk::kTrue);
// 		}
// 		else
// 		{
// 			vtGet = vtGet.orthoProject(vtNewNormal);
// 			if (vtGet.angleTo(vtShort) < PI*0.5)	// C 端部分
// 			{
// 				polyLine.addVertexAt(0, ptA.convert2d(planStd), dBulge1*0.5);
// 				polyLine.addVertexAt(1, ptCross.convert2d(planStd), dBulge2);
// 				polyLine.addVertexAt(2, ptCrossShortMir.convert2d(planStd), dBulge1*0.5);
// 				polyLine.addVertexAt(3, ptB.convert2d(planStd));
// 			}
// 			else									// D 端部分
// 			{
// 				polyLine.addVertexAt(0, ptB.convert2d(planStd), dBulge1*0.5);
// 				polyLine.addVertexAt(1, ptCrossInclinMir.convert2d(planStd), dBulge2);
// 				polyLine.addVertexAt(2, ptCrossLongMir.convert2d(planStd), dBulge1*0.5);
// 				polyLine.addVertexAt(3, ptA.convert2d(planStd));
// 			}
// 		}
// 	}		
// 
// 	polyLine.setElevation(dEle);
// 	polyLine.setNormal(vtNewNormal);
// 
// 	return 2;
// }

int TAuxTools::GetEllipseFromCircle( AcGePoint3d ptCenter, double dDia, AcGeVector3d vtOrigNormal, 
									AcGeVector3d vtNewNormal, AcDbPolyline &polyLine, AcGeVector3d vtGet)
{	
	vtOrigNormal.normalize();
	vtNewNormal.normalize();

	double dRadius = dDia * 0.5;
	AcGePlane planStd;											// 椭圆投影所在标准面
	planStd.set(ptCenter, vtNewNormal);
	AcGePoint3d ptPrj = AcGePoint3d::kOrigin.orthoProject(planStd);
	planStd.set(ptPrj, vtNewNormal);
	double dEle = ptPrj.asVector().length();
	if (!ptPrj.asVector().isCodirectionalTo(planStd.normal()))
	{
		dEle *= -1.0;
	}
	if (vtNewNormal.isParallelTo(vtOrigNormal))					// 平行,还是圆
	{
		AcGePoint3d ptStart, ptEnd;
		if (vtGet.length() < 1e-6)								// 整个圆
		{
			AcGeVector3d vtPerl = vtOrigNormal.perpVector();

			ptStart = ptCenter + dRadius * vtPerl;
			ptEnd = ptCenter - dRadius * vtPerl;
			polyLine.addVertexAt(0, ptStart.convert2d(planStd), 1.0);
			polyLine.addVertexAt(1, ptEnd.convert2d(planStd), 1.0);
			polyLine.setClosed(Adesk::kTrue);
		}
		else													// 半个圆
		{
			AcGeVector3d vtPerl = vtGet.orthoProject(vtNewNormal);
			vtPerl.rotateBy(-PI / 2, vtNewNormal);
			vtPerl.normalize();

			ptStart = ptCenter + dRadius * vtPerl;
			ptEnd = ptCenter - dRadius * vtPerl;
			polyLine.addVertexAt(0, ptStart.convert2d(planStd), 1);
			polyLine.addVertexAt(1, ptEnd.convert2d(planStd), 0);
		}

		polyLine.setElevation(dEle);
		polyLine.setNormal(vtNewNormal);
		return 0;
	}
	else if (vtNewNormal.isPerpendicularTo(vtOrigNormal))		// 垂直情况， 为直线
	{
		AcGeVector3d vtCrossPerl = vtOrigNormal.crossProduct(vtNewNormal);
		AcGePoint3d ptStart, ptEnd;
		ptStart = ptCenter + dRadius * vtCrossPerl;
		ptEnd = ptCenter - dRadius * vtCrossPerl;
		polyLine.addVertexAt(0, ptStart.convert2d(planStd));
		polyLine.addVertexAt(1, ptEnd.convert2d(planStd));
		polyLine.setElevation(dEle);
		polyLine.setNormal(vtNewNormal);
		return 1;
	}
	else														// 普通投影为椭圆情况
	{		
		// 长/短轴向量
		AcGeVector3d vtLong = vtOrigNormal.crossProduct(vtNewNormal);
		vtLong.normalize();
		AcGeVector3d vtShort = vtLong;
		vtShort.rotateBy(PI * 0.5, vtOrigNormal);

		AcGeVector3d vtPerp = vtOrigNormal.crossProduct(vtNewNormal);
		vtPerp.normalize();
		double dMinAngle = GetMinDiffAngle();
//		dMinAngle *= 0.5;
		int nPart = (int)(PI / dMinAngle) +1;
		dMinAngle = PI / nPart;

		AcGePoint3d ptNow;
		AcGePoint3dArray arptsEdge;
		if (vtGet.length() < 1e-6)
		{
			ptNow = ptCenter + vtPerp * dDia * 0.5;
			for(int i = 0; i <= nPart*2; i++)
			{
				polyLine.addVertexAt(i, ptNow.convert2d(planStd));
				ptNow.rotateBy(dMinAngle, vtOrigNormal, ptCenter);
			}
		}
		else
		{
			vtGet = vtGet.orthoProject(vtNewNormal);
			if (vtGet.angleTo(vtShort) < PI*0.5)	// C 端部分
			{
				ptNow = ptCenter + vtPerp * dDia * 0.5;
				for(int i = 0; i <= nPart; i++)
				{
					polyLine.addVertexAt(i, ptNow.convert2d(planStd));
					ptNow.rotateBy(dMinAngle, vtOrigNormal, ptCenter);
				}
			}
			else									// D 端部分
			{
				ptNow = ptCenter - vtPerp * dDia * 0.5;
				for(int i = 0; i <= nPart; i++)
				{
					polyLine.addVertexAt(i, ptNow.convert2d(planStd));
					ptNow.rotateBy(dMinAngle, vtOrigNormal, ptCenter);
				}
			}
		}
	}		

	polyLine.setElevation(dEle);
	polyLine.setNormal(vtNewNormal);

	return 2;
}

void TAuxTools::GetArcPoint(AcDbPolyline &polyLine, AcGePoint3dArray &ptArcArr)
{
// 	if (polyLine.numVerts() != 4)
// 		return;
// 	
	double dBugle(0.0);
	polyLine.getBulgeAt(0, dBugle);
	if (EQUAL_ZERO(dBugle - 1.0))// Polyline线是半个圆,或者圆
	{
		double dPar1, dPar2;
		AcGePoint3d pt0, pt1, pt2, pt3, ptMid;

		polyLine.getPointAt(0, pt0);
		polyLine.getPointAt(1, pt1);
		polyLine.getPointAt(2, pt2);
		polyLine.getPointAt(3, pt3);

		polyLine.getParamAtPoint(pt0, dPar1);
		polyLine.getParamAtPoint(pt1, dPar2);
		polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
		ptArcArr.append(pt0);
		ptArcArr.append(ptMid);
		ptArcArr.append(pt1);

		polyLine.getParamAtPoint(pt1, dPar1);
		polyLine.getParamAtPoint(pt2, dPar2);
		polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
		ptArcArr.append(ptMid);
		ptArcArr.append(pt2);

		polyLine.getParamAtPoint(pt2, dPar1);
		polyLine.getParamAtPoint(pt3, dPar2);
		polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
		ptArcArr.append(ptMid);
		ptArcArr.append(pt3);

		if (polyLine.isClosed())
		{
			polyLine.getParamAtPoint(pt3, dPar1);
			polyLine.getEndParam(dPar2);
			polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
			ptArcArr.append(ptMid);
			ptArcArr.append(pt0);
		}
	}
	else
	{
		AcGePoint3d pt1;
		for(int i = 0; i < polyLine.numVerts(); i++)
		{
			polyLine.getPointAt(i, pt1);
			ptArcArr.append(pt1);
		}
	}
}

int TAuxTools::GetEllipsePtsFromCircle(AcGePoint3dArray& arPtsOnCurve, AcGePoint3d ptCenter, double dDia, AcGeVector3d vtOrigNormal, 
							AcGeVector3d vtNewNormal, AcDbPolyline &polyLine, AcGeVector3d vtGet/* = AcGeVector3d::kIdentity*/)
{
	int iRes = TAuxTools::GetEllipseFromCircle(ptCenter, dDia, vtOrigNormal, vtNewNormal, polyLine, vtGet);
	if (iRes != -1)
	{
		AcGePoint3d ptTemp, ptTemp1, ptTemp2;
		double dPam1, dPam2;
		AcGeVector3d vtDir;
		AcGePlane plan;
		switch (iRes)
		{
		default:
		case 2:// 投影为椭圆
			TAuxTools::GetArcPoint(polyLine, arPtsOnCurve);
			break;
		case 1:// 投影为直线
			polyLine.getPointAt(0, ptTemp);
			arPtsOnCurve.append(ptTemp);
			polyLine.getPointAt(1, ptTemp);
			arPtsOnCurve.append(ptTemp);
			arPtsOnCurve.append(ptTemp);
			break;
		case 0:// 投影为圆
			if (polyLine.isClosed())// 整个圆
			{
				polyLine.getPointAt(0, ptTemp1);
				polyLine.getPointAt(1, ptTemp2);
				polyLine.getParamAtPoint(ptTemp1, dPam1);
				polyLine.getParamAtPoint(ptTemp2, dPam2);
				polyLine.getPointAtParam((dPam1+dPam2)*0.5, ptTemp);
				arPtsOnCurve.append(ptTemp1);
				arPtsOnCurve.append(ptTemp);
				arPtsOnCurve.append(ptTemp2);

				vtDir = ptTemp1 - ptTemp2;
				plan.set(TAuxTools::Mid(ptTemp1, ptTemp2), vtDir.rotateBy(PI * 0.5, vtNewNormal));
				ptTemp.mirror(plan);
				arPtsOnCurve.append(ptTemp);
				arPtsOnCurve.append(ptTemp1);
			}
			else// 半个圆
			{
				polyLine.getPointAt(0, ptTemp1);
				polyLine.getPointAt(1, ptTemp2);
				polyLine.getParamAtPoint(ptTemp1, dPam1);
				polyLine.getParamAtPoint(ptTemp2, dPam2);
				polyLine.getPointAtParam((dPam1+dPam2)*0.5, ptTemp);
				arPtsOnCurve.append(ptTemp1);
				arPtsOnCurve.append(ptTemp);
				arPtsOnCurve.append(ptTemp2);
			}
			
			break;
		}
	}
	return iRes;
}

BOOL TAuxTools::GetPrjPtsFromCircle(AcGePoint3dArray& ptArr, AcGePoint3dArray& arPtJudge)
{
	XCircle cir;
	AcGeVector3d vtTmp1, vtTmp2, vtCirNor;
	AcGePoint3d ptCirCen, ptIn, ptU, ptD;
	AcGePoint3dArray arPtSides;
	AcGePlane plan;
	int iRes(-1);
	AcDbPolyline* pLine = new AcDbPolyline;
	if (NULL == pLine)
		return TRUE;
	for (int i = 0; i < ptArr.length(); )
	{
		cir.Set(ptArr[i], ptArr[i+1], ptArr[i+2]);
		ptCirCen = cir.m_ptCenter.AsAcGePoint3d();
		vtTmp1 = ptArr[i+1] - ptCirCen;
		vtTmp2 = ptArr[i+2] - ptCirCen;
		// 分节圆法向
		vtCirNor = vtTmp1.crossProduct(vtTmp2);	
		plan.set(ptCirCen, TAuxTools::GetUcsZvt());

		iRes = TAuxTools::GetEllipseFromCircle(ptCirCen, cir.m_dRadius * 2, vtCirNor, TAuxTools::GetUcsZvt(), *pLine, vtCirNor);
		if (-1 == iRes)
		{
			if (NULL != pLine)
				delete pLine;
			return FALSE;
		}

		pLine->getPointAt(0, ptU);
		pLine->getPointAt(pLine->numVerts()-1, ptD);
		plan.set(arPtJudge[i / 3], TAuxTools::GetUcsZvt());
		ptU = ptU.orthoProject(plan);
		ptD = ptD.orthoProject(plan);
		if (ptD.distanceTo(arPtJudge[ i / 3]) <= ptU.distanceTo(arPtJudge[ i / 3]))
		{
			// 总是先添加距离ptArrCen[ i / 3]近的点
			arPtSides.append(ptD);
			arPtSides.append(ptU);
		}
		else
		{
			arPtSides.append(ptU);
			arPtSides.append(ptD);
		}
		pLine->reset(Adesk::kFalse, iRes);
		i = i+3;// 每3个点确定一个面
	}
	if (NULL == pLine)
		delete pLine;

	arPtJudge.setLogicalLength(0);
	arPtJudge.append(arPtSides);

	return TRUE;
}

BOOL TAuxTools::MergerPline(AcDbPolyline* pPl,AcDbPolyline* pSrc) 
{
	AcGePoint3d ptStart,ptStart2;
	AcGePoint3d ptEnd,ptEnd2;

	pPl->getStartPoint(ptStart);
	pPl->getEndPoint(ptEnd);
	
	pSrc->getStartPoint(ptStart2);
	pSrc->getEndPoint(ptEnd2);
	AcGePoint2d pt2d;
	double dBulge = -1;
	
	if (ptStart.distanceTo(ptStart2) < 1.e-3) //sta 重合
	{
		int nVerts = pSrc->numVerts();
		for (int i = 1;i < nVerts; i++) 
		{
			pSrc->getPointAt(i, pt2d);
			pSrc->getBulgeAt(i - 1, dBulge);
			pPl->addVertexAt(0, pt2d, -dBulge);
		}
	}
	else if (ptStart.distanceTo(ptEnd2) < 1.e-3) //end
	{
		int nVerts = pSrc->numVerts() - 1;
 		for (int i = nVerts; i > 0; i--) 
 		{
			pSrc->getPointAt(i - 1, pt2d);
			pSrc->getBulgeAt(i - 1, dBulge);
			pPl->addVertexAt(0, pt2d, dBulge);
		}
	}
	else if (ptEnd.distanceTo(ptStart2) < 1.e-3) //sta 重合
	{
		int nVerts = pPl->numVerts();
		for (int i = 1; i < (int)pSrc->numVerts(); i++) 
		{
			pSrc->getPointAt(i, pt2d);
			pSrc->getBulgeAt(i - 1, dBulge);
			if (1 == i)
			{
				pPl->setBulgeAt(nVerts - 1, dBulge);
			}
			pPl->addVertexAt(nVerts, pt2d, dBulge);
			nVerts++;
		}
	}
	else if (ptEnd.distanceTo(ptEnd2) < 1.e-3) //end
	{
		int nVerts = pPl->numVerts();
		for (int i = pSrc->numVerts() - 1; i > -1; i--) 
		{
			pSrc->getPointAt(i, pt2d);
			pSrc->getBulgeAt(i - 1, dBulge);
			pPl->addVertexAt(nVerts, pt2d, -dBulge);
			nVerts++;
		}
	}
	// Lixl处理两条PLine线不同高度的情况
	else
	{
		ptStart2.z = ptStart.z;
		ptEnd2.z = ptEnd.z;

		int nVerts = pPl->numVerts();
		int nPlVerts = nVerts - 1;
		if (ptEnd.distanceTo(ptStart2) < 1.e-3)
		{
			for (int i = 0; i < (int)pSrc->numVerts(); i++)
			{
				pSrc->getPointAt(i, pt2d);
				pSrc->getBulgeAt(i, dBulge);
				pPl->addVertexAt(nVerts, pt2d, dBulge);
				nVerts++;
			}
			pPl->setBulgeAt(nPlVerts, 0);
		}
		else if (ptEnd.distanceTo(ptEnd2) < 1.e-3)
		{
			for (int i = pSrc->numVerts()-1; i >= 0; i--)
			{
				pSrc->getPointAt(i, pt2d);
				pSrc->getBulgeAt(i-1, dBulge);
				if (0 == i)
					dBulge = 0.0;
				pPl->addVertexAt(nVerts, pt2d, -dBulge);
				nVerts++;
			}
			pPl->setBulgeAt(nPlVerts, 0);
		}
	}

	return TRUE;
}

int TAuxTools::PositionOnLine(AcGePoint3d ptSta, AcGePoint3d ptEnd, AcGePoint3d ptBase)
{
	AcGeVector3d vt = ptSta - ptEnd;
	vt.normalize();
	double dBS = ptBase.distanceTo(ptSta);
	double dBE = ptBase.distanceTo(ptEnd);
	double dSE = ptEnd.distanceTo(ptSta);
	//在两个点中间位置	
	if (((dBS + dBE) - dSE) < 1.e-3 )
	{
		return 0;
	}
	else
	{
		//在S端左侧
		if (dBS < dBE)
		{
			return 1;
		}
		//在E端右侧
		else
		{
			return 2;
		}
	}
	return -1;
}

BOOL TAuxTools::isCodirectionalPt(AcGePoint3d ptSta, AcGePoint3d ptEnd, AcGeVector3d vtBase)
{
	AcGeVector3d vt = ptSta - ptEnd;
	return vt.isCodirectionalTo(vtBase);
}

AcGePlane TAuxTools::GetHidePlane(AcGePoint3d pt1, AcGePoint3d pt2, AcGePoint3d pt3,  
										 AcGeVector3d vtNormal, double &dEle)
{
	AcGePlane plan(pt1, pt2, pt3);
	AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
	plan.set(ptOrth, vtNormal);
	
	dEle = ptOrth.asVector().length();
	if (!ptOrth.asVector().isCodirectionalTo(vtNormal))
		dEle *= -1.0;
	
	return plan;
}

BOOL TAuxTools::InsertBlock(AcDbVoidPtrArray& entitySet,AcDbObjectId idBlock, AcGePoint3d ptBase, AcGeScale3d ScaleFactor,double dAngle)
{
	AcDbBlockReference blcRfr;
	blcRfr.setNormal(AcGeVector3d::kZAxis); 
	blcRfr.setBlockTableRecord(idBlock); 
	blcRfr.setPosition(ptBase); 
	blcRfr.setRotation(dAngle); 
	blcRfr.setScaleFactors(ScaleFactor);
	blcRfr.explode(entitySet);

	return TRUE;
}

BOOL TAuxTools::GetIntersectWith(AcGePoint3d pt1,AcGePoint3d pt2,AcGePoint3d pt3,AcGePoint3d pt4,AcGePoint3d& ptIntersect)
{
	AcGeLine3d line1,line2;
	line1.set(pt1,pt2);
	line2.set(pt3,pt4);
	return	line1.intersectWith(line2, ptIntersect);
}

int TAuxTools::Getquadrant(AcGePoint3d ptCenter, AcGePoint3d pt, AcGeVector3d vtMain, AcGeVector3d vtNormal)
{
	AcGeVector3d vtBr = pt - ptCenter;
	double dAngle = vtMain.angleTo(vtBr, vtNormal);
	if (dAngle >= PI * 0.5 && dAngle < PI)
	{
		return 2;
	}
	else if (dAngle >= PI && dAngle < PI * 1.5)
	{
		return 3;
	}
	else if (dAngle >= PI * 1.5 && dAngle < PI * 2 )
	{
		return 4;
	}
    return 1;
}

// 用户X坐标向量
AcGeVector3d TAuxTools::GetUcsXvt()
{
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	AcDbDatabase* pDb = acdbCurDwg();
	if (NULL != pDb)
		vtX = pDb->ucsxdir();	

	return vtX;
}

AcGeVector3d TAuxTools::GetUcsYvt()
{
	AcGeVector3d vtY = AcGeVector3d::kYAxis;
	AcDbDatabase* pDb = acdbCurDwg();
	if (NULL != pDb)
		vtY = pDb->ucsydir();	

	return vtY;
}

AcGeVector3d TAuxTools::GetUcsZvt()
{
	AcGeVector3d vtZ = AcGeVector3d::kZAxis;
	AcDbDatabase* pDb = acdbCurDwg();
	if (NULL != pDb)
		vtZ = pDb->ucsxdir().crossProduct(pDb->ucsydir());	

	return vtZ;
}

//////////////////////////////////////////////////////////////////////////
// 风管沿程阻力水力计算
double TAuxTools::CalFricLoss( double dTemp, double dRough, double dDia, double dLength, double dVelocity )
{
	//double dDensity = CalDesity(dTemp);							// 密度
	double dDensity = TDbHvacDimension::m_dDensity;					// 密度
	//double dMoveVis = CalMoveVis(dTemp);						// 运动黏度(m^2/s)；范围：>0
	double dMoveVis = TDbHvacDimension::m_dMoveVis * 1.e-6;
	double dRe = CalRe(dVelocity, dDia, dMoveVis);				// 计算Re
	double dFricCoef = CalFricCoef(dRough, dDia, dRe);			// 计算摩擦系数
	return CalCircleFricLoss(dFricCoef, dDia, dLength, dDensity, dVelocity);
}

double TAuxTools::CalFricLoss( double dTemp, double dRough, double dWidth, double dHeight, 
														double dLength, double dVelocity )
{
	double dDia = CalVelDia(dWidth, dHeight);
	return CalFricLoss(dTemp, dRough, dDia, dLength, dVelocity);
}

// 圆管沿程阻力 dFricCoef摩擦系数 管径(mm)、管长(m)、密度(kg/m^3)和流速(m/s)计算沿程阻力(Pa)
double TAuxTools::CalCircleFricLoss(double dFricCoef, double dDia, double dLength,
										double dDensity, double dVelocity)
{
	if ((dFricCoef < ZERO_AIR) || (dDia < ZERO_AIR) || (dLength < 0)
		|| (dDensity < ZERO_AIR) || (dVelocity < 0))
		return 0.0;
	return dFricCoef * dLength * dDensity * pow(dVelocity, 2) / (0.002 * dDia);
}

// 根据粗糙度(mm)、流速当量直径(mm)和雷诺数计算摩擦系数, 用柯列勃洛克-怀特公式计算
double TAuxTools::CalFricCoef(double dRough, double dCalDia, double dRe)
{
	if ((dRough < 0.0) || (dCalDia < ZERO_AIR) || (dRe < ZERO_AIR))
		return ZERO_AIR;
	
	if (dRe < 2000)
		return 64 / dRe;
	
	double dA, dB;	// 系数a, b
	dA = dRough / (3.7 * dCalDia);
	dB = 2.51 / dRe;
	double dNewX, dOldX;	// 用于迭代计算的新旧数据 =1/(FricCoef)^0.5
	dNewX = 5.0;	// 初始值为5
	
	double e = 1.0;		// 两次迭代之差
	double t = 0.0;
	int nFlag = 0;		// 控制最大迭代次数
	while ((e > 0.0001) && (nFlag < 100)) 
	{
		dOldX = dNewX;
		t = dA + dB * dOldX;
		if (t < ZERO_AIR)
			return 0.0;	// 认为无解
		dNewX = dOldX - (dOldX + 2 * log10(t)) * (t) * log(10.0) / ((t) * log(10.0) + 2 * dB);
		e = fabs(dNewX - dOldX);		
		nFlag++;
	}
	if (nFlag >= 100)
		return 0.0;		// 认为无解
	return 1 / pow(dNewX, 2);	
}

// 根据管宽(mm)和管高(mm)计算流速当量直径(mm)
double TAuxTools::CalVelDia(double dWidth, double dHeight)
{
	if ((dWidth < ZERO_AIR) || (dHeight < ZERO_AIR))
		return 0.0;	
	return 2 * dWidth * dHeight / (dWidth + dHeight);
}

// 流速(m/s)、流速当量直径(mm)和黏度(m^2/s)计算雷诺数
double TAuxTools::CalRe(double dVelocity, double dVelDia, double dMoveVis)
{
	if ((dVelocity < 0.0) || (dVelDia < ZERO_AIR) || (dMoveVis < 1.0e-10))
		return ZERO_AIR;
	return dVelocity * 0.001 * dVelDia / dMoveVis;
}

double TAuxTools::CalDesity(double dTemperature)
{
	double dDensity[15] = {1.293, 1.270, 1.248, 1.226, 1.205,
		1.185, 1.165, 1.146, 1.128, 1.093,
		1.060, 1.029, 1.000, 0.973, 0.947};
	double dTem[15] = {0, 5, 10, 15, 20,
		25, 30, 35, 40, 50,
		60, 70, 80, 90, 100};
	
	return CalTable(dTem, (double*)dDensity, dTemperature, 15);
}

double TAuxTools::CalMoveVis(double dTemperature)
{
	double dMovVis[18] = {13.7, 14.7, 15.7, 16.6, 17.6,
		18.6, 19.6, 20.5, 21.7, 22.9,
		23.6, 26.2, 28.5, 30.6, 33.2, 
		35.8, 42.8, 49.9};
	double dTem[18] = {0, 10, 20, 30, 40,
		50, 60, 70, 80, 90,
		100, 120, 140, 160, 180,
		200, 250, 300};
	
	return CalTable(dTem, (double*)dMovVis, dTemperature, 18) * 1.0e-6;
}

/*----------------------------------------------------------------------------*
* 功能描述: 用插值法从一维表格中取值
* 备    注:	dAbscissa为表头；共m列数据；dX表示列值;表头升序
-----------------------------------------------------------------------------*/
double TAuxTools::CalTable(double dAbscissa[], double *pTable, double dX, int m)
{
	if (dX < dAbscissa[0])
		dX = dAbscissa[0];
	else if (dX > dAbscissa[m - 1])
		dX = dAbscissa[m - 1];
	
	for(int i = 0; i < m; i++)
	{
		if (dAbscissa[i] == dAbscissa[i - 1])	// 与前一个表头相等
			continue;
		
		if (dX == dAbscissa[i])					// 等于某个表头
			return pTable[i];
		else if (dX < dAbscissa[i])				// 小于某个表头，用查值
			return (pTable[i] - pTable[i - 1])*(dX - dAbscissa[i - 1]) 
			/ (dAbscissa[i] - dAbscissa[i - 1]) + pTable[i - 1];
	}
	return 0.0;
}
//////////////////////////////////////////////////////////////////////////

//  用于特性表修改某些参数后,更新遮挡关系
void TAuxTools::SetAndUpdateCover(TDbInterfacesObj* pObj, LPCTSTR pszName, TDb::OPMInfo* pInfo)
{
	// 设置数据时，更新遮挡
	if (NULL != pObj && NULL != pInfo->pXData && 0 != pInfo->pXData->nVt)
	{
		// 设置数据
		TDbXDataMap* pMap = pObj->GetSpecialtyData();
		if (NULL != pMap)
		{
			pMap->SetAt(pszName, *pInfo->pXData);
			pInfo->pXData->nVt = 0;		// 设置处理完成标识
			pObj->FlashCoverDisplay();
		}
	}
}

// 获得字体样式表
void TAuxTools::GetAllTextStyleNameArray(CStringArray& arTextStyle)
{
	AcDbTextStyleTable* pTextStyleTbl = NULL;
	AcDbTextStyleTableRecord* pTextStyleTblRec = NULL;
	if (acdbHostApplicationServices()->workingDatabase() \
		->getTextStyleTable(pTextStyleTbl, AcDb::kForRead) == Acad::eOk)
	{
		// 文字样式表记录
		AcDbTextStyleTableIterator* pIterator = NULL;
		if (pTextStyleTbl->newIterator(pIterator) == Acad::eOk)
		{
			for (pIterator->start(); !pIterator->done(); pIterator->step())
			{
				if (pIterator->getRecord(pTextStyleTblRec, AcDb::kForRead) == Acad::eOk)
				{
					LPCTSTR pszName = NULL;
					pTextStyleTblRec->getName(pszName);
					arTextStyle.Add(pszName);

					pTextStyleTblRec->close();
				}
			}

			delete pIterator;
		}

		pTextStyleTbl->close();
	}
}

// 获取最小分度角（曲面分化成小平面，相邻平面法向量间最小夹角）
double TAuxTools::GetMinDiffAngle()
{
	double dMinDiffAng = PI/12;
	GetGlobalContext()->GetAt(KEY_MINDIFFANG, dMinDiffAng);
	if (dMinDiffAng < 1e-3)
		return PI/12;

	return dMinDiffAng;
}

void TAuxTools::BuildRectDuct(const AcGePoint3d& ptStart, const AcGePoint3d& ptEnd,
							  const AcGeVector3d& vtNormal, const double dSWidth,
							  const double dSThick, const double dEWidth, const double dEThick,
							  TXShell& xShell, const AcGeVector3d* pvtSSide/* = NULL*/,
							  const AcGeVector3d* pvtESide/* = NULL*/)
{
	// 计算参数
	double dHalfSWidth = dSWidth / 2.0;
	double dHalfSThick = dSThick / 2.0;
	double dHalfEWidth = dEWidth / 2.0;
	double dHalfEThick = dEThick / 2.0;
	AcGeVector3d vtSSide;
	if (NULL == pvtSSide)
	{
		vtSSide = ptEnd - ptStart;
		vtSSide.rotateBy(PI / 2.0, vtNormal);
	}
	else
	{
		vtSSide = *pvtSSide;
	}
	vtSSide.normalize();
	AcGeVector3d vtESide;
	if (NULL == pvtESide)
	{
		vtESide = ptEnd - ptStart;
		vtESide.rotateBy(PI / 2.0, vtNormal);
	}
	else
	{
		vtESide = *pvtESide;
	}
	vtESide.normalize();
	
	// 计算端点
	AcGePoint3d arpt[8];
	arpt[0] = ptStart + vtSSide * dHalfSWidth + vtNormal * dHalfSThick;
	arpt[1] = ptStart + vtSSide * dHalfSWidth - vtNormal * dHalfSThick;
	arpt[2] = ptStart - vtSSide * dHalfSWidth - vtNormal * dHalfSThick;
	arpt[3] = ptStart - vtSSide * dHalfSWidth + vtNormal * dHalfSThick;
	arpt[4] = ptEnd + vtESide * dHalfEWidth + vtNormal * dHalfEThick;
	arpt[5] = ptEnd + vtESide * dHalfEWidth - vtNormal * dHalfEThick;
	arpt[6] = ptEnd - vtESide * dHalfEWidth - vtNormal * dHalfEThick;
	arpt[7] = ptEnd - vtESide * dHalfEWidth + vtNormal * dHalfEThick;
	
	// 添加碰撞面
	xShell.AppendFace(new AcDbFace(arpt[0], arpt[1], arpt[2], arpt[3]));
	xShell.AppendFace(new AcDbFace(arpt[4], arpt[5], arpt[6], arpt[7]));
	xShell.AppendFace(new AcDbFace(arpt[0], arpt[1], arpt[5], arpt[4]));
	xShell.AppendFace(new AcDbFace(arpt[1], arpt[2], arpt[6], arpt[5]));
	xShell.AppendFace(new AcDbFace(arpt[2], arpt[3], arpt[7], arpt[6]));
	xShell.AppendFace(new AcDbFace(arpt[3], arpt[0], arpt[4], arpt[7]));
}

void TAuxTools::BuildCirDuct(const AcGePoint3d& ptStart, const AcGePoint3d& ptEnd,
							 const double dSDiameter, const double dEDiameter, TXShell& xShell,
							 const AcGeVector3d* pvtSRot/* = NULL*/, const AcGeVector3d* pvtERot/* = NULL*/,
							 const AcGeVector3d* pvtSRotAxis/* = NULL*/, const AcGeVector3d* pvtERotAxis/* = NULL*/)
{
	// 计算参数
	double dSRadius = dSDiameter / 2.0;
	double dERadius = dEDiameter / 2.0;
	AcGeVector3d vtRotNormal = ptEnd - ptStart;
	AcGeVector3d vtSRot;
	if (NULL != pvtSRot && NULL != pvtSRotAxis)
	{
		vtSRot = *pvtSRot;
	}
	else
	{
		vtSRot = vtRotNormal.perpVector();
	}
	vtSRot.normalize();
	AcGeVector3d vtERot;
	if (NULL != pvtERot && NULL != pvtERotAxis)
	{
		vtERot = *pvtERot;
	}
	else
	{
		vtERot = vtRotNormal.perpVector();
	}
	vtERot.normalize();

	// 计算端点
	AcGePoint3d arpt[12];
	if (NULL != pvtSRotAxis && NULL != pvtERotAxis)
	{
		for (int i = 0; i < 6; ++i)
		{
			arpt[0 + i] = ptStart + vtSRot * dSRadius;
			arpt[6 + i] = ptEnd + vtERot * dERadius;
			
			vtSRot.rotateBy(PI / 3.0, *pvtSRotAxis);
			vtERot.rotateBy(-PI / 3.0, *pvtERotAxis);
		}
	} 
	else
	{
		for (int i = 0; i < 6; ++i)
		{
			arpt[0 + i] = ptStart + vtSRot * dSRadius;
			arpt[6 + i] = ptEnd + vtERot * dERadius;
			
			vtSRot.rotateBy(PI / 3.0, vtRotNormal);
			vtERot.rotateBy(PI / 3.0, vtRotNormal);
		}
	}

	
	// 添加碰撞面
	for (int j = 0; j < 5; ++j)
	{
		xShell.AppendFace(new AcDbFace(arpt[j], arpt[j + 1], arpt[j + 7], arpt[j + 6]));
	}
	xShell.AppendFace(new AcDbFace(arpt[5], arpt[0], arpt[6], arpt[11]));
	xShell.AppendFace(new AcDbFace(arpt[0], arpt[1], arpt[2], arpt[5]));
	xShell.AppendFace(new AcDbFace(arpt[2], arpt[3], arpt[4], arpt[5]));
	xShell.AppendFace(new AcDbFace(arpt[6], arpt[7], arpt[8], arpt[11]));
	xShell.AppendFace(new AcDbFace(arpt[8], arpt[9], arpt[10], arpt[11]));
}

void TAuxTools::BuildMinRectangle(const AcGePoint3dArray& arpt, AcDbExtents& ext)
{
	int iLen = arpt.length();
	if (0 == iLen)
	{
		return;
	}
	
	double dMaxX = arpt[0].x;
	double dMaxY = arpt[0].y;
	double dMaxZ = arpt[0].z;
	double dMinX = dMaxX;
	double dMinY = dMaxY;
	double dMinZ = dMaxZ;
	for (int i = 0; i < iLen; ++i)
	{
		if (dMaxX < arpt[i].x)
		{
			dMaxX = arpt[i].x;
		}
		
		if (dMaxY < arpt[i].y)
		{
			dMaxY = arpt[i].y;
		}
		
		if (dMaxZ < arpt[i].z)
		{
			dMaxZ = arpt[i].z;
		}
		
		if (dMinX > arpt[i].x)
		{
			dMinX = arpt[i].x;
		}
		
		if (dMinY > arpt[i].y)
		{
			dMinY = arpt[i].y;
		}
		
		if (dMinZ > arpt[i].z)
		{
			dMinZ = arpt[i].z;
		}
	}
	
	AcGePoint3d ptMax(dMaxX,dMaxY,dMaxZ);
	AcGePoint3d ptMin(dMinX,dMinY,dMinZ);
	
	ext.set(ptMin,ptMax);
}

BOOL TAuxTools::IsAutoWorkOffset()
{
	BOOL bAuto(FALSE);
	GetGlobalContext(HVAC_AUTOOFFSET, bAuto);

	return bAuto;
}

BOOL TAuxTools::IsAutoWorkConnect()
{
	BOOL bAuto(FALSE);
	GetGlobalContext(HVAC_AUTOCONNECT, bAuto);

	return bAuto;	
}

BOOL TAuxTools::IsAutoWorkSize()
{
	BOOL bAuto(FALSE);
	GetGlobalContext(HVAC_AUTOSIZE, bAuto);

	return bAuto;
}

void TAuxTools::BuildCir2RectDuct(const AcGePoint3d& ptCir, const AcGePoint3d& ptRec,
								  const AcGeVector3d& vtNormal, const double dDiameter,
								  const double dWidth, const double dThick, TXShell& xShell,
								  const AcGeVector3d* pvtRot/* = NULL*/, const AcGeVector3d* pvtCirOut/* = NULL*/)
{
	// 计算侧方向
	AcGeVector3d vtRot;
	AcGeVector3d vtRotNormal;
	if (NULL != pvtRot && NULL != pvtCirOut)
	{
		vtRot = *pvtRot;
		vtRotNormal = *pvtCirOut;
	}
	else
	{
		vtRot = ptCir - ptRec;
		vtRot.rotateBy(PI / 2.0, vtNormal);
	}
	vtRot.normalize();

	// 计算方口端点
	double dHalfWidth = dWidth / 2.0;
	double dHalfThick = dThick / 2.0;
	AcGeVector3d vtSide = vtRot;
	AcGePoint3d arptRec[4];
	arptRec[0] = ptRec + vtSide * dHalfWidth + vtNormal * dHalfThick;
	arptRec[1] = ptRec - vtSide * dHalfWidth + vtNormal * dHalfThick;
	arptRec[2] = ptRec - vtSide * dHalfWidth - vtNormal * dHalfThick;
	arptRec[3] = ptRec + vtSide * dHalfWidth - vtNormal * dHalfThick;

	// 计算圆口端点
	double dRadius = dDiameter / 2.0;
	AcGePoint3d arptCir[8];
	for (int i = 0; i < 8; ++i)
	{
		arptCir[i] = ptCir + vtRot * dRadius;
		vtRot.rotateBy(PI / 4.0, vtRotNormal);
	}

	// 添加碰撞面
	xShell.AppendFace(new AcDbFace(arptCir[0], arptCir[1], arptRec[0], arptRec[0]));
	xShell.AppendFace(new AcDbFace(arptCir[1], arptCir[2], arptRec[0], arptRec[0]));
	xShell.AppendFace(new AcDbFace(arptCir[2], arptCir[3], arptRec[1], arptRec[1]));
	xShell.AppendFace(new AcDbFace(arptCir[3], arptCir[4], arptRec[1], arptRec[1]));
	xShell.AppendFace(new AcDbFace(arptCir[4], arptCir[5], arptRec[2], arptRec[2]));
	xShell.AppendFace(new AcDbFace(arptCir[5], arptCir[6], arptRec[2], arptRec[2]));
	xShell.AppendFace(new AcDbFace(arptCir[6], arptCir[7], arptRec[3], arptRec[3]));
	xShell.AppendFace(new AcDbFace(arptCir[7], arptCir[0], arptRec[3], arptRec[3]));

	xShell.AppendFace(new AcDbFace(arptRec[0], arptRec[1], arptCir[2], arptCir[2]));
	xShell.AppendFace(new AcDbFace(arptRec[1], arptRec[2], arptCir[4], arptCir[4]));
	xShell.AppendFace(new AcDbFace(arptRec[2], arptRec[3], arptCir[6], arptCir[6]));
	xShell.AppendFace(new AcDbFace(arptRec[3], arptRec[0], arptCir[0], arptCir[0]));

	xShell.AppendFace(new AcDbFace(arptCir[0], arptCir[1], arptCir[2], ptCir));
	xShell.AppendFace(new AcDbFace(arptCir[2], arptCir[3], arptCir[4], ptCir));
	xShell.AppendFace(new AcDbFace(arptCir[4], arptCir[5], arptCir[6], ptCir));
	xShell.AppendFace(new AcDbFace(arptCir[6], arptCir[7], arptCir[0], ptCir));
	xShell.AppendFace(new AcDbFace(arptRec[0], arptRec[1], arptRec[2], arptRec[3]));
}

void TAuxTools::BuildRecFace(const AcGePoint3d& pt, const double dWidth, const double dThick,
							 const AcGeVector3d& vtNormal, const AcGeVector3d& vtFaceNormal, TXShell& xShell)
{
	// 获得侧方向
	AcGeVector3d vtSide = vtFaceNormal;
	vtSide.rotateBy(PI / 2.0, vtNormal);
	vtSide.normalize();
	
	// 添加面
	double dHalfWidth = dWidth / 2.0;
	double dHalfThick = dThick / 2.0;
	AcGePoint3d arpt[4];
	arpt[0] = pt + vtSide * dHalfWidth + vtNormal * dHalfThick;
	arpt[1] = pt + vtSide * dHalfWidth - vtNormal * dHalfThick;
	arpt[2] = pt - vtSide * dHalfWidth - vtNormal * dHalfThick;
	arpt[3] = pt - vtSide * dHalfWidth + vtNormal * dHalfThick;
	xShell.AppendFace(new AcDbFace(arpt[0], arpt[1], arpt[2], arpt[3]));
}

void TAuxTools::BuildRecFace(const AcGePoint3d& pt, const double dWidth, const double dThick,
					const AcGeVector3d& vtNormal, const AcGeVector3d& vtFaceNormal, AcDbVoidPtrArray& dbPtArr)
{
	// 获得侧方向
	AcGeVector3d vtSide = vtFaceNormal;
	vtSide.rotateBy(PI / 2.0, vtNormal);
	vtSide.normalize();
	
	// 添加面
	double dHalfWidth = dWidth / 2.0;
	double dHalfThick = dThick / 2.0;
	AcGePoint3d arpt[4];
	arpt[0] = pt + vtSide * dHalfWidth + vtNormal * dHalfThick;
	arpt[1] = pt + vtSide * dHalfWidth - vtNormal * dHalfThick;
	arpt[2] = pt - vtSide * dHalfWidth - vtNormal * dHalfThick;
	arpt[3] = pt - vtSide * dHalfWidth + vtNormal * dHalfThick;

	dbPtArr.append(new AcDbFace(arpt[0], arpt[1], arpt[2], arpt[3]));
}

void TAuxTools::BuildCirFace(const AcGePoint3d& pt, const double dDiameter, const AcGeVector3d& vtNormal,
							 const AcGeVector3d& vtFaceNormal, TXShell& xShell)
{
	// 获得侧方向
	AcGeVector3d vtRot = vtNormal;
	vtRot.normalize();
	
	double dRadius = dDiameter / 2.0;
	AcGePoint3d arpt[6];
	for (int i = 0; i < 6; ++i)
	{
		arpt[i] = pt + vtRot * dRadius;
		vtRot.rotateBy(PI / 3.0, vtFaceNormal);
	}
	
	xShell.AppendFace(new AcDbFace(arpt[0], arpt[1], arpt[2], arpt[3]));
	xShell.AppendFace(new AcDbFace(arpt[3], arpt[4], arpt[5], arpt[0]));
}

void TAuxTools::BuildCirFace(const AcGePoint3d& pt, const double dDiameter, const AcGeVector3d& vtNormal,
							 const AcGeVector3d& vtFaceNormal, AcDbVoidPtrArray& dbPtArr)
{
	// 获得侧方向
	AcGeVector3d vtRot = vtNormal;
	vtRot.normalize();
	
	double dRadius = dDiameter / 2.0;
	AcGePoint3d arpt[6];
	for (int i = 0; i < 6; ++i)
	{
		arpt[i] = pt + vtRot * dRadius;
		vtRot.rotateBy(PI / 3.0, vtFaceNormal);
	}
	
	dbPtArr.append(new AcDbFace(arpt[0], arpt[1], arpt[2], arpt[3]));
	dbPtArr.append(new AcDbFace(arpt[3], arpt[4], arpt[5], arpt[0]));
}

void TAuxTools::DealWithConEnt(AcDbObjectId idToDeal, const AcGeVector3d& vtOff, 
							   AcDbObjectId idFrom, AcGePoint3d ptFrom)
{
	TDbXDataMap* pMap = NULL;
	ObjectKind eKind(TDb::eCabletry);
	OPENOBJ_BEGIN(idToDeal, AcDb::kForWrite, TDbInterfacesObj, pIfObj);
	if (NULL != pIfObj)
	{
		pMap = pIfObj->GetSpecialtyData();
		if (NULL != pMap)
		{
			pMap->GetAt(KEY_RUNTIME, (int&)eKind);
			if (eKind == TDb::ePipe)
			{
				TDbHvacDuct* pDuct = TDbHvacDuct::cast(pIfObj);
				if (NULL != pDuct)
				{
					AcGePoint3d ptStart = pDuct->StartPoint();
					AcGePoint3d ptEnd = pDuct->EndPoint();
					AcGeVector3d vtDirect = ptEnd - ptStart;
					if (vtOff.isParallelTo(vtDirect))
					{
						if (ptStart.distanceTo(ptFrom) < 1e-6)
						{
							AcGePoint3d ptNewStart = ptStart + vtOff;
							pDuct->SetStartPoint(ptNewStart);
							pDuct->UpdateInterfaceRec(ptStart, ptNewStart);
						}
						else if (ptEnd.distanceTo(ptFrom) < 1e-6)
						{
							AcGePoint3d ptNewEnd = ptEnd + vtOff;
							pDuct->SetEndPoint(ptNewEnd);
							pDuct->UpdateInterfaceRec(ptEnd, ptNewEnd);
						}
					}
				}
			}
			else
			{
				if (!pIfObj->GetInterface(ptFrom, TInterface())) // 没有实际连接
					return;

				int nIfNum = pIfObj->GetInterfaceCount();
				int i(0);
				TInterface tIf;
				AcDbObjectId id(AcDbObjectId::kNull);
				for (i = 0; i < nIfNum; i++)
				{
					tIf.Reset();
					if (!pIfObj->GetInterface(i, tIf))
						continue;

					id = tIf.GetConnectObject();
					if (id != idFrom && id.isValid())
					{
						DealWithConEnt(id, vtOff, idToDeal, tIf.GetPosition());
					}
				}
				pIfObj->transformBy(vtOff);	
			}
		}
	}
	OPENOBJ_END();
}

void TAuxTools::DealWithConEnt( AcDbObjectIdArray idArrToDeal, const AcGePoint3dArray& ptArrOrig, 
							   const AcGePoint3dArray& ptArrNew, AcDbObjectId idFrom )
{
	int nSize = idArrToDeal.length();
	if (nSize != ptArrOrig.length() || nSize != ptArrNew.length())
		return;

	AcGeVector3d vtOff;
	int i(0);
	for (i = 0; i < nSize; i++)
	{
		if (idArrToDeal[i].isValid() && idFrom.isValid())
		{
			vtOff = ptArrNew[i] - ptArrOrig[i];
			if (vtOff.length() > 1e-6)
			{
				DealWithConEnt(idArrToDeal[i], vtOff, idFrom, ptArrOrig[i]);
			}
		}
	}
}

BOOL TAuxTools::GetInterfacePoint(const TImpSpecFitting* pFit, AcGePoint3dArray &ptArr )
{
	if (NULL == pFit)
		return FALSE;

	TInterface tIf;
	int i(0), nNum = pFit->GetInterfaceCount();
	for (i = 0; i < nNum; i++)
	{
		tIf.Reset();
		pFit->GetInterface(i, tIf);
		ptArr.append(tIf.GetPosition());
	}

	return ptArr.length() > 0;
}

BOOL TAuxTools::GetInterfaceId( const TImpSpecFitting* pFit, AcDbObjectIdArray &idArr )
{
	if (NULL == pFit)
		return FALSE;

	TInterface tIf;
	AcDbObjectId id(AcDbObjectId::kNull);
	int i(0), nNum = pFit->GetInterfaceCount();
	for (i = 0; i < nNum; i++)
	{
		tIf.Reset();
		pFit->GetInterface(i, tIf);
		id = tIf.GetConnectObject();
		if (id.isValid())
			idArr.append(id);
	}

	return idArr.length() > 0;
}


// 获取面标高，　零点距到零点投影到该面的垂点的长度
double TAuxTools::GetPlaneEle( const AcGePlane &plan ) 
{
	AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
	double dEle = ptOrth.asVector().length();
	AcGeVector3d vtZAxis(TAuxTools::GetUcsZvt());

	if (!ptOrth.asVector().isCodirectionalTo(plan.normal()))
		dEle *= -1.0;

	return dEle;
}

//读扩展数据
CString TAuxTools::ReadXdata( ads_name name, const TCHAR*szName )
{
	AcDbObjectId idEnt;
	acdbGetObjectId(idEnt, name);
	
	return ReadXdata(idEnt, szName);
}

//读扩展数据
CString TAuxTools::ReadXdata( AcDbObjectId idEnt, const TCHAR*szName )
{
	AcDbObject *pObj = NULL;
	acdbOpenObject(pObj, idEnt, AcDb::kForRead);
	if(!pObj)
		return _T("");
	
	resbuf  *pRb = pObj->xData(szName);
	CString csRet;
    if (pRb != NULL)   	
	{  
		resbuf  *pTemp = pRb; 
		if (pTemp->rbnext != NULL)	
		{
			pTemp = pTemp->rbnext;
			if (pTemp->restype == 1000)	
				csRet = pTemp->resval.rstring;	
		}
	}	
	ads_relrb(pRb);
	pObj->close();
	
	return csRet;
}

//写扩展数据
BOOL TAuxTools::WriteXdata(ads_name name, const TCHAR*szName, const TCHAR*szValue)
{
	AcDbObjectId idEnt;
	acdbGetObjectId(idEnt, name);
	
	return WriteXdata(idEnt, szName, szValue);
}

//写扩展数据
BOOL TAuxTools::WriteXdata(AcDbObjectId idEnt, const TCHAR*szName, const TCHAR*szValue)
{
	AcDbObject *pObj = NULL;
	if(!XSymbolTable(_T("APPID"), szName))
		ads_regapp(szName);
	
	acdbOpenObject(pObj, idEnt, AcDb::kForWrite);
	if(!pObj)
		return FALSE;
	
	resbuf *pXData = ads_buildlist(1001, szName, 1000, szValue, NULL);
	pObj->setXData(pXData);
	ads_relrb(pXData);
	pObj->close();
	
	return TRUE;
}

// 通过id获取文字样式名
TCHAR* TAuxTools::GetFontStyle(AcDbObjectId idTextStyle)
{	
	AcDbTextStyleTableRecord* pTTR;
	if (acdbOpenObject(pTTR, idTextStyle, AcDb::kForRead) != Acad::eOk)
		return NULL;

	TCHAR* pName = NULL;
	if (pTTR->getName(pName) != Acad::eOk)
	{
		pTTR->close();
		return NULL;
	}
	pTTR->close();

	return pName;
}

BOOL TAuxTools::IsEquipAutoMove( TImpSpecEquipment* pImpEquip, AcGeVector3d vtOffset )
{
	if (NULL == pImpEquip)
		return FALSE;

	TInterface tIf;
	AcGeVector3d vtIf;
	int i(0), nIfNum(pImpEquip->GetInterfaceCount());
	for (i = 0; i < nIfNum; i++)
	{
		tIf.Reset();
		if (!pImpEquip->GetInterface(i, tIf))
			continue; 

		vtIf = tIf.GetOutDir();
		if (!(vtOffset.isPerpendicularTo(vtIf) || vtOffset.isParallelTo(vtIf)))
			return FALSE;		
	}

	return TRUE;
}

void TAuxTools::GetAirLetByDuct( const TDbHvacDuct* pDuct, AcDbObjectIdArray &idArrAir )
{
	AcDbObjectIdArray idArrAllEnt;
	GetAllAirFromModel(idArrAllEnt);
	int nPos(0);
	AcGeVector3d vtFlur;

	int i(0);
	for (i = 0; i < idArrAllEnt.length(); i++)
	{
		if (AirIsOnDuct(idArrAllEnt[i], pDuct, nPos, vtFlur))
			idArrAir.append(idArrAllEnt[i]);
	}
}

// 从模型空间块表中获取所有的风口,性能有待改善
void TAuxTools::GetAllAirFromModel(AcDbObjectIdArray& arAirId)
{
//  需要非写方式打开实体时调用
// 	RBList	rbMask = ads_buildlist( -4, _T("<or"),
// 		-4, _T("<and"), RTDXF0, _T("ATS_DBHEQUIPMENT"), -4, _T("and>"),				
// 		-4, _T("or>"), NULL);
// 
// 
// 	PickSet ssEquip(SS_FREE);
// 	ssEquip.Get(_T("X"), NULL, NULL, rbMask);
// 	long lIndex(0), lLen(ssEquip.Length());
// 	TInterface tIf;
// 	TDb::ObjectKind eKind = TDb::eCabletry;
// 
// 	for (lIndex = 0; lIndex < lLen; lIndex++)
// 	{
// 		OPENOBJ_BEGIN(ssEquip[lIndex], AcDb::kForRead, TDbHvacEquipment, pEqu);
// 		if (pEqu != NULL)
// 		{
// 			pEqu->GetSpecialtyDataReadOnly()->GetAt(KEY_RUNTIME, (int&)eKind);
// 			if (eKind == TDb::eAirlets) 
// 			{
// 				tIf.Reset();
// 				pEqu->GetInterface(0, tIf);
// 				if (tIf.GetConnectObject().isValid())
// 					continue;
// 				
// 				arAirId.append(pEqu->objectId());
// 			}
// 		}
// 		OPENOBJ_END();
// 	}


	AcDbBlockTable* pBlockTable = NULL;
	if(Acad::eOk != acdbHostApplicationServices()->workingDatabase()->getBlockTable(pBlockTable, AcDb::kForRead))
		return;
	AcDbBlockTableRecord* pBlockTableRecord = NULL;
	if(Acad::eOk != pBlockTable->getAt(ACDB_MODEL_SPACE, pBlockTableRecord, AcDb::kForWrite))
	{
		pBlockTable->close();
		return;
	}
	pBlockTable->close();
	
	AcDbObjectId idPre;
	AcDbBlockTableRecordIterator* pRecIter;
	pBlockTableRecord->newIterator(pRecIter);
	TDb::ObjectKind eKind;
	TInterface tIf;
	AcDbObjectId idCon = NULL;

	BOOL bConOk(FALSE);	// 连接完好的不用统计，会自动联动
	for (pRecIter->start(); !pRecIter->done(); pRecIter->step())
	{
		pRecIter->getEntityId(idPre);
		OPENOBJ_BEGIN(idPre, AcDb::kForRead, TDbHvacEquipment, pEqu);
		if (pEqu != NULL)
		{
			pEqu->GetSpecialtyDataReadOnly()->GetAt(KEY_RUNTIME, (int&)eKind);
			if (eKind == TDb::eAirlets) 
			{
				tIf.Reset();
				pEqu->GetInterface(0, tIf);
				if (tIf.GetConnectObject().isValid())
					continue;

				arAirId.append(idPre);
			}
		}
		OPENOBJ_END();
	}
	
	pBlockTableRecord->close();
}

// 判断风口是否在风管上
BOOL TAuxTools::AirIsOnDuct( const AcDbObjectId& idAir, const TDbHvacDuct* pDuct, int& nPos, AcGeVector3d& vtFlux )
{	
	if (pDuct == NULL)
		return FALSE;

	OPENOBJ_BEGIN(idAir, AcDb::kForRead, TDbHvacEquipment, pEqu);
	if (pEqu == NULL)
		return FALSE;
	TDbXDataMap* pXMap = pEqu->GetSpecialtyDataReadOnly();
	TDb::ObjectKind eKind;
	pXMap->GetAt(KEY_RUNTIME, (int&)eKind);
	if (eKind != TDb::eAirlets) 
		return FALSE;
			
	AcGePoint3d ptStart, ptEnd, ptCenter;
	AcGeVector3d vtNorDuct, vtSect, vtNorAir, vtMain;
	double dWidthDt, dThickDt, dThickAir;
	pXMap->GetAt(HALT_CenterPoint, ptCenter);
	pXMap->GetAt(HALT_MainDir, vtMain);
	pXMap->GetAt(HVAC_Normal, vtNorAir);
	pXMap->GetAt(HALT_Thick, dThickAir);

	pDuct->getStartPoint(ptStart);
	pDuct->getEndPoint(ptEnd);
	vtNorDuct = pDuct->normal();
	pXMap = pDuct->GetSpecialtyDataReadOnly();
	pXMap->GetAt(HDCT_Width, dWidthDt);
	pXMap->GetAt(HDCT_Thick, dThickDt);
	TDb::HvacSectType eSectType;
	pXMap->GetAt(HVAC_SectType, (int&)eSectType);
	if (eSectType == TDb::eCircular)
		dThickDt = dWidthDt;
	vtSect = ptEnd - ptStart;

	nPos = CalPosBy3Point(ptStart, ptEnd, ptCenter);
	if (nPos == 0)		// 不共线
	{
		// 求风口在管上的投影点
		AcGePlane plan(ptCenter, vtSect);
		AcGePoint3d ptConer = ptStart.orthoProject(plan);
		if (CalPosBy3Point(ptStart, ptEnd, ptConer) == 3)
		{
			double dLength = ptCenter.distanceTo(ptConer);
			dThickAir += 1.0;
			if (vtNorAir.isParallelTo(vtNorDuct))
			{				
				if (fabs(dLength - dThickDt / 2.0) < dThickAir)
				{
					nPos = 2;					
					vtFlux = ptCenter - ptConer;
					vtFlux.normalize();
					return TRUE;
				}
			}
			else if (vtNorAir.isPerpendicularTo(vtNorDuct))
			{
				if (fabs(dLength - dWidthDt / 2.0) < dThickAir)
				{
					nPos = 3;					
					vtFlux = ptCenter - ptConer;
					vtFlux.normalize();
					return TRUE;
				}
			}
		}
	}
	else	// 共线
	{		
		if (vtNorAir.isParallelTo(vtSect))		// 平行
		{
			dThickAir += 1.0;
			if ((ptCenter.distanceTo(ptStart) < dThickAir) || (ptCenter.distanceTo(ptEnd) < dThickAir))		// 范围
			{			
				nPos = 1;
				vtFlux = vtNorAir;
				return TRUE;
			}
		}			
	}
	
	OPENOBJ_END();	
	
	return FALSE;
}

// 判断点pt3与pt1和pt2的位置关系。0-不共线；1--在pt1外；2--同pt1；3--在pt1和pt2之间；4--同pt2；5--在pt2外
int TAuxTools::CalPosBy3Point(const AcGePoint3d& pt1, const AcGePoint3d& pt2, const AcGePoint3d& pt3)
{
	if (pt3 == pt1)
		return 2;
	if (pt3 == pt2)
		return 4;
	
	AcGeVector3d vt13, vt23;
	vt13 = pt3 - pt1;
	vt23 = pt3 - pt2;
	if (!vt13.isParallelTo(vt23))		// 不共线
		return 0;
	
	if (vt13.isCodirectionalTo(vt23))
	{
		if (pt3.distanceTo(pt1) < pt3.distanceTo(pt2))
			return 1;
		else
			return 5;
	}
	else
	{
		return 3;
	}
	return -1;
}

BOOL TAuxTools::Is2DView()
{
	BOOL b2D(FALSE);
	struct resbuf rb = {NULL, RT3DPOINT, 0};
	acedGetVar(_T("VIEWDIR"), &rb);
	AcGeVector3d vtDir = asVec3d(rb.resval.rpoint);
	
	if ((vtDir.isCodirectionalTo(AcGeVector3d::kZAxis) 
		&& TAuxTools::GetUcsZvt().isCodirectionalTo(AcGeVector3d::kZAxis)))
	{
		b2D = TRUE;
	}	

	return b2D;
}

void TAuxTools::DoubleToString( double dValue, int nPreci, CString &csValue )
{
	CString csPreci;
	csPreci.Format(_T("%d"), nPreci);
	csValue.Format(_T("%.") + csPreci + _T("f"), dValue);
}

AcDbObjectId TAuxTools::GetProjBlockId(const AcDbObjectId& idSrc, AcGeVector3d vtNor,
									   AcGeVector3d vtMain, AcGeVector3d vtPlaneSec,
									   AcGeScale3d& scale, AcDbExtents* pExt)
{
	// 图块正方向
	AcGeVector3d vtFront = vtNor.crossProduct(vtMain);
	// 正方向与投影方向的角度
	double dProjAng = vtFront.angleTo(vtPlaneSec, vtNor);
	// 是否镜像
	BOOL bMirror = (PI / 2 < dProjAng && PI * 1.5 > dProjAng);
	// 旋转轴
	AcGeVector3d vtAxis = vtPlaneSec.crossProduct(vtNor);
	// 旋转角度
	double dAngle = vtNor.angleTo(vtPlaneSec, bMirror ? -vtAxis : vtAxis);
	// 矩阵
	AcGeMatrix3d matNor, matHorz, matMirr;
	matNor.setToRotation(dAngle, vtAxis, AcGePoint3d::kOrigin);
	matHorz.setToRotation(-dProjAng, AcGeVector3d::kZAxis, AcGePoint3d::kOrigin);
	matMirr.setToRotation(PI, AcGeVector3d::kXAxis, AcGePoint3d::kOrigin);
	// 新图块ID
	AcDbObjectId idNew = AcDbObjectId::kNull;
	// 原始图块旋转之后的尺寸
	AcGeScale3d scaOrg(1, 1, 1);

	// 生成图块名
	CString csBlkName;
	OPENOBJ_BEGIN(idSrc, AcDb::kForRead, AcDbBlockTableRecord, pBlkRec);
	if(NULL != pBlkRec)
	{
		TCHAR* pName = NULL;
		pBlkRec->getName(pName);
		csBlkName.Format(_T("%s_%d%d%d%.6f%.6f%.6f"), pName, bMirror, (int)(dAngle * 180 / PI),
			(int)(dProjAng * 180 / PI), vtAxis.x, vtAxis.y, vtAxis.z);
	}
	else
	{
		return AcDbObjectId::kNull; 
	}
	OPENOBJ_END();

	AcDbBlockTable* pBlkTbl = NULL;
	acdbCurDwg()->getBlockTable(pBlkTbl, AcDb::kForWrite);
	if(NULL == pBlkTbl)
		return AcDbObjectId::kNull;

	AcGePoint3d ptMax, ptMin;
	if(pBlkTbl->has(csBlkName)) // 块存在
	{
		pBlkTbl->getAt(csBlkName, idNew);
		OPENOBJ_BEGIN(idNew, AcDb::kForRead, AcDbBlockTableRecord, pBlkOld);
		if(NULL != pBlkOld)
		{
			AcDbExtents ext;
			ext.addBlockExt(pBlkOld);
			ptMax = ext.maxPoint();
			ptMin = ext.minPoint();
			scaOrg.set(ptMax.x - ptMin.x, ptMax.y - ptMin.y, ptMax.z - ptMin.z);
		}
		OPENOBJ_END();
	}
	else
	{
		// 插入新图块
		AcDbBlockTableRecord* pBlkNew = new AcDbBlockTableRecord;
		pBlkTbl->add(idNew, pBlkNew);
		pBlkNew->setName(csBlkName);

		AcDbBlockReference* pBlkRef = new AcDbBlockReference(AcGePoint3d::kOrigin , idSrc);
		pBlkRef->transformBy(matNor);
		pBlkRef->transformBy(matHorz);
		if(bMirror)
			pBlkRef->transformBy(matMirr);

		AcDbVoidPtrArray ptrArr;
		pBlkRef->explode(ptrArr);
		for(int i = 0; i < ptrArr.length(); i++)
		{
			AcDbEntity* pEnt = AcDbEntity::cast((AcDbEntity*)ptrArr[i]);
			if(NULL != pEnt)
			{
				pBlkNew->appendAcDbEntity(pEnt);
				pEnt->close();
			}
		}
		delete pBlkRef;

		// 取得图块尺寸
		AcDbExtents ext;
		ext.addBlockExt(pBlkNew);
		ptMax = ext.maxPoint();
		ptMin = ext.minPoint();
		scaOrg.set(ptMax.x - ptMin.x, ptMax.y - ptMin.y, ptMax.z - ptMin.z);

		// 设置图块插入点
		//AcGePoint3d ptOrigin = Mid(ptMax, ptMin);
		//ptOrigin.y = ptMin.y;
		//pBlkNew->setOrigin(ptOrigin);

		pBlkNew->close();
	}

	// 计算新图块比例
	AcDbObjectId idTemp;
	AcDbBlockTableRecord* pBlkSca = new AcDbBlockTableRecord;
	pBlkTbl->add(idTemp, pBlkSca);
	pBlkTbl->close();

	AcDbBlockReference* pBlkRefSca = new AcDbBlockReference(AcGePoint3d::kOrigin , idSrc);
	pBlkRefSca->setScaleFactors(scale);
	pBlkRefSca->transformBy(matNor);
	pBlkRefSca->transformBy(matHorz);
	if(bMirror)
		pBlkRefSca->transformBy(matMirr);

	AcDbVoidPtrArray ptrArr;
	pBlkRefSca->explode(ptrArr);
	for(int i = 0; i < ptrArr.length(); i++)
	{
		AcDbEntity* pEnt = AcDbEntity::cast((AcDbEntity*)ptrArr[i]);
		if(NULL != pEnt)
		{
			pBlkSca->appendAcDbEntity(pEnt);
			pEnt->close();
		}
	}
	delete pBlkRefSca;
	
	// 取得新图块尺寸
	AcDbExtents extSca;
	extSca.addBlockExt(pBlkSca);
	ptMax = extSca.maxPoint();
	ptMin = extSca.minPoint();
	if(NULL != pExt)
		pExt->addExt(extSca);
	scale.set((ptMax.x - ptMin.x) / scaOrg[X],
		(ptMax.y - ptMin.y) / scaOrg[Y],
		(ptMax.z - ptMin.z) / scaOrg[Z]);

	pBlkSca->erase();
	pBlkSca->close();

	return idNew;
}

extern TDbRelInterfaceReactor* g_pRelInterfaceReactor;
TDbInterfaceRecord* TAuxTools::GetIntfPtrFromDB()
{
	AcDbDatabase* pDb = acdbCurDwg();
	if(NULL == pDb)
		return NULL;

	TDbInterfaceRecord* pIRec = NULL;
	g_pRelInterfaceReactor->m_mapDbToIRecPtr.Lookup(pDb,(void *&)pIRec);
	if (pIRec != NULL)
	{
		pIRec->m_bIsCatchBuf = true;
		return pIRec;
	}
	else //
	{

	}
	return NULL;
}

// pLine转换为TGGeCurveSegment,并添加到TDPtrList中
void TAuxTools::Poly2CurveSeg(AcDbPolyline* pLine, TDPtrList<TGGeCurveSegment>& segComs)
{
	if (NULL == pLine)
		return ;
	AcGePoint3d pt1, pt2;
	double dBugle(0.0), dAng(0.0);
	TGGeCurveSegment tGetSeg;
	for(int i = 0; i <= (int)pLine->numVerts()-2; i++)
	{
		pLine->getPointAt(i, pt1);
		pLine->getBulgeAt(i, dBugle);
		pLine->getPointAt(i+1, pt2);
		// 直线
		if (EQUAL_ZERO(dBugle))
		{
			tGetSeg.SetLine(pt1, pt2);
		}
		// 此段为弧线
		else
		{
			// 计算角度
			dAng = atan(dBugle) * 4;
			tGetSeg.SetArc(pt1, pt2, dAng);
		}
		segComs.Append(new TGGeCurveSegment(tGetSeg));
	}

	if (pLine->isClosed())
	{
		dBugle = 0.0;
		pLine->getPointAt(pLine->numVerts()-1, pt1);
		pLine->getPointAt(0, pt2);
		pLine->getBulgeAt(pLine->numVerts()-1, dBugle);

		if (EQUAL_ZERO(dBugle))
			tGetSeg.SetLine(pt1, pt2); 
		else
		{
			dAng = atan(dBugle) * 4;
			tGetSeg.SetArc(pt1, pt2, dAng);
		}
		segComs.Append(new TGGeCurveSegment(tGetSeg));
	}
}

BOOL TAuxTools::IsIncline(AcGeVector3d& vt)
{
	AcDbDatabase* pDb = acdbCurDwg();
	if (NULL == pDb)
		return FALSE;

	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));

	return !vt.isParallelTo(vtZAxis) && !vt.isPerpendicularTo(vtZAxis);
}

void TAuxTools::Matrix3D2String( const AcGeMatrix3d &mat, CString &str )
{
#if ADS <= 15
	std::ostringstream stream;
#else
	std::wostringstream stream;
#endif
	for (int ln = 0; ln < 4; ++ln)
	{
		for (int col = 0; col < 4; ++col)
		{
			stream<<mat.entry[ln][col];
		#if ADS <= 15
			stream << " ";
		#else
			stream << L" ";
		#endif
		}
	}
	str = stream.str().c_str();
}

double TAuxTools::CalCurvature(const AcGePoint3d& pt1, const AcGePoint3d& pt2,
							 const AcGePoint3d& pt3, const AcGeVector3d* pVtNor)
{
	AcGeVector3d vtUseZAixs = AcGeVector3d::kIdentity;
	if(NULL == pVtNor)
	{
		AcDbDatabase* pDb = acdbCurDwg();
		if (NULL != pDb)
			vtUseZAixs = pDb->ucsxdir().crossProduct(pDb->ucsydir());
	}
	else
	{
		vtUseZAixs = *pVtNor;
	}
	AcGeCircArc3d arc(pt1, pt2, pt3);
	double dBulge = tan((arc.endAng() - arc.startAng()) * 0.25);	
	AcGeVector3d vtMid = pt2 - pt1;
	AcGeVector3d vtEnd = pt3 - pt1;
	AcGeVector3d vtCross = vtMid.crossProduct(vtEnd);
	if (!vtCross.isCodirectionalTo(vtUseZAixs))
		dBulge *= -1;
	return dBulge;
}

LPCTSTR TAuxTools::GetBlkNameById (AcDbObjectId id)
{
	AcDbObject* pObj = NULL;
	if (Acad::eOk != acdbOpenObject(pObj, id, AcDb::kForRead))
	{
		return NULL;
	}
	if (!pObj->isKindOf(AcDbBlockTableRecord::desc()))
	{
		pObj->close();
		return NULL;
	}
	AcDbBlockTableRecord* pRec = AcDbBlockTableRecord::cast(pObj);
	ACHAR* pCh = NULL;
	pRec->getName(pCh);
	pRec->close();
	pObj->close();
	return pCh;
}

// add by dyc on 2014-01-21 解决Y型三通在比较大坐标值情况下以后后变成T型问题,求两圆交点
BOOL TAuxTools::CircleInsertWith(const AcGeCircArc3d& circleS, const AcGeCircArc3d& circleE, 
									AcGePoint3d& ptInter1, AcGePoint3d& ptInter2)
{
	AcGePoint3d ptCentS = circleS.center();
	AcGePoint3d ptCentE = circleE.center();
	double dRS = circleS.radius();
	double dRE = circleE.radius();
	double dSumR = dRS + dRE;
	double dDistanceES = ptCentS.distanceTo(ptCentE);
	AcGeVector3d vtES = ptCentE - ptCentS;
	BOOL bInsert = FALSE;
	vtES.normalize();
	AcGePoint3d ptInsert;
	if(dDistanceES > dSumR)
		return bInsert;
	else if(fabs(dDistanceES - dSumR) <= 1e-6)
	{
		ptInsert = ptCentS + vtES * dRS;
		ptInter1 = ptInter2 = ptInsert;
		bInsert = TRUE;
	}
	else
	{
		double dLeftLength = (pow(dRS, 2) - pow(dRE, 2) + pow(dDistanceES, 2)) / (2 * dDistanceES);
		double dUpLength = sqrt(pow(dRS, 2) - pow(dLeftLength, 2));
		double dDownLength = dUpLength;
		ptInsert = ptCentS + vtES * dLeftLength;
		vtES.rotateBy(PI * 0.5, AcGeVector3d::kZAxis);
		ptInter1 = ptInsert + vtES * dUpLength;
		ptInter2 = ptInsert - vtES * dDownLength;
		bInsert = TRUE;
	}
	return bInsert;
}

int TAuxTools::StrTokenize(LPCTSTR pszSrc, LPCTSTR pszDelimit, CStringArray& arSubs)
{
	if(NULL == pszSrc || NULL == pszDelimit)
		return 0;

	CString sText = pszSrc;

	LPTSTR pszSub = _tcstok(sText.GetBuffer(0), pszDelimit);
	while(NULL != pszSub)
	{
		arSubs.Add(pszSub);
		pszSub = _tcstok(NULL, pszDelimit);
	}
	sText.ReleaseBuffer();

	return (int)arSubs.GetSize();
}

BOOL TAuxTools::IsVerticalLine(AcGePoint3d pt1, AcGePoint3d pt2)
{
	AcGeVector3d vt = pt2 - pt1;
	return fabs(vt.x) < 1.0E-6 && fabs(vt.y) < 1.0E-6;
}

// 计算曲线遮挡 用于水管遮挡风管的情况
void TAuxTools::GetCurveGeomExtentsEdge(AcDbEntity* pEnt, TComplexCurve& crLoop)
{
	if(NULL == pEnt)
		return;
	if(!pEnt->isKindOf(AcDbCurve::desc()))
		return;

	// 起点终点
	AcDbCurve* pCurve = (AcDbCurve*)pEnt;
	AcGePoint3d ptStart, ptEnd;
	pCurve->getStartPoint(ptStart);
	pCurve->getEndPoint(ptEnd);

	// 立管不处理
	if(IsVerticalLine(ptStart, ptEnd))
		return;

	// 中点
	double dPar1 = 0, dPar2 = 0;
	pCurve->getStartParam(dPar1);
	pCurve->getEndParam(dPar2);
	AcGePoint3d ptMid;
	pCurve->getPointAtParam((dPar1 + dPar2) / 2, ptMid);

	// 判断是否弧形
	BOOL bArc = FALSE;
	AcGeVector3d vtSE = ptEnd - ptStart;
	AcGeVector3d ptSM = ptMid - ptStart;
	if(!vtSE.isParallelTo(ptSM))
	{
		bArc = TRUE;
	}

	// 计算边界
	double dBrWidth = 0;
	if(!TAuxTools::GetTHvacDataFromDwg(HVAC_PIPEHIDEWIDTH, dBrWidth))
		GetGlobalContext()->GetAt(HVAC_PIPEHIDEWIDTH, dBrWidth);

	if(!DOWNEQUAL_ZERO(dBrWidth))
	{
		AcGePoint3d ptS1, ptS2, ptE1, ptE2, ptM1, ptM2;
		if(bArc)
		{
			// 取得圆心
			AcGeCircArc3d arc(ptStart, ptMid, ptEnd);
			AcGePoint3d ptCenter = arc.center();
			AcGeVector3d vtDir;

			// start
			vtDir = ptStart - ptCenter;
			vtDir.normalize();
			ptS1 = ptStart + vtDir * dBrWidth;
			ptS2 = ptStart - vtDir * dBrWidth;

			// end
			vtDir = ptEnd - ptCenter;
			vtDir.normalize();
			ptE1 = ptEnd + vtDir * dBrWidth;
			ptE2 = ptEnd - vtDir * dBrWidth;

			// mid
			vtDir = ptMid - ptCenter;
			vtDir.normalize();
			ptM1 = ptMid + vtDir * dBrWidth;
			ptM2 = ptMid - vtDir * dBrWidth;

		}
		else
		{
			// 方向
			AcGeVector3d vtDir = ptEnd - ptStart;
			vtDir.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			vtDir.normalize();

			ptS1 = ptStart + vtDir * dBrWidth;
			ptS2 = ptStart - vtDir * dBrWidth;
			ptE1 = ptEnd + vtDir * dBrWidth;
			ptE2 = ptEnd - vtDir * dBrWidth;
		}

		TCurveElement tCurveEle;
		memset(&tCurveEle, 0, sizeof(TCurveElement));
		tCurveEle.bHided = FALSE;
		tCurveEle.dWidth = 0.0;
		tCurveEle.gsMark = 0;

		tCurveEle.ptGe[0] = ptS1;
		tCurveEle.ptGe[1] = bArc ? ptM1 : ptE1;
		tCurveEle.ptGe[2] = ptE1;
		crLoop.append(tCurveEle);

		tCurveEle.ptGe[0] = ptE1;
		tCurveEle.ptGe[1] = ptE2;
		tCurveEle.ptGe[2] = ptE2;
		crLoop.append(tCurveEle);

		tCurveEle.ptGe[0] = ptE2;
		tCurveEle.ptGe[1] = bArc ? ptM2 : ptS2;
		tCurveEle.ptGe[2] = ptS2;
		crLoop.append(tCurveEle);

		tCurveEle.ptGe[0] = ptS2;
		tCurveEle.ptGe[1] = ptS1;
		tCurveEle.ptGe[2] = ptS1;
		crLoop.append(tCurveEle);
	}
}

void TAuxTools::MakeCurvePolyFaces(AcDbEntity* pEnt, AcDbVoidPtrArray& arFaces)
{
	if(NULL == pEnt)
		return;
	if(!pEnt->isKindOf(AcDbCurve::desc()))
		return;

	// 起点终点
	AcDbCurve* pCurve = (AcDbCurve*)pEnt;
	AcGePoint3d ptStart, ptEnd;
	pCurve->getStartPoint(ptStart);
	pCurve->getEndPoint(ptEnd);

	// 立管不处理
	if(IsVerticalLine(ptStart, ptEnd))
		return;

	// 中点
	double dPar1 = 0, dPar2 = 0;
	pCurve->getStartParam(dPar1);
	pCurve->getEndParam(dPar2);
	AcGePoint3d ptMid;
	pCurve->getPointAtParam((dPar1 + dPar2) / 2, ptMid);

	// 投影到中点上
	AcGePlane plane(Mid(ptStart, ptEnd), AcGeVector3d::kZAxis);
	ptStart = ptStart.orthoProject(plane);
	ptEnd = ptEnd.orthoProject(plane);
	ptMid = ptMid.orthoProject(plane);

	// 判断是否弧形
	BOOL bArc = FALSE;
	AcGeVector3d vtSE = ptEnd - ptStart;
	AcGeVector3d ptSM = ptMid - ptStart;
	if(!vtSE.isParallelTo(ptSM))
	{
		bArc = TRUE;
	}

	// 计算边界
	double dBrWidth = 0;
	if(!TAuxTools::GetTHvacDataFromDwg(HVAC_PIPEHIDEWIDTH, dBrWidth))
		GetGlobalContext()->GetAt(HVAC_PIPEHIDEWIDTH, dBrWidth);

	if(!DOWNEQUAL_ZERO(dBrWidth))
	{
		if(!bArc)
		{
			// 方向
			AcGeVector3d vtDir = ptEnd - ptStart;
			vtDir.normalize();
			ptStart += vtDir * 0.1;
			ptEnd -= vtDir * 0.1;
			vtDir.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			vtDir.normalize();

			AcGePoint3d ptS1 = ptStart + vtDir * dBrWidth;
			AcGePoint3d ptS2 = ptStart - vtDir * dBrWidth;
			AcGePoint3d ptE1 = ptEnd + vtDir * dBrWidth;
			AcGePoint3d ptE2 = ptEnd - vtDir * dBrWidth;

			AcDbFace* pFace = new AcDbFace;
			pFace->setVertexAt(0, ptS1);
			pFace->setVertexAt(1, ptE1);
			pFace->setVertexAt(2, ptE2);
			pFace->setVertexAt(3, ptS2);
			arFaces.append(pFace);
		}
		else // 弧形以直线进行拟合
		{
			double dAngle = GetMinDiffAngle();

			// 取得圆心 圆心角
			AcGeCircArc3d arc(ptStart, ptMid, ptEnd);
			double dRadius = arc.radius();
			AcGePoint3d ptCent = arc.center();
			AcGeVector3d vtMid = ptMid - ptCent;
			vtMid.normalize();

			// 生成点
			AcGePoint3dArray arPtUp, arPtDn;
			AcGePoint3d ptOn;
			AcGeVector3d vtLeft = vtMid;
			AcGeVector3d vtRight = vtMid;
			double dArcAngle = arc.endAng() - arc.startAng();
			int nLoop = (int)(dArcAngle / dAngle / 2) + 1;
			for(int i = 0; i < nLoop; i++)
			{
				if(0 == i)
				{
					ptOn = ptCent + vtMid * (dRadius + dBrWidth);
					arPtUp.append(ptOn);

					ptOn = ptCent + vtMid * (dRadius - dBrWidth);
					arPtDn.append(ptOn);
				}
				else
				{
					// 左侧
					vtLeft.rotateBy(dAngle, AcGeVector3d::kZAxis);
					ptOn = ptCent + vtLeft * (dRadius + dBrWidth);
					arPtUp.insertAt(0, ptOn);

					ptOn = ptCent + vtLeft * (dRadius - dBrWidth);
					arPtDn.insertAt(0, ptOn);

					// 右侧
					vtRight.rotateBy(-dAngle, AcGeVector3d::kZAxis);
					ptOn = ptCent + vtRight * (dRadius + dBrWidth);
					arPtUp.append(ptOn);

					ptOn = ptCent + vtRight * (dRadius - dBrWidth);
					arPtDn.append(ptOn);
				}
			}
			// 起点终点
			vtMid = ptEnd - ptCent;
			vtMid.normalize();
			arPtUp.insertAt(0, ptCent + vtMid * (dRadius + dBrWidth));
			arPtDn.insertAt(0, ptCent + vtMid * (dRadius - dBrWidth));

			vtMid = ptStart - ptCent;
			vtMid.normalize();
			arPtUp.append(ptCent + vtMid * (dRadius + dBrWidth));
			arPtDn.append(ptCent + vtMid * (dRadius - dBrWidth));

			// 生成遮挡面
			AcDbFace* pFace = NULL;
			for(int i = 0; i < arPtUp.length() - 1; i++)
			{
				pFace = new AcDbFace;
				pFace->setVertexAt(0, arPtUp[i]);
				pFace->setVertexAt(1, arPtUp[i + 1]);
				pFace->setVertexAt(2, arPtDn[i + 1]);
				pFace->setVertexAt(3, arPtDn[i]);

				arFaces.append(pFace);
			}
		}
	}
}