// PipeStyle5.cpp: implementation of the CPipeStyle5 class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "PipeStyle5.h"
#include "math.h"
#include "geassign.h"
#include "PipeTools.h"
#include "GlobalFunction.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#define _PI 3.14159265358979323846
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
extern double TransAngTo2PI(double dbAng);
extern double GetArcRadius(double dbInput);


CPipeStyle5::CPipeStyle5()
{
	m_rectStartPt[X] = 0;
	m_rectStartPt[Y] = 0;
	m_rectStartPt[Z] = 0;
	m_rectEndPt[X] = 0;
	m_rectEndPt[Y] = 0;
	m_rectEndPt[Z] = 0;
	m_nDist = 0;
	m_dbPGAng = 0.0;
	m_nEntryType = 0;

	m_dbCenDist = 0.0;		// 中心线间距
	m_dbArcRadius = 0.0;	// 圆弧半径
	m_nNum = 0;				// 一边的盘管数（n）
	m_dbDiagAng = 0.0;		// 对角线与矩形夹角的锐角
	m_dbDiagDist = 0.0;		// 对角线长度
	m_dbShortDist = 0.0;	// 矩形短边长度
	m_dbLongDist = 0.0;		// 矩形长边长度
	m_dbAssisAng = 0.0;
	m_dbNormAng = 0.0;
	m_nColorInd = 4;
}

CPipeStyle5::CPipeStyle5(XPoint rectStartPt, XPoint rectEndPt, int nDist
						 , double dbPGAng, int nEntryType, const int &nColorIndex)
{
	ads_point_set(rectStartPt, m_rectStartPt);
	ads_point_set(rectEndPt, m_rectEndPt);
	m_nDist = nDist;
	m_dbPGAng = dbPGAng;
	m_nEntryType = nEntryType;

	m_dbCenDist = 0.0;		// 中心线间距
	m_dbArcRadius = 0.0;	// 圆弧半径
	m_nNum = 0;				// 一边的盘管数（n）
	m_dbDiagAng = 0.0;		// 对角线与矩形夹角的锐角
	m_dbDiagDist = 0.0;		// 对角线长度
	m_dbShortDist = 0.0;	// 矩形短边长度
	m_dbLongDist = 0.0;		// 矩形长边长度
	m_dbAssisAng = 0.0;
	m_dbNormAng = 0.0;
	m_nColorInd = nColorIndex;
}

CPipeStyle5::~CPipeStyle5()
{
	int i = 0; // sg modify
	for(i=0; i < m_LineArr1.GetSize(); i++)
	{
		if(m_LineArr1[i] != NULL)
		{
			delete m_LineArr1[i];
		}
	}
	m_LineArr1.RemoveAll();
	for( i=0; i < m_LineArr2.GetSize(); i++)
	{
		if(m_LineArr2[i] != NULL)
		{
			delete m_LineArr2[i];
		}
	}
	m_LineArr2.RemoveAll();
	for( i=0; i < m_LineArr3.GetSize(); i++)
	{
		if(m_LineArr3[i] != NULL)
		{
			delete m_LineArr3[i];
		}
	}
	m_LineArr3.RemoveAll();
	for( i=0; i < m_LineArr4L.GetSize(); i++)
	{
		if(m_LineArr4L[i] != NULL)
		{
			delete m_LineArr4L[i];
		}
	}
	m_LineArr4L.RemoveAll();
	for( i=0; i < m_LineArr4R.GetSize(); i++)
	{
		if(m_LineArr4R[i] != NULL)
		{
			delete m_LineArr4R[i];
		}
	}
	m_LineArr4R.RemoveAll();
	for( i=0; i < m_CenLineArr.GetSize(); i++)
	{
		if(m_CenLineArr[i] != NULL)
		{
			delete m_CenLineArr[i];
		}
	}
	m_CenLineArr.RemoveAll();
	for( i=0; i < m_EndLineLArr.GetSize(); i++)
	{
		if(m_EndLineLArr[i] != NULL)
		{
			delete m_EndLineLArr[i];
		}
	}
	m_EndLineLArr.RemoveAll();
	for( i=0; i < m_EndLineRArr.GetSize(); i++)
	{
		if(m_EndLineRArr[i] != NULL)
		{
			delete m_EndLineRArr[i];
		}
	}
	m_EndLineRArr.RemoveAll();
}

void CPipeStyle5::SetStartPt(ads_point rectStartPt)
{
	ads_point_set(rectStartPt, m_rectStartPt);
}

void CPipeStyle5::SetDist(int nDist)
{
	m_nDist = nDist;
}

void CPipeStyle5::SetPGAng(double dbPGAng)
{
	m_dbPGAng = dbPGAng;
}

void CPipeStyle5::SetEntryType(int nEntryType)
{
	switch(nEntryType)
	{
	case 1:
	case 2:
		m_nEntryType = 1;
		break;
	case 3:
	case 4:
		m_nEntryType = 2;
		break;
	case 5:
	case 6:
		m_nEntryType = 3;
		break;
	case 7:
	case 8:
		m_nEntryType = 4;
		break;
	default :
		m_nEntryType = 0;
	}
}
 
bool CPipeStyle5::DrawPGLine(XExplodeDraw &dc)
{
	if(abs(m_nDist) <= 0)
	{
		acutPrintf(_T("\n间距错误"));
		return false;
	}
	if(m_nEntryType < 1 || m_nEntryType > 8)
	{
		acutPrintf(_T("\n入口类型错误"));
		return false;
	}

	GetCenterPt();			// 得到中心点
	GetDiagAng();			// 得到对角线锐角
	GetLengthofSide();		// 得到长短边
	GetVirtaulRect();		// 得到虚拟矩形
	NormalizeRect();		// 把虚拟矩形放倒
	m_dbArcRadius = GetArcRadius(m_nDist);		// 得到圆弧半径

	int nNum = (int)(m_dbShortDist / m_nDist);
	if(nNum < 5 && nNum >= 4)
	{
		return DrawSingle(dc);		// 画一圈
	}
	else
	{
		if(IsEvenNum(nNum))
		{
			m_nNum = (nNum-4) / 2;
		}
		else
		{
			m_nNum = (nNum-3) / 2;
		}
		m_dbCenDist = (m_dbShortDist - 2*m_nNum*m_nDist) / 3;
		if(!DrawMulti())
		{
			return false;
		}
	}

	int i = 0; // sg modify
	for(i=0; i < m_LineArr1.GetSize(); i++)
	{
		m_LineArr1[i]->DrawTheLine(dc, m_nColorInd);
	}
	for( i=0; i < m_LineArr2.GetSize(); i++)
	{
		m_LineArr2[i]->DrawTheLine(dc, m_nColorInd);
	}
	for( i=0; i < m_LineArr3.GetSize(); i++)
	{
		m_LineArr3[i]->DrawTheLine(dc, m_nColorInd);
	}
	for( i=0; i < m_LineArr4L.GetSize(); i++)
	{
		m_LineArr4L[i]->DrawTheLine(dc, m_nColorInd);
	}
	for( i=0; i < m_LineArr4R.GetSize(); i++)
	{
		m_LineArr4R[i]->DrawTheLine(dc, m_nColorInd);
	}
	for( i=0; i < m_CenLineArr.GetSize(); i++)
	{
		m_CenLineArr[i]->DrawTheLine(dc, m_nColorInd);
	}
	for( i=0; i < m_EndLineRArr.GetSize(); i++)
	{
		m_EndLineRArr[i]->DrawTheLine(dc, m_nColorInd);
	}
	for( i=0; i < m_EndLineLArr.GetSize(); i++)
	{
		m_EndLineLArr[i]->DrawTheLine(dc, m_nColorInd);
	}
	if(!CreateArcArr(dc))
	{
		return false;
	}

	return true;
}

// 将矩形转换为躺倒的矩形
void CPipeStyle5::NormalizeRect()
{
	double dbDist12 = acutDistance(m_ptLB, m_ptLT);		// 1、2点间距离
	double dbDist14 = acutDistance(m_ptLB, m_ptRB);		// 1、4点间距离
	if(dbDist12 > dbDist14)
	{
		m_dbDiagAng = 0.5*_PI - m_dbDiagAng;
		GetVirtaulRect();
		m_nEntryType += 2;
		if(m_nEntryType == 9)
		{
			m_nEntryType = 1;
		}
		else if(m_nEntryType == 10)
		{
			m_nEntryType = 2;
		}
		m_dbNormAng = 0.5*_PI;
	}
	switch(m_nEntryType)
	{
	case 1:
	case 2:
		m_nEntryType = 1;
		break;
	case 3:
	case 4:
		m_nEntryType = 2;
		break;
	case 5:
	case 6:
		m_nEntryType = 3;
		break;
	case 7:
	case 8:
		m_nEntryType = 4;
		break;
	default :
		m_nEntryType = 0;
	}
}

	// 矩形的中心点
void CPipeStyle5::GetCenterPt()
{
	m_CenterPt[X] = (m_rectStartPt[X]+m_rectEndPt[X])/2;
	m_CenterPt[Y] = (m_rectStartPt[Y]+m_rectEndPt[Y])/2;
	m_CenterPt[Z] = (m_rectStartPt[Z]+m_rectEndPt[Z])/2;
	
}

	// 得到对角线的锐角
void CPipeStyle5::GetDiagAng()
{
	m_dbDiagAng = acutAngle(m_rectStartPt, m_CenterPt) - m_dbPGAng;
	m_dbDiagAng = TransAngTo2PI(m_dbDiagAng);
	if(m_dbDiagAng >= 0.5*_PI && m_dbDiagAng <_PI)
	{
		m_dbDiagAng = _PI - m_dbDiagAng;
	}
	else if(m_dbDiagAng >= _PI && m_dbDiagAng < 1.5*_PI)
	{
		m_dbDiagAng = m_dbDiagAng - _PI;
	}
	else if(m_dbDiagAng >=1.5*_PI && m_dbDiagAng < 2*_PI)
	{
		m_dbDiagAng = 2*_PI - m_dbDiagAng;
	}
	
}

// 得到矩形边长
void CPipeStyle5::GetLengthofSide()
{
	m_dbDiagDist = acutDistance(m_rectStartPt, m_rectEndPt);
	double dbDist12 = fabs(m_dbDiagDist*sin(m_dbDiagAng));		// 1、2点间距离
	double dbDist14 = fabs(m_dbDiagDist*cos(m_dbDiagAng));		// 1、4点间距离

	m_dbShortDist = (dbDist12 < dbDist14)? dbDist12 : dbDist14;
	m_dbLongDist = (dbDist12 > dbDist14)? dbDist12 : dbDist14;
}

bool CPipeStyle5::DrawSingle(XExplodeDraw &dc)
{
	m_nNum = 1;
	double dbWidth = m_dbLongDist/2 - ((m_nNum+2)*m_nDist + 2*m_dbArcRadius);
	if(fabs(dbWidth) < 0)
	{
//		acutPrintf(_T("\n指定的绘制范围太小,宽 %.2f 时，长度应至少为%.2f"), m_dbShortDist, m_dbLongDist-2*dbWidth);
		return false;
	}

	ads_point virStartPt1, virEndPt1;		// 1边虚拟起点、终点
	ads_point virStartPt2, virEndPt2;		// 2边虚拟起点、终点
	ads_point virStartPt3, virEndPt3;		// 3边虚拟起点、终点
	ads_point virStartPt4L, virEndPt4L;		// 4边左虚拟起点、终点
	ads_point virStartPt4R, virEndPt4R;		// 4边右虚拟起点、终点
	ads_point virStartPtIn, virEndPtIn;		// 输入线虚拟起点、终点
	ads_point virStartPtOut, virEndPtOut;	// 输出线虚拟起点、终点
	ads_point actStartPt, actEndPt;			// 实际起点、终点
	ads_point pt;

	// 计算2条线的起点、终点
	switch(m_nEntryType)
	{
	case 1:
		{
			m_dbAssisAng = 0;
			acutPolar(m_ptLB, 0, m_nDist, pt);		// 1
			acutPolar(pt, 0.5*_PI, m_nDist+m_dbArcRadius, virStartPt1);
			acutPolar(virStartPt1, 0.5*_PI, m_dbShortDist-(2*m_nDist+2*m_dbArcRadius), virEndPt1);

			acutPolar(virEndPt1, 0, m_dbArcRadius, pt);		// 2
			acutPolar(pt, 0.5*_PI, m_dbArcRadius, virStartPt2);
			acutPolar(virStartPt2, 0, m_dbLongDist-(2*m_nDist+2*m_dbArcRadius), virEndPt2);

			acutPolar(virEndPt2, 1.5*_PI, m_dbArcRadius, pt);	// 3
			acutPolar(pt, 0, m_dbArcRadius, virStartPt3);
			acutPolar(virStartPt3, 1.5*_PI, m_dbShortDist-(2*m_nDist+2*m_dbArcRadius), virEndPt3);

			acutPolar(virEndPt3, _PI, m_dbArcRadius, pt);	// 4R
			acutPolar(pt, 1.5*_PI, m_dbArcRadius, virStartPt4R);
			acutPolar(virStartPt4R, _PI, m_dbLongDist/2-(m_nDist+2*m_dbArcRadius), virEndPt4R);

			acutPolar(virStartPt1, 0, m_dbArcRadius, pt);		// 4L
			acutPolar(pt, 1.5*_PI, m_dbArcRadius, virStartPt4L);
			acutPolar(virStartPt4L, 0, m_dbLongDist/2-(2*m_nDist+2*m_dbArcRadius), virEndPt4L);

			acutPolar(m_ptLB, 0, m_dbLongDist/2-m_nDist, virStartPtIn);		// in
			acutPolar(virStartPtIn, 0.5*_PI, m_nDist-m_dbArcRadius, virEndPtIn);

			acutPolar(m_ptLB, 0, m_dbLongDist/2, virStartPtOut);				// out
			acutPolar(virStartPtOut, 0.5*_PI, m_nDist-m_dbArcRadius, virEndPtOut);
		}
		break;
	case 2:
		{
			m_dbAssisAng = -0.5*_PI;
			acutPolar(m_ptLT, 0, m_nDist, pt);		// 1
			acutPolar(pt, 1.5*_PI, m_nDist+m_dbArcRadius, virStartPt1);
			acutPolar(virStartPt1, 1.5*_PI, m_dbShortDist-(2*m_nDist+2*m_dbArcRadius), virEndPt1);

			acutPolar(virEndPt1, 0, m_dbArcRadius, pt);		// 2
			acutPolar(pt, 1.5*_PI, m_dbArcRadius, virStartPt2);
			acutPolar(virStartPt2, 0, m_dbLongDist-(2*m_nDist+2*m_dbArcRadius), virEndPt2);

			acutPolar(virEndPt2, 0.5*_PI, m_dbArcRadius, pt);	// 3
			acutPolar(pt, 0, m_dbArcRadius, virStartPt3);
			acutPolar(virStartPt3, 0.5*_PI, m_dbShortDist-(2*m_nDist+2*m_dbArcRadius), virEndPt3);

			acutPolar(virEndPt3, _PI, m_dbArcRadius, pt);	// 4R
			acutPolar(pt, 0.5*_PI, m_dbArcRadius, virStartPt4R);
			acutPolar(virStartPt4R, _PI, m_dbLongDist/2-(m_nDist+2*m_dbArcRadius), virEndPt4R);

			acutPolar(virStartPt1, 0, m_dbArcRadius, pt);		// 4L
			acutPolar(pt, 0.5*_PI, m_dbArcRadius, virStartPt4L);
			acutPolar(virStartPt4L, 0, m_dbLongDist/2-(2*m_nDist+2*m_dbArcRadius), virEndPt4L);

			acutPolar(m_ptLT, 0, m_dbLongDist/2-m_nDist, virStartPtIn);		// in
			acutPolar(virStartPtIn, 1.5*_PI, m_nDist-m_dbArcRadius, virEndPtIn);

			acutPolar(m_ptLT, 0, m_dbLongDist/2, virStartPtOut);				// out
			acutPolar(virStartPtOut, 1.5*_PI, m_nDist-m_dbArcRadius, virEndPtOut);
		}
		break;
	case 3:
		{
			m_dbAssisAng = _PI;
			acutPolar(m_ptRT, _PI, m_nDist, pt);		// 1
			acutPolar(pt, 1.5*_PI, m_nDist+m_dbArcRadius, virStartPt1);
			acutPolar(virStartPt1, 1.5*_PI, m_dbShortDist-(2*m_nDist+2*m_dbArcRadius), virEndPt1);

			acutPolar(virEndPt1, _PI, m_dbArcRadius, pt);		// 2
			acutPolar(pt, 1.5*_PI, m_dbArcRadius, virStartPt2);
			acutPolar(virStartPt2, _PI, m_dbLongDist-(2*m_nDist+2*m_dbArcRadius), virEndPt2);

			acutPolar(virEndPt2, 0.5*_PI, m_dbArcRadius, pt);	// 3
			acutPolar(pt, _PI, m_dbArcRadius, virStartPt3);
			acutPolar(virStartPt3, 0.5*_PI, m_dbShortDist-(2*m_nDist+2*m_dbArcRadius), virEndPt3);

			acutPolar(virEndPt3, 0, m_dbArcRadius, pt);	// 4R
			acutPolar(pt, 0.5*_PI, m_dbArcRadius, virStartPt4R);
			acutPolar(virStartPt4R, 0, m_dbLongDist/2-(m_nDist+2*m_dbArcRadius), virEndPt4R);

			acutPolar(virStartPt1, _PI, m_dbArcRadius, pt);		// 4L
			acutPolar(pt, 0.5*_PI, m_dbArcRadius, virStartPt4L);
			acutPolar(virStartPt4L, _PI, m_dbLongDist/2-(2*m_nDist+2*m_dbArcRadius), virEndPt4L);

			acutPolar(m_ptRT, _PI, m_dbLongDist/2-m_nDist, virStartPtIn);		// in
			acutPolar(virStartPtIn, 1.5*_PI, m_nDist-m_dbArcRadius, virEndPtIn);

			acutPolar(m_ptRT, _PI, m_dbLongDist/2, virStartPtOut);				// out
			acutPolar(virStartPtOut, 1.5*_PI, m_nDist-m_dbArcRadius, virEndPtOut);
		}
		break;
	case 4:
		{
			m_dbAssisAng = 0.5*_PI;
			acutPolar(m_ptRB, _PI, m_nDist, pt);		// 1
			acutPolar(pt, 0.5*_PI, m_nDist+m_dbArcRadius, virStartPt1);
			acutPolar(virStartPt1, 0.5*_PI, m_dbShortDist-(2*m_nDist+2*m_dbArcRadius), virEndPt1);

			acutPolar(virEndPt1, _PI, m_dbArcRadius, pt);		// 2
			acutPolar(pt, 0.5*_PI, m_dbArcRadius, virStartPt2);
			acutPolar(virStartPt2, _PI, m_dbLongDist-(2*m_nDist+2*m_dbArcRadius), virEndPt2);

			acutPolar(virEndPt2, 1.5*_PI, m_dbArcRadius, pt);	// 3
			acutPolar(pt, _PI, m_dbArcRadius, virStartPt3);
			acutPolar(virStartPt3, 1.5*_PI, m_dbShortDist-(2*m_nDist+2*m_dbArcRadius), virEndPt3);

			acutPolar(virEndPt3, 0, m_dbArcRadius, pt);	// 4R
			acutPolar(pt, 1.5*_PI, m_dbArcRadius, virStartPt4R);
			acutPolar(virStartPt4R, 0, m_dbLongDist/2-(m_nDist+2*m_dbArcRadius), virEndPt4R);

			acutPolar(virStartPt1, _PI, m_dbArcRadius, pt);		// 4L
			acutPolar(pt, 1.5*_PI, m_dbArcRadius, virStartPt4L);
			acutPolar(virStartPt4L, _PI, m_dbLongDist/2-(2*m_nDist+2*m_dbArcRadius), virEndPt4L);

			acutPolar(m_ptRB, _PI, m_dbLongDist/2-m_nDist, virStartPtIn);		// in
			acutPolar(virStartPtIn, 0.5*_PI, m_nDist-m_dbArcRadius, virEndPtIn);

			acutPolar(m_ptRB, _PI, m_dbLongDist/2, virStartPtOut);				// out
			acutPolar(virStartPtOut, 0.5*_PI, m_nDist-m_dbArcRadius, virEndPtOut);
		}
		break;
	default:
		return false;
	}

	TransToActualPt(virStartPt1, actStartPt);	// 1
	TransToActualPt(virEndPt1, actEndPt);
	CPipeLine *pLine1 = new CPipeLine;
	pLine1->SetStartPt(actStartPt);
	pLine1->SetEndPt(actEndPt);
	m_LineArr1.Add(pLine1);

	TransToActualPt(virStartPt2, actStartPt);	// 2
	TransToActualPt(virEndPt2, actEndPt);
	CPipeLine *pLine2 = new CPipeLine;
	pLine2->SetStartPt(actStartPt);
	pLine2->SetEndPt(actEndPt);
	m_LineArr2.Add(pLine2);

	TransToActualPt(virStartPt3, actStartPt);	// 3
	TransToActualPt(virEndPt3, actEndPt);
	CPipeLine *pLine3 = new CPipeLine;
	pLine3->SetStartPt(actStartPt);
	pLine3->SetEndPt(actEndPt);
	m_LineArr3.Add(pLine3);

	TransToActualPt(virStartPt4L, actStartPt);	// 4L
	TransToActualPt(virEndPt4L, actEndPt);
	CPipeLine *pLine4L = new CPipeLine;
	pLine4L->SetStartPt(actStartPt);
	pLine4L->SetEndPt(actEndPt);
	m_LineArr4L.Add(pLine4L);

	TransToActualPt(virStartPt4R, actStartPt);	// 4R
	TransToActualPt(virEndPt4R, actEndPt);
	CPipeLine *pLine4R = new CPipeLine;
	pLine4R->SetStartPt(actStartPt);
	pLine4R->SetEndPt(actEndPt);
	m_LineArr4R.Add(pLine4R);

	TransToActualPt(virStartPtIn, actStartPt);	// in
	TransToActualPt(virEndPtIn, actEndPt);
	CPipeLine *pLineIn = new CPipeLine;
	pLineIn->SetStartPt(actStartPt);
	pLineIn->SetEndPt(actEndPt);
	m_CenLineArr.Add(pLineIn);

	TransToActualPt(virStartPtOut, actStartPt);	// out
	TransToActualPt(virEndPtOut, actEndPt);
	CPipeLine *pLineOut = new CPipeLine;
	pLineOut->SetStartPt(actStartPt);
	pLineOut->SetEndPt(actEndPt);
	m_CenLineArr.Add(pLineOut);

	// 画线
	m_LineArr1[0]->DrawTheLine(dc, m_nColorInd);
	m_LineArr2[0]->DrawTheLine(dc, m_nColorInd);
	m_LineArr3[0]->DrawTheLine(dc, m_nColorInd);
	m_LineArr4L[0]->DrawTheLine(dc, m_nColorInd);
	m_LineArr4R[0]->DrawTheLine(dc, m_nColorInd);
	m_CenLineArr[0]->DrawTheLine(dc, m_nColorInd);
	m_CenLineArr[1]->DrawTheLine(dc, m_nColorInd);

	// 创建圆弧
	ads_point StartPt, EndPt, CenPt;
	AcDbObjectId ArcID;

	// 1 2
	m_LineArr1[0]->GetEndPt(EndPt);
	m_LineArr2[0]->GetStartPt(StartPt);
	GetArcCenterPt(EndPt, 0, CenPt);
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 2 3
	m_LineArr2[0]->GetEndPt(EndPt);
	m_LineArr3[0]->GetStartPt(StartPt);
	GetArcCenterPt(EndPt, -0.5*_PI, CenPt);
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 3 4R
	m_LineArr3[0]->GetEndPt(EndPt);
	m_LineArr4R[0]->GetStartPt(StartPt);
	GetArcCenterPt(EndPt, _PI, CenPt);
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 1 4L
	m_LineArr1[0]->GetStartPt(StartPt);
	m_LineArr4L[0]->GetStartPt(EndPt);
	GetArcCenterPt(EndPt, 0.5*_PI, CenPt);
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 4L in
	m_CenLineArr[0]->GetEndPt(StartPt);
	m_LineArr4L[0]->GetEndPt(EndPt);
	GetArcCenterPt(EndPt, -0.5*_PI, CenPt);
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// out 4R
	m_LineArr4R[0]->GetEndPt(StartPt);
	m_CenLineArr[1]->GetEndPt(EndPt);
	GetArcCenterPt(EndPt, 0, CenPt);
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	return true;
}

XPoint CPipeStyle5::GetEntryPt(int nNum)
{
    GetCenterPt();			// 得到中心点
    GetDiagAng();			// 得到对角线锐角
    GetLengthofSide();		// 得到长短边
    GetVirtaulRect();		// 得到虚拟矩形
    ads_point StartPtIn;		// 入口起点

    double dbDist12 = acutDistance(m_ptLB, m_ptLT);		// 1、2点间距离
    double dbDist14 = acutDistance(m_ptLB, m_ptRB);		// 1、4点间距离
    if(dbDist12 > dbDist14)
    {
        m_dbDiagAng = 0.5*_PI - m_dbDiagAng;
        GetVirtaulRect();
        nNum += 2;
        if(nNum == 9)
        {
            nNum = 1;
        }
        else if(nNum == 10)
        {
            nNum = 2;
        }
        m_dbNormAng = 0.5*_PI;
    }
    switch(nNum)
    {
    case 1:
    case 2:
        nNum = 1;
        break;
    case 3:
    case 4:
        nNum = 2;
        break;
    case 5:
    case 6:
        nNum = 3;
        break;
    case 7:
    case 8:
        nNum = 4;
        break;
    default :
        nNum = 0;
    }


    if(nNum == 1 || nNum == 4)
        acutPolar(m_ptLB, 0, m_dbLongDist/2, StartPtIn);
    else
        acutPolar(m_ptLT, 0, m_dbLongDist/2, StartPtIn);
    TransToActualPt(StartPtIn, StartPtIn);
	XPoint ptRet = StartPtIn;
	return ptRet;
}


bool CPipeStyle5::DrawMulti()
{
	double dbWidth = m_dbLongDist/2 - ((m_nNum+2)*m_nDist + 2*m_dbArcRadius);
	if(fabs(dbWidth) < 0)
	{
		return false;
	}

	CreateLeftLineArr();
	CreateTopLineArr();
	CreateRightLineArr();
	CreateBottomRightLineArr();
	CreateBottomLeftLineArr();
 
	CreateCenterLineArr();
	CreateEndLineArr();

	return true;
}

// 将虚拟点转换到真实坐标
void CPipeStyle5::TransToActualPt(ads_point point, ads_point retPt)
{
	double dbDist = acutDistance(m_CenterPt, point);
	double ang = acutAngle(m_CenterPt, point);
	acutPolar(m_CenterPt, m_dbPGAng+ang+m_dbNormAng, dbDist, retPt);
}

// 将真实坐标转换到虚拟点
void CPipeStyle5::TransToVirtualPt(ads_point point, ads_point retPt)
{
	double dbDist = acutDistance(m_CenterPt, point);
	double ang = acutAngle(m_CenterPt, point);
	acutPolar(m_CenterPt, ang-m_dbPGAng-m_dbNormAng, dbDist, retPt);
}

	// 虚拟矩形的四个顶点
void CPipeStyle5::GetVirtaulRect()
{
	acutPolar(m_CenterPt, _PI+m_dbDiagAng, m_dbDiagDist/2, m_ptLB);
	acutPolar(m_CenterPt, _PI-m_dbDiagAng, m_dbDiagDist/2, m_ptLT);
	acutPolar(m_CenterPt, m_dbDiagAng, m_dbDiagDist/2, m_ptRT);
	acutPolar(m_CenterPt, -m_dbDiagAng, m_dbDiagDist/2, m_ptRB);
}

void CPipeStyle5::CreateLeftLineArr()
{
   
	ads_point StartPtIn;		// 入口起点
	double dbLen;				// 直线长度
	ads_point pt;
	switch(m_nEntryType)		// 判断入口
	{
	case 1:
		m_dbAssisAng = 0.0;
		acutPolar(m_ptLB, 0, m_nDist, pt);
		acutPolar(pt, 0.5*_PI, m_nDist+m_dbArcRadius, StartPtIn);
		break;
	case 2:
		m_dbAssisAng = 0;
		acutPolar(m_ptLT, 0, m_nDist, pt);
		acutPolar(pt, 1.5*_PI, m_nDist+m_dbArcRadius, StartPtIn);
		break;
	case 3:
		m_dbAssisAng = _PI;
		acutPolar(m_ptRT, _PI, m_nDist, pt);
		acutPolar(pt, 1.5*_PI, m_nDist+m_dbArcRadius, StartPtIn);
		break;
	case 4:
		m_dbAssisAng = _PI;
		acutPolar(m_ptRB, _PI, m_nDist, pt);
		acutPolar(pt, 0.5*_PI, m_nDist+m_dbArcRadius, StartPtIn);
		break;
	default:
		return ;
	}
	dbLen = m_dbShortDist - (2*m_nDist + 2*m_dbArcRadius);

	// 第一根线
	ads_point actPt;		// 实际点
	TransToActualPt(StartPtIn, actPt);
	CPipeLine *line1 = NULL;
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		line1 = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng+0.5*_PI, m_dbNormAng);
	}
	else
	{
		line1 = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng-0.5*_PI, m_dbNormAng);
	}
	m_LineArr1.Add(line1);
 
	// 其余的
	for(int i=1; i < m_nNum; i++)
	{
		ads_point lastPt, virPt;		// 前一直线的起点，虚拟点
		m_LineArr1[i-1]->GetStartPt(lastPt);
		TransToVirtualPt(lastPt, virPt);
		ads_point pt;

		CPipeLine *line = NULL;
		acutPolar(virPt, m_dbAssisAng, m_nDist, pt);
		switch(m_nEntryType)
		{
		case 1:
		case 3:
			{
				dbLen = dbLen - 2*m_nDist;
				acutPolar(pt, m_dbAssisAng+0.5*_PI, m_nDist, pt);
				TransToActualPt(pt, actPt);
				line = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI+m_dbAssisAng, m_dbNormAng);
			}
			break;
		case 2:
		case 4:
			{
				dbLen = dbLen - 2*m_nDist;
				acutPolar(pt, m_dbAssisAng-0.5*_PI, m_nDist, pt);
				TransToActualPt(pt, actPt);
				line = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng-0.5*_PI, m_dbNormAng);
			}
			break;
		default:
			return;
		}

		m_LineArr1.Add(line);
	}

}

void CPipeStyle5::CreateTopLineArr()
{
	double dbLen = 0;			// 直线长
	int size = (int)m_LineArr1.GetSize();
	for(int i=0; i < size; i++)
	{
		ads_point lastPt, virPt, actPt;		// 前一组直线的终点，虚拟点，实际点
		CPipeLine *line = NULL;
		m_LineArr1[i]->GetEndPt(lastPt);
		TransToVirtualPt(lastPt, virPt);
		if(i == 0)
		{// 第一根线
			dbLen = m_dbLongDist - 2*(m_nDist+m_dbArcRadius); 
		}
		else
		{
			dbLen = dbLen - 2*m_nDist; 
		}
		ads_point pt;
		acutPolar(virPt, m_dbAssisAng, m_dbArcRadius, pt);
		switch(m_nEntryType)
		{
		case 1:
		case 3:
			{
				acutPolar(pt, m_dbAssisAng+0.5*_PI, m_dbArcRadius, pt);
			}
			break;
		case 2:
		case 4:
			{
				acutPolar(pt, m_dbAssisAng-0.5*_PI, m_dbArcRadius, pt);
			}
			break;
		default:
			return;
		}
		TransToActualPt(pt, actPt);
		line = new CPipeLine(actPt, m_dbPGAng, dbLen, 0+m_dbAssisAng, m_dbNormAng);
		m_LineArr2.Add(line);
	}
}

void CPipeStyle5::CreateRightLineArr()
{
	double dbLen = 0;			// 直线长
	int size = (int)m_LineArr2.GetSize();

	for(int i=0; i < size; i++)
	{
		ads_point lastPt, virPt, actPt;		// 前一组直线的终点，虚拟点，实际点
		CPipeLine *line = NULL;
		m_LineArr2[i]->GetEndPt(lastPt);
		TransToVirtualPt(lastPt, virPt);
		if(0 == i)
		{
			dbLen = m_dbShortDist - 2*(m_nDist + m_dbArcRadius);
		}
		else
		{
			dbLen -= 2*m_nDist;
		}
		ads_point pt;
		switch(m_nEntryType)
		{
		case 1:
		case 3:
			{
				acutPolar(virPt, m_dbAssisAng-0.5*_PI, m_dbArcRadius, pt);
				acutPolar(pt, m_dbAssisAng, m_dbArcRadius, pt);
				TransToActualPt(pt, actPt);
				line = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng-0.5*_PI, m_dbNormAng);
			}
			break;
		case 2:
		case 4:
			{
				acutPolar(virPt, m_dbAssisAng+0.5*_PI, m_dbArcRadius, pt);
				acutPolar(pt, m_dbAssisAng, m_dbArcRadius, pt);
				TransToActualPt(pt, actPt);
				line = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng+0.5*_PI, m_dbNormAng);
			}
			break;
		default:
			return;
		}
		m_LineArr3.Add(line);
	}
}

void CPipeStyle5::CreateBottomRightLineArr()
{
	double dbLen = 0;			// 直线长
	int size = (int)m_LineArr3.GetSize();
	for(int i=0; i < size; i++)
	{
		ads_point lastPt, virPt, actPt;		// 前一组直线的终点，虚拟点，实际点
		CPipeLine *line = NULL;
		m_LineArr3[i]->GetEndPt(lastPt);
		TransToVirtualPt(lastPt, virPt);
		if(0 == i)
		{
			dbLen = m_dbLongDist/2 - (2*m_nDist + 2*m_dbArcRadius);
		}
		else
		{
			dbLen -= m_nDist;
		}
		ads_point pt;
		acutPolar(virPt, m_dbAssisAng-_PI, m_dbArcRadius, pt);
		switch(m_nEntryType)
		{
		case 1:
		case 3:
			{
				acutPolar(pt, m_dbAssisAng-0.5*_PI, m_dbArcRadius, pt);
			}
			break;
		case 2:
		case 4:
			{
				acutPolar(pt, m_dbAssisAng+0.5*_PI, m_dbArcRadius, pt);
			}
			break;
		default:
			return;
		}
		TransToActualPt(pt, actPt);
		line = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng-_PI, m_dbNormAng);
		m_LineArr4R.Add(line);
	}
}

void CPipeStyle5::CreateCenterLineArr()
{
	double dbLen = 0;			// 直线长
	ads_point lastPt, virPt, actPt;		// 前一组直线的终点，虚拟点，实际点
	ads_point pt;

	if(m_LineArr4R.GetSize() < 1)
	{
		return;
	}

	double dbMirror = 0.0;		// 如果m_nNum是偶数，则中间的线镜象
	if(IsEvenNum(m_nNum))
	{
		dbMirror = _PI;
	}
	// 1
	if(m_nNum == 1)
	{
		m_LineArr4R[0]->GetEndPt(lastPt);
	}
	else
	{
		if(IsEvenNum(m_nNum))
		{
			if(m_LineArr4L.GetSize() != m_nNum)
			{
				return;
			}
			m_LineArr4L[m_nNum-1]->GetEndPt(lastPt);
		}
		else
		{
			if(m_LineArr4R.GetSize() != m_nNum)
			{
				return;
			}
			m_LineArr4R[m_nNum-1]->GetEndPt(lastPt);
		}
	}
	TransToVirtualPt(lastPt, virPt);
	dbLen = m_dbCenDist - 2*m_dbArcRadius;
	CPipeLine *pLine1 = NULL;
	switch(m_nEntryType)
	{
	case 1:
		{
			acutPolar(virPt, 0.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, _PI+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine1 = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI, m_dbNormAng);
		}
		break;
	case 2:
		{
			acutPolar(virPt, 1.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, _PI+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine1 = new CPipeLine(actPt, m_dbPGAng, dbLen, 1.5*_PI, m_dbNormAng);
		}
		break;
	case 3:
		{
			acutPolar(virPt, 1.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, 0+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine1 = new CPipeLine(actPt, m_dbPGAng, dbLen, 1.5*_PI, m_dbNormAng);
		}
		break;
	case 4:
		{
			acutPolar(virPt, 0.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, 0+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine1 = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI, m_dbNormAng);
		}
		break;
	default:
		return;
	}
	m_CenLineArr.Add(pLine1);

	// 2
	m_CenLineArr[0]->GetEndPt(lastPt);
	TransToVirtualPt(lastPt, virPt);
	acutPolar(virPt, m_dbAssisAng+dbMirror, m_dbArcRadius, pt);
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		acutPolar(pt, m_dbAssisAng+0.5*_PI, m_dbArcRadius, pt);
	}
	else
	{
		acutPolar(pt, m_dbAssisAng-0.5*_PI, m_dbArcRadius, pt);
	}
	TransToActualPt(pt, actPt);
	if(m_nNum == 1)
	{
		dbLen = m_dbLongDist/2 - (3*m_nDist + 2*m_dbArcRadius);
	}
	else
	{
		dbLen = m_dbLongDist/2 - ((m_nNum+2)*m_nDist + 2*m_dbArcRadius);
	}
	CPipeLine *pLine2 = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng+dbMirror, m_dbNormAng);
	m_CenLineArr.Add(pLine2);

	// 3
	m_CenLineArr[1]->GetEndPt(lastPt);
	TransToVirtualPt(lastPt, virPt);
	dbLen = m_dbCenDist - 2*m_dbArcRadius;
	CPipeLine *pLine3 = NULL;
	switch(m_nEntryType)
	{
	case 1:
		{
			acutPolar(virPt, 0.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, 0+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine3 = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI, m_dbNormAng);
		}
		break;
	case 2:
		{
			acutPolar(virPt, 1.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, 0+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine3 = new CPipeLine(actPt, m_dbPGAng, dbLen, 1.5*_PI, m_dbNormAng);
		}
		break;
	case 3:
		{
			acutPolar(virPt, 1.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, _PI+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine3 = new CPipeLine(actPt, m_dbPGAng, dbLen, 1.5*_PI, m_dbNormAng);
		}
		break;
	case 4:
		{
			acutPolar(virPt, 0.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, _PI+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine3 = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI, m_dbNormAng);
		}
		break;
	default:
		return;
	}
	m_CenLineArr.Add(pLine3);

	// 4
	m_CenLineArr[2]->GetEndPt(lastPt);
	TransToVirtualPt(lastPt, virPt);
	acutPolar(virPt, m_dbAssisAng+_PI+dbMirror, m_dbArcRadius, pt);
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		acutPolar(pt, m_dbAssisAng+0.5*_PI, m_dbArcRadius, pt);
	}
	else
	{
		acutPolar(pt, m_dbAssisAng-0.5*_PI, m_dbArcRadius, pt);
	}
	TransToActualPt(pt, actPt);
	if(m_nNum == 1)
	{
		dbLen = m_dbLongDist - (4*m_nDist + 2*m_dbArcRadius);
	}
	else
	{
		dbLen = m_dbLongDist - ((2*m_nNum+2)*m_nDist + 2*m_dbArcRadius);
	}
	CPipeLine *pLine4 = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng+_PI+dbMirror, m_dbNormAng);
	m_CenLineArr.Add(pLine4);

	// 5
	m_CenLineArr[3]->GetEndPt(lastPt);
	TransToVirtualPt(lastPt, virPt);
	dbLen = m_dbCenDist - 2*m_dbArcRadius;
	CPipeLine *pLine5 = NULL;
	switch(m_nEntryType)
	{
	case 1:
		{
			acutPolar(virPt, 1.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, _PI+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine5 = new CPipeLine(actPt, m_dbPGAng, dbLen, 1.5*_PI, m_dbNormAng);
		}
		break;
	case 2:
		{
			acutPolar(virPt, 0.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, _PI+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine5 = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI, m_dbNormAng);
		}
		break;
	case 3:
		{
			acutPolar(virPt, 0.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, 0+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine5 = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI, m_dbNormAng);
		}
		break;
	case 4:
		{
			acutPolar(virPt, 1.5*_PI, m_dbArcRadius, pt);
			acutPolar(pt, 0+dbMirror, m_dbArcRadius, pt);
			TransToActualPt(pt, actPt);
			pLine5 = new CPipeLine(actPt, m_dbPGAng, dbLen, 1.5*_PI, m_dbNormAng);
		}
		break;
	default:
		return;
	}
	m_CenLineArr.Add(pLine5);

	// 6
	m_CenLineArr[4]->GetEndPt(lastPt);
	TransToVirtualPt(lastPt, virPt);
	acutPolar(virPt, m_dbAssisAng+dbMirror, m_dbArcRadius, pt);
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		acutPolar(pt, m_dbAssisAng-0.5*_PI, m_dbArcRadius, pt);
	}
	else
	{
		acutPolar(pt, m_dbAssisAng+0.5*_PI, m_dbArcRadius, pt);
	}
	TransToActualPt(pt, actPt);
	if(m_nNum == 1)
	{
		dbLen = m_dbLongDist/2 - (2*m_nDist + 2*m_dbArcRadius);
	}
	else
	{
		dbLen = m_dbLongDist/2 - ((m_nNum+1)*m_nDist + 2*m_dbArcRadius);
	}
	CPipeLine *pLine6 = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng+dbMirror, m_dbNormAng);
	m_CenLineArr.Add(pLine6);

	// 7(out)
	double dbAng = 0.0;
	if(m_nEntryType == 1 || m_nEntryType == 4)
	{
		dbAng = 0.5*_PI;
		acutPolar(m_ptLB, 0, m_dbLongDist/2, pt);
	}
	else
	{
		dbAng = 1.5*_PI;
		acutPolar(m_ptLT, 0, m_dbLongDist/2, pt);
	}
	TransToActualPt(pt, actPt);
	if(m_nNum == 1)
	{
		dbLen = (m_nDist+m_dbCenDist) - m_dbArcRadius;
	}
	else
	{
		dbLen = m_nNum*m_nDist + m_dbCenDist - m_dbArcRadius;
	}
	CPipeLine *pLine7 = new CPipeLine(actPt, m_dbPGAng, dbLen, dbAng, m_dbNormAng);
	m_CenLineArr.Add(pLine7);

	// 8(in)
	dbAng = 0.0;
	switch(m_nEntryType)
	{
	case 1:
		{
			dbAng = 0.5*_PI;
			acutPolar(m_ptLB, 0, m_dbLongDist/2-m_nDist, pt);
		}
		break;
	case 2:
		{
			dbAng = 1.5*_PI;
			acutPolar(m_ptLT, 0, m_dbLongDist/2-m_nDist, pt);
		}
		break;
	case 3:
		{
			dbAng = 1.5*_PI;
			acutPolar(m_ptLT, 0, m_dbLongDist/2+m_nDist, pt);
		}
		break;
	case 4:
		{
			dbAng = 0.5*_PI;
			acutPolar(m_ptLB, 0, m_dbLongDist/2+m_nDist, pt);
		}
		break;
	default:
		return;
	}
	TransToActualPt(pt, actPt);
	dbLen = m_nDist - m_dbArcRadius;
	CPipeLine *pLine8 = new CPipeLine(actPt, m_dbPGAng, dbLen, dbAng, m_dbNormAng);
	m_CenLineArr.Add(pLine8);
}

bool CPipeStyle5::CreateArcArr(XExplodeDraw &dc)
{
	ads_point StartPt, EndPt;		// 圆弧起点，圆弧终点
	AcDbObjectId ArcID;				// 圆弧实体ID
	ads_point CenPt;				// 圆弧中心点
	int size = (int)m_LineArr2.GetSize();
	int i = 0; // sg modify
	for(i=0; i < size; i++)
	{// 1、2边加角圆弧
		m_LineArr1[i]->GetEndPt(EndPt);
		m_LineArr2[i]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, 0, CenPt);
		if(m_nEntryType == 1 || m_nEntryType == 3)
		{
			if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		else
		{
			if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
			{// 反向画弧
				return false;
			}
		}
		m_ArcArr.Add(ArcID);
	}

	size = (int)m_LineArr3.GetSize();
	for(i=0; i < size; i++)
	{// 2、3边加角圆弧
		m_LineArr2[i]->GetEndPt(EndPt);
		m_LineArr3[i]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, -0.5*_PI, CenPt);
		if(m_nEntryType == 1 || m_nEntryType == 3)
		{
			if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		else
		{// 反向画弧
			if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		m_ArcArr.Add(ArcID);
	}
	size = (int)m_LineArr4R.GetSize();
	for(i=0; i < size; i++)
	{// 3、4R边加角圆弧
		m_LineArr3[i]->GetEndPt(EndPt);
		m_LineArr4R[i]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, -_PI, CenPt);
		if(m_nEntryType == 1 || m_nEntryType == 3)
		{
			if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		else
		{
			if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		m_ArcArr.Add(ArcID);
	}

	size = (int)m_LineArr4L.GetSize();
	for(i=0; i < size; i++)
	{// 4L、1边加角圆弧
		m_LineArr4L[i]->GetStartPt(EndPt);
		m_LineArr1[i]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, -1.5*_PI, CenPt);
		if(m_nEntryType == 1 || m_nEntryType == 3)
		{
			if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		else
		{
			if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		m_ArcArr.Add(ArcID);
	}

	// 连接4L、m_EndLineLArr直线端点
	ads_point StartPtL, EndPtL, StartPtR, EndPtR, CenPtL, CenPtR;
	size = (int)m_EndLineLArr.GetSize();
	int j = 2; // sg modify
	for(j=2, i=0; i < size, j < m_LineArr4L.GetSize(); i++, j+=2)
	{
		m_LineArr4L[j]->GetEndPt(EndPtL);
		m_EndLineLArr[i]->GetEndPt(StartPtL);
		m_EndLineLArr[i]->GetStartPt(EndPtR);
		m_LineArr4L[j-1]->GetEndPt(StartPtR);
		switch(m_nEntryType)
		{
		case 1:
			{
				GetArcCenterPt(EndPtL, -0.5*_PI, CenPtL);
				if(!CreateArc(StartPtL, EndPtL, CenPtL, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
				GetArcCenterPt(EndPtR, _PI, CenPtR);
				if(!CreateArc(StartPtR, EndPtR, CenPtR, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
			}
			break;
		case 2:
			{
				GetArcCenterPt(EndPtL, 1.5*_PI, CenPtL);
				if(!CreateArc(EndPtL, StartPtL, CenPtL, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
				GetArcCenterPt(EndPtR, _PI, CenPtR);
				if(!CreateArc(EndPtR, StartPtR, CenPtR, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
			}
			break;
		case 3:
			{
				GetArcCenterPt(EndPtL, 1.5*_PI, CenPtL);
				if(!CreateArc(StartPtL, EndPtL, CenPtL, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
				GetArcCenterPt(EndPtR, _PI, CenPtR);
				if(!CreateArc(StartPtR, EndPtR, CenPtR, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
			}
			break;
		case 4:
			{
				GetArcCenterPt(EndPtL, 1.5*_PI, CenPtL);
				if(!CreateArc(EndPtL, StartPtL, CenPtL, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
				GetArcCenterPt(EndPtR, _PI, CenPtR);
				if(!CreateArc(EndPtR, StartPtR, CenPtR, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
			}
			break;
		default:
			return false;
		}
	}

	// 连接4R、m_EndRineLArr直线端点
	size = (int)m_EndLineRArr.GetSize();
	for(j=1, i=0; i < size, j < m_LineArr4L.GetSize(); i++, j+=2)
	{
		m_LineArr4R[j]->GetEndPt(StartPtR);
		m_EndLineRArr[i]->GetEndPt(EndPtR);
		m_EndLineRArr[i]->GetStartPt(StartPtL);
		m_LineArr4R[j-1]->GetEndPt(EndPtL);
		switch(m_nEntryType)
		{
		case 1:
			{
				GetArcCenterPt(EndPtL, 0.5*_PI, CenPtL);
				if(!CreateArc(StartPtL, EndPtL, CenPtL, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
				GetArcCenterPt(EndPtR, 0, CenPtR);
				if(!CreateArc(StartPtR, EndPtR, CenPtR, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
			}
			break;
		case 2:
			{
				GetArcCenterPt(EndPtL, 0.5*_PI, CenPtL);
				if(!CreateArc(EndPtL, StartPtL, CenPtL, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
				GetArcCenterPt(EndPtR, 0, CenPtR);
				if(!CreateArc(EndPtR, StartPtR, CenPtR, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
			}
			break;
		case 3:
			{
				GetArcCenterPt(EndPtL, 0.5*_PI, CenPtL);
				if(!CreateArc(StartPtL, EndPtL, CenPtL, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
				GetArcCenterPt(EndPtR, 0, CenPtR);
				if(!CreateArc(StartPtR, EndPtR, CenPtR, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
			}
			break;
		case 4:
			{
				GetArcCenterPt(EndPtL, 0.5*_PI, CenPtL);
				if(!CreateArc(EndPtL, StartPtL, CenPtL, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
				GetArcCenterPt(EndPtR, 0, CenPtR);
				if(!CreateArc(EndPtR, StartPtR, CenPtR, ArcID,dc))
				{
					return false;
				}
				m_ArcArr.Add(ArcID);
			}
			break;
		default:
			return false;
		}
	}
	
	// 连接中间直线
	if(m_CenLineArr.GetSize() < 8)
	{
		return false;
	}
	// 1
	if(IsEvenNum(m_nNum))
	{
		m_LineArr4L[m_LineArr4L.GetSize()-1]->GetEndPt(StartPt);
		m_CenLineArr[0]->GetStartPt(EndPt);
		GetArcCenterPt(EndPt, -_PI, CenPt);
	}
	else
	{
		m_LineArr4R[m_LineArr4R.GetSize()-1]->GetEndPt(EndPt);
		m_CenLineArr[0]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, -1.5*_PI, CenPt);
	}
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 2
	if(IsEvenNum(m_nNum))
	{
		m_CenLineArr[0]->GetEndPt(StartPt);
		m_CenLineArr[1]->GetStartPt(EndPt);
		GetArcCenterPt(EndPt, -0.5*_PI, CenPt);
	}
	else
	{
		m_CenLineArr[0]->GetEndPt(EndPt);
		m_CenLineArr[1]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, 0, CenPt);
	}
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 3
	if(IsEvenNum(m_nNum))
	{
		m_CenLineArr[1]->GetEndPt(EndPt);
		m_CenLineArr[2]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, -1.5*_PI, CenPt);
	}
	else
	{
		m_CenLineArr[1]->GetEndPt(StartPt);
		m_CenLineArr[2]->GetStartPt(EndPt);
		GetArcCenterPt(EndPt, _PI, CenPt);
	}
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 4
	if(IsEvenNum(m_nNum))
	{
		m_CenLineArr[2]->GetEndPt(EndPt);
		m_CenLineArr[3]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, 0, CenPt);
	}
	else
	{
		m_CenLineArr[2]->GetEndPt(StartPt);
		m_CenLineArr[3]->GetStartPt(EndPt);
		GetArcCenterPt(EndPt, -0.5*_PI, CenPt);
	}
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 5
	if(IsEvenNum(m_nNum))
	{
		m_CenLineArr[3]->GetEndPt(EndPt);
		m_CenLineArr[4]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, -0.5*_PI, CenPt);
	}
	else
	{
		m_CenLineArr[3]->GetEndPt(StartPt);
		m_CenLineArr[4]->GetStartPt(EndPt);
		GetArcCenterPt(EndPt, 0, CenPt);
	}
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 6
	if(IsEvenNum(m_nNum))
	{
		m_CenLineArr[4]->GetEndPt(EndPt);
		m_CenLineArr[5]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, -_PI, CenPt);
	}
	else
	{
		m_CenLineArr[4]->GetEndPt(StartPt);
		m_CenLineArr[5]->GetStartPt(EndPt);
		GetArcCenterPt(EndPt, -1.5*_PI, CenPt);
	}
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 7
	if(IsEvenNum(m_nNum))
	{
		m_CenLineArr[5]->GetEndPt(StartPt);
		m_CenLineArr[6]->GetEndPt(EndPt);
		GetArcCenterPt(EndPt, 0, CenPt);
	}
	else
	{
		m_CenLineArr[5]->GetEndPt(EndPt);
		m_CenLineArr[6]->GetEndPt(StartPt);
		GetArcCenterPt(EndPt, -0.5*_PI, CenPt);
	}
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	// 8
	m_LineArr4L[0]->GetEndPt(EndPt);
	m_CenLineArr[7]->GetEndPt(StartPt);
	GetArcCenterPt(EndPt, -0.5*_PI, CenPt);
	if(m_nEntryType == 1 || m_nEntryType == 3)
	{
		if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	else
	{
		if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
		{
			return false;
		}
	}
	m_ArcArr.Add(ArcID);

	return true;
}

/*///////////////////////////////////////////////////////////////////////////
    函数 CPipeStyle5::CreateArc()
主要功能: 创建圆弧
  返回值: true:成功		false:失败
参数含义:	
		StartPt - 圆弧起点
		EndPt - 圆弧终点
		CenPt - 圆弧圆心
		ObjID - 返回圆弧实体ID
///////////////////////////////////////////////////////////////////////////*/
bool CPipeStyle5::CreateArc(ads_point StartPt, ads_point EndPt, ads_point CenPt, AcDbObjectId& ObjID,XExplodeDraw &dc)
{
	/*
	AcDbArc *pArc = NULL;
	AcDbBlockTable *pTab;
	AcDbBlockTableRecord *pRec;
    */

	double StartAng = acutAngle(CenPt, StartPt);
	double EndAng = acutAngle(CenPt, EndPt);
    /*
	if(acdbHostApplicationServices()->workingDatabase()
		->getBlockTable(pTab, AcDb::kForRead) != Acad::eOk)
	{
		acutPrintf(_T("\n打开块表失败"));
		return false;
	}
	if(pTab->getAt(ACDB_MODEL_SPACE, pRec, AcDb::kForWrite) != Acad::eOk)
	{
		pTab->close();
		acutPrintf(_T("\n打开块表失败"));
		return false;
	}
	pTab->close();

	pArc = new AcDbArc(asPnt3d(CenPt), m_dbArcRadius, StartAng, EndAng);
	if(pRec->appendAcDbEntity(ObjID, pArc) != Acad::eOk)
	{
		pArc->close();
		pRec->close();
		acutPrintf(_T("\n添加实体失败"));
		return false;
	}
	pArc->close();
	pRec->close();
   */
	XArc pArc(CenPt, m_dbArcRadius, StartAng, EndAng);
	// sg modify
	//	dc.DrawArc(pArc,0);
	
	XCurveSegment seg;
	seg = pArc;
	BOOL bIsWeight = g_bPipeWeight;
	if (bIsWeight) {
		// 注：先给定一个默认值，下个版本改进
		double dWeight = DocGetPScale() * 0.35;
		DrawWeight(dc, dWeight, seg, m_nColorInd, 1.0);
	}
	else
		dc << seg;
	return true;
}

void CPipeStyle5::GetArcCenterPt(ads_point EndPt, double dbAng, ads_point& actCenPt)
{
	actCenPt[X] = actCenPt[Y] = actCenPt[Z] = 0.0;		// 返回的圆心
	ads_point virPt, CenPt;			// 虚拟点，虚拟中心点
	TransToVirtualPt(EndPt, virPt);

	switch(m_nEntryType)
	{
	case 1:
		acutPolar(virPt, dbAng, m_dbArcRadius, CenPt);
		break;
	case 2:
		acutPolar(virPt, 0-dbAng, m_dbArcRadius, CenPt);
		break;
	case 3:
		acutPolar(virPt, dbAng+_PI, m_dbArcRadius, CenPt);
		break;
	case 4:
		acutPolar(virPt, _PI-dbAng, m_dbArcRadius, CenPt);
		break;
	default :
		return;
	}
	TransToActualPt(CenPt, actCenPt);
}

bool CPipeStyle5::IsEvenNum(int nNum)
{
	int nCount = (int)(nNum/2);
	double dbExt = nNum - 2*nCount;
	if(dbExt+1 == 1.0)
	{
		return true;
	}

	return false;
}

void CPipeStyle5::CreateBottomLeftLineArr()
{
	double dbLen = 0;			// 直线长
	int size = (int)m_LineArr1.GetSize();
	for(int i=0; i < size; i++)
	{
		ads_point lastPt, virPt, actPt;		// 前一组直线的终点，虚拟点，实际点
		CPipeLine *line = NULL;
		m_LineArr1[i]->GetStartPt(lastPt);
		TransToVirtualPt(lastPt, virPt);
		if(0 == i)
		{
			dbLen = m_dbLongDist/2 - (2*m_nDist + 2*m_dbArcRadius);
		}
		else
		{
			dbLen -= m_nDist;
		}
		ads_point pt;
		acutPolar(virPt, m_dbAssisAng, m_dbArcRadius, pt);
		switch(m_nEntryType)
		{
		case 1:
		case 3:
			{
				acutPolar(pt, m_dbAssisAng-0.5*_PI, m_dbArcRadius, pt);
			}
			break;
		case 2:
		case 4:
			{
				acutPolar(pt, m_dbAssisAng+0.5*_PI, m_dbArcRadius, pt);
			}
			break;
		default:
			return;
		}
		TransToActualPt(pt, actPt);
		line = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng, m_dbNormAng);
		m_LineArr4L.Add(line);
	}
}

void CPipeStyle5::CreateEndLineArr()
{
	if(m_nNum < 2)
	{
		return;
	}

	double dbLen = 0.0;			// 直线长
	double dbMirror = _PI;

	int size = (int)m_LineArr1.GetSize();
	int i = 1; // sg modify	
	for(i=1; i < size; i+=2) // 右侧
	{
		ads_point lastPtR, virPtR, actPt; // 前一组直线的终点，虚拟点，实际点
		CPipeLine *line = NULL;
		m_LineArr4R[i-1]->GetEndPt(lastPtR);
		TransToVirtualPt(lastPtR, virPtR);
		ads_point ptR;
		dbLen = m_nDist - 2*m_dbArcRadius;
		CPipeLine *pLineR = NULL;
		switch(m_nEntryType)
		{
		case 1:
			{
				acutPolar(virPtR, 0.5*_PI, m_dbArcRadius, ptR);
				acutPolar(ptR, 0+dbMirror, m_dbArcRadius, ptR);
				TransToActualPt(ptR, actPt);
				pLineR = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI, m_dbNormAng);
			}
			break;
		case 2:
			{
				acutPolar(virPtR, 1.5*_PI, m_dbArcRadius, ptR);
				acutPolar(ptR, 0+dbMirror, m_dbArcRadius, ptR);
				TransToActualPt(ptR, actPt);
				pLineR = new CPipeLine(actPt, m_dbPGAng, dbLen, 1.5*_PI, m_dbNormAng);
			}
			break;
		case 3:
			{
				acutPolar(virPtR, 1.5*_PI, m_dbArcRadius, ptR);
				acutPolar(ptR, _PI+dbMirror, m_dbArcRadius, ptR);
				TransToActualPt(ptR, actPt);
				pLineR = new CPipeLine(actPt, m_dbPGAng, dbLen, 1.5*_PI, m_dbNormAng);
			}
			break;
		case 4:
			{
				acutPolar(virPtR, 0.5*_PI, m_dbArcRadius, ptR);
				acutPolar(ptR, _PI+0+dbMirror, m_dbArcRadius, ptR);
				TransToActualPt(ptR, actPt);
				pLineR = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI, m_dbNormAng);
			}
			break;
		default:
			return;
		}
		m_EndLineRArr.Add(pLineR);
	}

	// 左侧
	for(i=2; i < size; i+=2)
	{
		ads_point lastPtL, virPtL, actPt;		// 前一组直线的终点，虚拟点，实际点
		CPipeLine *line = NULL;
		m_LineArr4L[i-1]->GetEndPt(lastPtL);
		TransToVirtualPt(lastPtL, virPtL);
		ads_point ptL;
		dbLen = m_nDist - 2*m_dbArcRadius;
		CPipeLine *pLineL = NULL;
		switch(m_nEntryType)
		{
		case 1:
			{
				acutPolar(virPtL, 0.5*_PI, m_dbArcRadius, ptL);
				acutPolar(ptL, 0, m_dbArcRadius, ptL);
				TransToActualPt(ptL, actPt);
				pLineL = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI, m_dbNormAng);
			}
			break;
		case 2:
			{
				acutPolar(virPtL, 1.5*_PI, m_dbArcRadius, ptL);
				acutPolar(ptL, 0, m_dbArcRadius, ptL);
				TransToActualPt(ptL, actPt);
				pLineL = new CPipeLine(actPt, m_dbPGAng, dbLen, 1.5*_PI, m_dbNormAng);
			}
			break;
		case 3:
			{
				acutPolar(virPtL, 1.5*_PI, m_dbArcRadius, ptL);
				acutPolar(ptL, _PI, m_dbArcRadius, ptL);
				TransToActualPt(ptL, actPt);
				pLineL = new CPipeLine(actPt, m_dbPGAng, dbLen, 1.5*_PI, m_dbNormAng);
			}
			break;
		case 4:
			{
				acutPolar(virPtL, 0.5*_PI, m_dbArcRadius, ptL);
				acutPolar(ptL, _PI, m_dbArcRadius, ptL);
				TransToActualPt(ptL, actPt);
				pLineL = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI, m_dbNormAng);
			}
			break;
		default:
			return;
		}
		m_EndLineLArr.Add(pLineL);
	}
	
}