// PipeStyle6.cpp: implementation of the CPipeStyle6 class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "PipeStyle6.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);


CPipeStyle6::CPipeStyle6()
{
	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_pCenLine = NULL;
	m_pOutLine = NULL;
	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;
}

CPipeStyle6::CPipeStyle6(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_pCenLine = NULL;
	m_pOutLine = NULL;
	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;
}

CPipeStyle6::~CPipeStyle6()
{
	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_LineArr4.GetSize(); i++)
	{
		if(m_LineArr4[i] != NULL)
		{
			delete m_LineArr4[i];
		}
	}
	m_LineArr4.RemoveAll();
	m_ArcArr.RemoveAll();
	if(m_pCenLine != NULL)
		delete m_pCenLine;
	if(m_pOutLine != NULL)
		delete m_pOutLine;
}

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

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

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

void CPipeStyle6::SetEntryType(int nEntryType)
{
	m_nEntryType = nEntryType;
}

bool CPipeStyle6::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)
	{// 如果是一圈
		m_nNum = 1;
	}
	else
	{
		m_nNum = int((nNum-1) / 2);
	} 
	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_LineArr4.GetSize(); i++)
	{
		m_LineArr4[i]->DrawTheLine(dc, m_nColorInd);
	}
	if(m_pCenLine != NULL)
	{
		m_pCenLine->DrawTheLine(dc, m_nColorInd);
	}
	if(m_pOutLine != NULL)
	{
		m_pOutLine->DrawTheLine(dc, m_nColorInd);
	}
	if(!CreateArcArr(dc))
	{
		return false;
	}

	return true;
}

// 将矩形转换为躺倒的矩形
void CPipeStyle6::NormalizeRect()
{
	double dbDist12 = acutDistance(m_ptLB, m_ptLT);		// 1、2点间距离
	double dbDist14 = acutDistance(m_ptLB, m_ptRB);		// 1、4点间距离
	if(dbDist12 <= dbDist14)
	{// 已经是躺倒的
		return ;
	}
	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;
}

	// 矩形的中心点
void CPipeStyle6::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 CPipeStyle6::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 CPipeStyle6::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;
}

XPoint CPipeStyle6::GetEntryPt(int nNum)
{
	GetCenterPt();			// 得到中心点
	GetDiagAng();			// 得到对角线锐角
	GetLengthofSide();		// 得到长短边
    GetVirtaulRect();		// 得到虚拟矩形
    NormalizeRect();		// 把虚拟矩形放倒

/**
	XPoint ptLB, ptLT, ptRT, ptRB;
	ads_polar(m_CenterPt, _PI+m_dbDiagAng+m_dbPGAng, m_dbDiagDist/2, ptLB);
	ads_polar(m_CenterPt, _PI-m_dbDiagAng+m_dbPGAng, m_dbDiagDist/2, ptLT);
	ads_polar(m_CenterPt, m_dbDiagAng+m_dbPGAng, m_dbDiagDist/2, ptRT);
	ads_polar(m_CenterPt, -m_dbDiagAng+m_dbPGAng, m_dbDiagDist/2, ptRB);
//*/	
	if(m_dbNormAng > 0.1)	//add	//==PI/2
	{
		nNum += 2;
		if(nNum == 9)
		{
			nNum = 1;
		}
		else if(nNum == 10)
		{
			nNum = 2;
		}
	}
	ads_point StartPtIn;		// 入口起点
	switch(nNum)		// 判断入口
	{
	case 1:
		acutPolar(m_ptLB, 0, m_nDist, StartPtIn);
		break;
	case 2:
		acutPolar(m_ptLB, 0.5*_PI, m_nDist, StartPtIn);
		break;
	case 3:
		acutPolar(m_ptLT, 1.5*_PI, m_nDist, StartPtIn);
		break;
	case 4:
		acutPolar(m_ptLT, 0, m_nDist, StartPtIn);
		break;
	case 5:
		acutPolar(m_ptRT, _PI, m_nDist, StartPtIn);
		break;
	case 6:
		acutPolar(m_ptRT, 1.5*_PI, m_nDist, StartPtIn);
		break;
	case 7:
		acutPolar(m_ptRB, 0.5*_PI, m_nDist, StartPtIn);
		break;
	case 8:
		acutPolar(m_ptRB, _PI, m_nDist, StartPtIn);
		break;
	default:
		return XPoint();
	}
	XPoint ptRet = StartPtIn;
	TransToActualPt(StartPtIn, ptRet);	//add
	return ptRet;
}


bool CPipeStyle6::DrawMulti()
{
	if(m_nNum == 1)
	{
		m_dbCenDist = (m_dbShortDist - 2*m_nDist) / 2;
	}
	else if(IsEvenNum())
	{
		m_dbCenDist = (m_dbShortDist - 2*m_nNum*m_nDist) / 2;
	}
	else
	{
		m_dbCenDist = (m_dbShortDist - (2*m_nNum-1)*m_nDist) / 2;
	}

	double dbWidth;
	if(IsEvenNum())
	{
		if(m_nEntryType == 1 || m_nEntryType == 4 || m_nEntryType == 5 || m_nEntryType == 8)
		{
			dbWidth = m_dbLongDist - ((2*m_nNum+2)*m_nDist + m_dbArcRadius);
		}
		else
		{
			dbWidth = m_dbLongDist - ((2*m_nNum+1)*m_nDist + m_dbArcRadius);
		}
	}
	else
	{
		if(m_nEntryType == 1 || m_nEntryType == 4 || m_nEntryType == 5 || m_nEntryType == 8)
		{
			dbWidth = m_dbLongDist - ((2*m_nNum+1)*m_nDist + m_dbArcRadius);
		}
		else
		{
			dbWidth = m_dbLongDist - (2*m_nNum*m_nDist + m_dbArcRadius);
		}
	}
	if(fabs(dbWidth) < 0)
	{
	//	acutPrintf(_T("\n指定的绘制范围太小,宽 %.2f 时，长度应至少为%.2f"), m_dbShortDist, m_dbLongDist-dbWidth);
		return false;
	}

	CreateLeftLineArr(m_nNum);
	CreateTopLineArr();
	CreateRightLineArr();
	CreateBottomLineArr();
	CreateCenterLine();
	CreateOutLine();

	return true;
}

// 将虚拟点转换到真实坐标
void CPipeStyle6::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 CPipeStyle6::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 CPipeStyle6::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 CPipeStyle6::CreateLeftLineArr(int nNum)
{
	ads_point StartPtIn;		// 输入线起点
	double dbLen;				// 线长度
	switch(m_nEntryType)		// 判断入口
	{
	case 1:
		dbLen = m_dbShortDist - m_nDist - m_dbArcRadius;
		m_dbAssisAng = 0.0;
		acutPolar(m_ptLB, 0, m_nDist, StartPtIn);
		break;
	case 2:
		dbLen = m_dbLongDist - m_nDist - m_dbArcRadius;
		m_dbAssisAng = 0.5*_PI;
		acutPolar(m_ptLB, 0.5*_PI, m_nDist, StartPtIn);
		break;
	case 3:
		dbLen = m_dbLongDist - m_nDist - m_dbArcRadius;
		m_dbAssisAng = 1.5*_PI;
		acutPolar(m_ptLT, 1.5*_PI, m_nDist, StartPtIn);
		break;
	case 4:
		dbLen = m_dbShortDist - m_nDist - m_dbArcRadius;
		m_dbAssisAng = 0;
		acutPolar(m_ptLT, 0, m_nDist, StartPtIn);
		break;
	case 5:
		dbLen = m_dbShortDist - m_nDist - m_dbArcRadius;
		m_dbAssisAng = _PI;
		acutPolar(m_ptRT, _PI, m_nDist, StartPtIn);
		break;
	case 6:
		dbLen = m_dbLongDist - m_nDist - m_dbArcRadius;
		m_dbAssisAng = 1.5*_PI;
		acutPolar(m_ptRT, 1.5*_PI, m_nDist, StartPtIn);
		break;
	case 7:
		dbLen = m_dbLongDist - m_nDist - m_dbArcRadius;
		m_dbAssisAng = 0.5*_PI;
		acutPolar(m_ptRB, 0.5*_PI, m_nDist, StartPtIn);
		break;
	case 8:
		dbLen = m_dbShortDist - m_nDist - m_dbArcRadius;
		m_dbAssisAng = _PI;
		acutPolar(m_ptRB, _PI, m_nDist, StartPtIn);
		break;
	default:
		return ;
	}

	// 第一根线
	ads_point actPt;		// 实际点
	TransToActualPt(StartPtIn, actPt);
	CPipeLine *line1 = NULL;
	if(m_nEntryType == 1 || m_nEntryType == 3 || m_nEntryType == 5 || m_nEntryType == 7)
	{
		line1 = new CPipeLine(actPt, m_dbPGAng, dbLen, 0.5*_PI+m_dbAssisAng, m_dbNormAng);
	}
	else
	{
		line1 = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng-0.5*_PI, m_dbNormAng);
	}
	m_LineArr1.Add(line1);

	if((m_nEntryType == 1 || m_nEntryType == 4 || m_nEntryType == 5 || m_nEntryType == 8)
		&& IsEvenNum())
	{
		nNum++;
	}
	// 其余的
	for(int i=1; i < nNum; i++)
	{
		ads_point lastPt;		// 前一直线的起点
		ads_point 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:
		case 5:
		case 7:
			{
				if(i == nNum-1 && (m_nEntryType == 1 || m_nEntryType == 5))
				{// 最后一条
					if(i == 1)
					{// 第2条
						if(IsEvenNum())
						{// 是偶数
							dbLen = m_dbCenDist - 2*m_dbArcRadius;
						}
						else
						{
							dbLen = dbLen - (2*m_nDist+m_dbArcRadius);
						}
						acutPolar(pt, m_dbAssisAng+0.5*_PI, m_nDist+m_dbArcRadius, pt);
					}
					else
					{
						if(IsEvenNum())
						{
							dbLen = m_dbCenDist - 2*m_dbArcRadius;
						}
						else
						{
							dbLen = dbLen - 2*m_nDist;
						}
						acutPolar(pt, m_dbAssisAng+0.5*_PI, m_nDist, pt);
					}
				}
				else if(i == 1)
				{// 第2条
					dbLen = dbLen - (2*m_nDist + m_dbArcRadius);
					acutPolar(pt, m_dbAssisAng+0.5*_PI, m_nDist+m_dbArcRadius, pt);
				}
				else
				{
					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:
		case 6:
		case 8:
			{
				if(i == nNum-1)
				{// 最后一条
					if(i == 1)
					{// 第2条
						if(IsEvenNum())
						{// 是偶数
							dbLen = m_dbLongDist - (3*m_nDist + 2*m_dbArcRadius);
						}
						else
						{
							dbLen = dbLen - (2*m_nDist+m_dbArcRadius);
						}
						acutPolar(pt, m_dbAssisAng-0.5*_PI, m_nDist+m_dbArcRadius, pt);
					}
					else
					{
						if((m_nEntryType == 4 || m_nEntryType == 8) && IsEvenNum())
						{
							dbLen = m_dbCenDist - 2*m_dbArcRadius;
						}
						else
						{
							dbLen = dbLen - 2*m_nDist;
						}
						acutPolar(pt, m_dbAssisAng-0.5*_PI, m_nDist, pt);
					}
				}
				else if(i == 1)
				{// 第2条
					dbLen = dbLen - (2*m_nDist + m_dbArcRadius);
					acutPolar(pt, m_dbAssisAng-0.5*_PI, m_nDist+m_dbArcRadius, pt);
				}
				else
				{
					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 CPipeStyle6::CreateTopLineArr()
{
	double dbLen = 0;			// 直线长
	int size = (int)m_LineArr1.GetSize();
	if((m_nEntryType == 1 || m_nEntryType == 4 || m_nEntryType == 5 || m_nEntryType == 8)
		&& IsEvenNum())
	{// 比数组1中的直线少1
		size--;
	}
	for(int i=0; i < size; i++)
	{
		ads_point lastPt;		// 前一组直线的终点
		ads_point virPt;		// 虚拟点
		ads_point actPt;		// 实际点
		CPipeLine *line = NULL;
		m_LineArr1[i]->GetEndPt(lastPt);
		TransToVirtualPt(lastPt, virPt);
		ads_point pt;
		switch(m_nEntryType)
		{
		case 1:
		case 3:
		case 5:
		case 7:
			{
				if(i == size-1)
				{// 最后一根
					if(m_nNum == 1)
					{// 只有一圈
						if(m_nEntryType == 1|| m_nEntryType == 5)
						{
							dbLen = m_dbLongDist - 2*(m_nDist+m_dbArcRadius);
						}
						else
						{
							dbLen = m_dbShortDist - 2*(m_nDist+m_dbArcRadius);
						}
					}
					else
					{
						switch(m_nEntryType)
						{
						case 1:
						case 5:
							dbLen = dbLen - 2*m_nDist;
							break;
						case 3:
						case 7:
							if(IsEvenNum())
							{// 偶数
								dbLen = dbLen - 2*m_nDist;
							}
							else
							{
								dbLen = m_dbCenDist - 2*m_dbArcRadius;
							}
							break;
						default:
							return;
						}
					}
				}
				else if(i == 0)
				{// 第一根线
					if(m_nEntryType == 1 || m_nEntryType == 5)
					{
						dbLen = m_dbLongDist - 2*(m_nDist+m_dbArcRadius); 
					}
					else
					{
						dbLen = m_dbShortDist - 2*(m_nDist+m_dbArcRadius); 
					}
				}
				else
				{
					dbLen = dbLen - 2*m_nDist; 
				}
				acutPolar(virPt, m_dbAssisAng, m_dbArcRadius, pt);
				acutPolar(pt, m_dbAssisAng+0.5*_PI, m_dbArcRadius, pt);
				TransToActualPt(pt, actPt);
				line = new CPipeLine(actPt, m_dbPGAng, dbLen, 0+m_dbAssisAng, m_dbNormAng);
			}
			break;
		case 2:
		case 4:
		case 6:
		case 8:
			{
				if(i == size-1)
				{// 最后一根
					if(m_nNum == 1)
					{// 只有一圈
						if(m_nEntryType == 4 || m_nEntryType == 8)
						{
							dbLen = m_dbLongDist - 2*(m_nDist+m_dbArcRadius);
						}
						else
						{
							dbLen = m_dbShortDist - 2*(m_nDist+m_dbArcRadius);
						}
					}
					else
					{
						switch(m_nEntryType)
						{
						case 4:
						case 8:
							dbLen = dbLen - 2*m_nDist;
							break;
						case 2:
						case 6:
							if(IsEvenNum())
							{// 偶数
								dbLen = dbLen - 2*m_nDist;
							}
							else
							{
								dbLen = m_dbCenDist - 2*m_dbArcRadius;
							}
							break;
						default:
							return;
						}
					}
				}
				else if(i == 0)
				{// 第一根线
					if(m_nEntryType == 4 || m_nEntryType == 8)
					{
						dbLen = m_dbLongDist - 2*(m_nDist+m_dbArcRadius); 
					}
					else
					{
						dbLen = m_dbShortDist - 2*(m_nDist+m_dbArcRadius); 
					}
				}
				else
				{
					dbLen = dbLen - 2*m_nDist; 
				}
				acutPolar(virPt, m_dbAssisAng, m_dbArcRadius, pt);
				acutPolar(pt, m_dbAssisAng-0.5*_PI, m_dbArcRadius, pt);
				TransToActualPt(pt, actPt);
				line = new CPipeLine(actPt, m_dbPGAng, dbLen, 0+m_dbAssisAng, m_dbNormAng);
			}
			break;
		default:
			return;
		}
		m_LineArr2.Add(line);
	}
}

void CPipeStyle6::CreateRightLineArr()
{
	double dbLen = 0;			// 直线长
	int size = (int)m_LineArr2.GetSize();
	if((m_nEntryType == 2 || m_nEntryType == 3 || m_nEntryType == 6 || m_nEntryType == 7)
		&& !IsEvenNum())
	{// 比数组2中的直线数量少1
		size--;
	}

	for(int i=0; i < size; i++)
	{
		ads_point lastPt, virPt, actPt;		// 前一组直线的终点，虚拟点，实际点
		CPipeLine *line = NULL;
		m_LineArr2[i]->GetEndPt(lastPt);
		TransToVirtualPt(lastPt, virPt);
		ads_point pt;
		switch(m_nEntryType)
		{
		case 1:
		case 3:
		case 5:
		case 7:
			{
				if(i == size-1)
				{// 最后一根
					if(m_nNum == 1)
					{// 只有一圈
						if(m_nEntryType == 1|| m_nEntryType == 5)
						{
							dbLen = m_dbShortDist - 2*(m_nDist+m_dbArcRadius);
						}
						else
						{
							dbLen = m_dbLongDist - 2*(m_nDist+m_dbArcRadius);
						}
					}
					else
					{
						switch(m_nEntryType)
						{
						case 1:
						case 5:
							if(IsEvenNum())
							{// 偶数
								dbLen = dbLen - 2*m_nDist;
							}
							else
							{
								dbLen = m_dbCenDist - 2*m_dbArcRadius;
							}
							break;
						case 3:
						case 7:
							if(m_nNum == 2)
							{// 只有2圈
								dbLen = m_dbLongDist - (4*m_nDist+2*m_dbArcRadius);
							}
							else
							{
								dbLen = dbLen - 2*m_nDist;
							}
							break;
						default:
							return;
						}
					}
				}
				else if(i == 0)
				{// 第一根线
					if(m_nEntryType == 1 || m_nEntryType == 5)
					{
						dbLen = m_dbShortDist - 2*(m_nDist+m_dbArcRadius); 
					}
					else
					{
						dbLen = m_dbLongDist - 2*(m_nDist+m_dbArcRadius); 
					}
				}
				else
				{
					dbLen = dbLen - 2*m_nDist; 
				}
				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:
		case 6:
		case 8:
			{
				if(i == size-1)
				{// 最后一根
					if(m_nNum == 1)
					{// 只有一圈
						if(m_nEntryType == 4 || m_nEntryType == 8)
						{
							dbLen = m_dbShortDist - 2*(m_nDist+m_dbArcRadius);
						}
						else
						{
							dbLen = m_dbLongDist - 2*(m_nDist+m_dbArcRadius);
						}
					}
					else
					{
						switch(m_nEntryType)
						{
						case 4:
						case 8:
							if(IsEvenNum())
							{// 偶数
								dbLen = dbLen - 2*m_nDist;
							}
							else
							{
								dbLen = m_dbCenDist - 2*m_dbArcRadius;
							}
							break;
						case 2:
						case 6:
							if(m_nNum == 2)
							{// 只有2圈
								dbLen = m_dbLongDist - (4*m_nDist+2*m_dbArcRadius);
							}
							else
							{
								dbLen = dbLen - 2*m_nDist;
							}
							break;
						default:
							return;
						}
					}
				}
				else if(i == 0)
				{// 第一根线
					if(m_nEntryType == 4 || m_nEntryType == 8)
					{
						dbLen = m_dbShortDist - 2*(m_nDist+m_dbArcRadius); 
					}
					else
					{
						dbLen = m_dbLongDist - 2*(m_nDist+m_dbArcRadius); 
					}
				}
				else
				{
					dbLen = dbLen - 2*m_nDist; 
				}
				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 CPipeStyle6::CreateBottomLineArr()
{
	double dbLen = 0;			// 直线长
	int size = (int)m_LineArr3.GetSize();
	if((m_nEntryType == 1 || m_nEntryType == 4 || m_nEntryType == 5 || m_nEntryType == 8)
		&& m_nNum != 1 && !IsEvenNum())
	{// 比数组3中的直线数量少1
		size--;
	}
	for(int i=0; i < size; i++)
	{
		ads_point lastPt, virPt, actPt;		// 前一组直线的终点，虚拟点，实际点
		CPipeLine *line = NULL;
		m_LineArr3[i]->GetEndPt(lastPt);
		TransToVirtualPt(lastPt, virPt);
		ads_point pt;
		switch(m_nEntryType)
		{
		case 1:
		case 3:
		case 5:
		case 7:
			{
				if(i == size-1)
				{// 最后一根
					if(m_nNum == 1)
					{// 只有一圈
						if(m_nEntryType == 1 || m_nEntryType == 5)
						{
							dbLen = m_dbLongDist - (3*m_nDist+2*m_dbArcRadius);
						}
						else
						{
							dbLen = m_dbCenDist - 2*m_dbArcRadius;
						}
					}
					else
					{
						switch(m_nEntryType)
						{
						case 1:
						case 5:
								if(m_nNum == 2)
								{// 只有2圈
									dbLen = m_dbLongDist - (5*m_nDist+2*m_dbArcRadius);
								}
								else
								{
									dbLen = dbLen - 2*m_nDist;
								}
							break;
						case 3:
						case 7:
							if(IsEvenNum())
							{// 偶数
								dbLen = m_dbCenDist - 2*m_dbArcRadius;
							}
							else
							{
								if(m_nNum == 2)
								{// 只有2圈
									dbLen = m_dbShortDist - (3*m_nDist+2*m_dbArcRadius);
								}
								else
								{
									dbLen = dbLen - 2*m_nDist;
								}
							}
							break;
						default:
							return;
						}
					}
				}
				else if(i == 0)
				{// 第一根线
					if(m_nEntryType == 1 || m_nEntryType == 5)
					{
						dbLen = m_dbLongDist - (3*m_nDist+2*m_dbArcRadius); 
					}
					else
					{
						dbLen = m_dbShortDist - (3*m_nDist+2*m_dbArcRadius); 
					}
				}
				else
				{
					dbLen = dbLen - 2*m_nDist; 
				}
				acutPolar(virPt, m_dbAssisAng-_PI, m_dbArcRadius, pt);
				acutPolar(pt, m_dbAssisAng-0.5*_PI, m_dbArcRadius, pt);
				TransToActualPt(pt, actPt);
				line = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng-_PI, m_dbNormAng);
			}
			break;
		case 2:
		case 4:
		case 6:
		case 8:
			{
				if(i == size-1)
				{// 最后一根
					if(m_nNum == 1)
					{// 只有一圈
						if(m_nEntryType == 4 || m_nEntryType == 8)
						{
							dbLen = m_dbLongDist - (3*m_nDist+2*m_dbArcRadius);
						}
						else
						{
							dbLen = m_dbCenDist - 2*m_dbArcRadius;
						}
					}
					else
					{
						switch(m_nEntryType)
						{
						case 4:
						case 8:
								if(m_nNum == 2)
								{// 只有2圈
									dbLen = m_dbLongDist - (5*m_nDist+2*m_dbArcRadius);
								}
								else
								{
									dbLen = dbLen - 2*m_nDist;
								}
							break;
						case 2:
						case 6:
							if(IsEvenNum())
							{// 偶数
								dbLen = m_dbCenDist - 2*m_dbArcRadius;
							}
							else
							{
								if(m_nNum == 2)
								{// 只有2圈
									dbLen = m_dbShortDist - (3*m_nDist+2*m_dbArcRadius);
								}
								else
								{
									dbLen = dbLen - 2*m_nDist;
								}
							}
							break;
						default:
							return;
						}
					}
				}
				else if(i == 0)
				{// 第一根线
					if(m_nEntryType == 4 || m_nEntryType == 8)
					{
						dbLen = m_dbLongDist - (3*m_nDist+2*m_dbArcRadius); 
					}
					else
					{
						dbLen = m_dbShortDist - (3*m_nDist+2*m_dbArcRadius); 
					}
				}
				else
				{
					dbLen = dbLen - 2*m_nDist; 
				}
				acutPolar(virPt, m_dbAssisAng-_PI, m_dbArcRadius, pt);
				acutPolar(pt, m_dbAssisAng+0.5*_PI, m_dbArcRadius, pt);
				TransToActualPt(pt, actPt);
				line = new CPipeLine(actPt, m_dbPGAng, dbLen, m_dbAssisAng-_PI, m_dbNormAng);
			}
			break;
		default:
			return;
		}
		m_LineArr4.Add(line);
	}
}

void CPipeStyle6::CreateCenterLine()
{
	double dbLen = 0;			// 直线长
	ads_point lastPt, virPt, actPt;		// 前一组直线的终点，虚拟点，实际点
	ads_point pt;
	double dbAng = 0.0;			// 辅助角度(1、2取0，3、4取_PI)

	switch(m_nEntryType)
	{
	case 1:
	case 4:
	case 5:
	case 8:
		{
			if(IsEvenNum())
			{// 偶数
				int size = (int)m_LineArr1.GetSize();
				m_LineArr1[size-1]->GetEndPt(lastPt);		// 取1边的最后一条线
				dbAng = 0.0;
			}
			else
			{
				int size = (int)m_LineArr3.GetSize();			// 取3边的最后一条线
				m_LineArr3[size-1]->GetEndPt(lastPt);
				dbAng = _PI;
			}
			TransToVirtualPt(lastPt, virPt);

			acutPolar(virPt, m_dbAssisAng+dbAng, m_dbArcRadius, pt);
			if(m_nEntryType == 1 || m_nEntryType == 5)
			{
				if(IsEvenNum())
				{// 偶数
					dbLen = m_dbLongDist - (2*m_nNum*m_nDist + 2*m_nDist + m_dbArcRadius);
				}
				else
				{
					dbLen = m_dbLongDist - ((2*m_nNum-1)*m_nDist + 2*m_nDist + m_dbArcRadius);
				}
				acutPolar(pt, m_dbAssisAng+0.5*_PI+dbAng, m_dbArcRadius, pt);
			}
			else
			{
				if(IsEvenNum())
				{// 偶数
					dbLen = m_dbLongDist - (2*m_nNum*m_nDist + 2*m_nDist + m_dbArcRadius);
				}
				else
				{
					dbLen = m_dbLongDist - ((2*m_nNum-1)*m_nDist + 2*m_nDist + m_dbArcRadius);
				}
				acutPolar(pt, m_dbAssisAng-0.5*_PI+dbAng, m_dbArcRadius, pt);
			}
			TransToActualPt(pt, actPt);
			if(m_nEntryType == 1 || m_nEntryType == 4)
			{
				m_pCenLine = new CPipeLine(actPt, m_dbPGAng, dbLen, 0, m_dbNormAng+dbAng);
			}
			else
			{
				m_pCenLine = new CPipeLine(actPt, m_dbPGAng, dbLen, _PI, m_dbNormAng+dbAng);
			}
		}
		break;
	case 2:
	case 3:
	case 6:
	case 7:
		{
			if(IsEvenNum())
			{// 偶数
				int size = (int)m_LineArr4.GetSize();
				m_LineArr4[size-1]->GetEndPt(lastPt);		// 取4边的最后一条线
				dbAng = _PI;
			}
			else
			{
				int size = (int)m_LineArr2.GetSize();
				m_LineArr2[size-1]->GetEndPt(lastPt);		// 取2边的最后一条线
				dbAng = 0.0;
			}
			TransToVirtualPt(lastPt, virPt);

			acutPolar(virPt, m_dbAssisAng+dbAng, m_dbArcRadius, pt);
			if(m_nEntryType == 2 || m_nEntryType == 6)
			{
				if(IsEvenNum())
				{// 偶数
					dbLen = m_dbLongDist - ((2*m_nNum-1)*m_nDist + 2*m_nDist + m_dbArcRadius);
				}
				else
				{
					dbLen = m_dbLongDist - (2*(m_nNum-1)*m_nDist + 2*m_nDist + m_dbArcRadius);
				}
				acutPolar(pt, m_dbAssisAng+0.5*_PI+dbAng, m_dbArcRadius, pt);
			}
			else
			{
				if(IsEvenNum())
				{// 偶数
					dbLen = m_dbLongDist - ((2*m_nNum-1)*m_nDist + 2*m_nDist + m_dbArcRadius);
				}
				else
				{
					dbLen = m_dbLongDist - (2*(m_nNum-1)*m_nDist + 2*m_nDist + m_dbArcRadius);
				}
				acutPolar(pt, m_dbAssisAng-0.5*_PI+dbAng, m_dbArcRadius, pt);
			}
			TransToActualPt(pt, actPt);
			if(m_nEntryType == 2 || m_nEntryType == 3)
			{
				m_pCenLine = new CPipeLine(actPt, m_dbPGAng, dbLen, _PI, m_dbNormAng+dbAng);
			}
			else
			{
				m_pCenLine = new CPipeLine(actPt, m_dbPGAng, dbLen, 0, m_dbNormAng+dbAng);
			}
		}
		break;
	default:
		return;
	}
}

bool CPipeStyle6::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 || m_nEntryType == 5 || m_nEntryType == 7)
		{
			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 || m_nEntryType == 5 || m_nEntryType == 7)
		{
			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_LineArr4.GetSize();
	for(i=0; i < size; i++)
	{// 3、4边加角圆弧
		m_LineArr3[i]->GetEndPt(EndPt);
		m_LineArr4[i]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, -_PI, CenPt);
		if(m_nEntryType == 1 || m_nEntryType == 3 || m_nEntryType == 5 || m_nEntryType == 7)
		{
			if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		else
		{// 反向画弧
			if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		m_ArcArr.Add(ArcID);
	}

	for(i=0; i < size; i++)
	{// 4、1边加角圆弧
		if(m_nNum == 1)
		{
			m_LineArr4[0]->GetEndPt(StartPt);
			if(m_LineArr1.GetSize() < 2)
			{// 只有一圈时不画
				break;
			}
			m_LineArr1[1]->GetStartPt(EndPt);
			GetArcCenterPt(EndPt, 0, CenPt);
			if(m_nEntryType == 1 || m_nEntryType == 3 || m_nEntryType == 5 || m_nEntryType == 7)
			{
				if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
				{
					return false;
				}
			}
			else
			{
				if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
				{// 反向画弧
					return false;
				}
			}
			break;
		}
		m_LineArr4[i]->GetEndPt(EndPt);
		if(m_LineArr1.GetSize() < (i+2))
		{// 1组中没有实体了
			break;
		}
		m_LineArr1[i+1]->GetStartPt(StartPt);
		GetArcCenterPt(EndPt, -1.5*_PI, CenPt);
		if(m_nEntryType == 1 || m_nEntryType == 3 || m_nEntryType == 5 || m_nEntryType == 7)
		{
			if(!CreateArc(StartPt, EndPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		else
		{// 反向画弧
			if(!CreateArc(EndPt, StartPt, CenPt, ArcID,dc))
			{
				return false;
			}
		}
		m_ArcArr.Add(ArcID);
	}

	// 中心线圆弧
	if(m_pCenLine != NULL)
	{
		m_pCenLine->GetStartPt(StartPt);
		if(m_nEntryType == 1 || m_nEntryType == 4 || m_nEntryType == 5 || m_nEntryType == 8)
		{
			if(IsEvenNum())
			{// 如果是偶数，且入口是1、4、5、8，则连接1边最后一根直线的终点
				m_LineArr1[m_LineArr1.GetSize()-1]->GetEndPt(EndPt);
				GetArcCenterPt(EndPt, 0, CenPt);
			}
			else
			{// 否则连接3边最后一根直线的终点
				m_LineArr3[m_LineArr3.GetSize()-1]->GetEndPt(EndPt);
				GetArcCenterPt(EndPt, _PI, CenPt);
			}
		}
		else
		{
			if(IsEvenNum())
			{// 如果是偶数，且入口是2、3、6、7，则连接4边最后一根直线的终点
				m_LineArr4[m_LineArr4.GetSize()-1]->GetEndPt(EndPt);
				GetArcCenterPt(EndPt, -1.5*_PI, CenPt);
			}
			else
			{// 否则连接2边最后一根直线的终点
				m_LineArr2[m_LineArr2.GetSize()-1]->GetEndPt(EndPt);
				GetArcCenterPt(EndPt, -0.5*_PI, CenPt);
			}
		}
		if(m_nEntryType == 1 || m_nEntryType == 3 || m_nEntryType == 5 || m_nEntryType == 7)
		{
			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;
}

/*///////////////////////////////////////////////////////////////////////////
    函数 CPipeStyle6::CreateArc()
主要功能: 创建圆弧
  返回值: true:成功		false:失败
参数含义:	
		StartPt - 圆弧起点
		EndPt - 圆弧终点
		CenPt - 圆弧圆心
		ObjID - 返回圆弧实体ID
///////////////////////////////////////////////////////////////////////////*/
bool CPipeStyle6::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 CPipeStyle6::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.5*_PI-dbAng, m_dbArcRadius, CenPt);
		break;
	case 3:
		acutPolar(virPt, dbAng+1.5*_PI, m_dbArcRadius, CenPt);
		break;
	case 4:
		acutPolar(virPt, 0-dbAng, m_dbArcRadius, CenPt);
		break;
	case 5:
		acutPolar(virPt, dbAng+_PI, m_dbArcRadius, CenPt);
		break;
	case 6:
		acutPolar(virPt, 1.5*_PI-dbAng, m_dbArcRadius, CenPt);
		break;
	case 7:
		acutPolar(virPt, dbAng+0.5*_PI, m_dbArcRadius, CenPt);
		break;
	case 8:
		acutPolar(virPt, _PI-dbAng, m_dbArcRadius, CenPt);
		break;
	default :
		return;
	}
	TransToActualPt(CenPt, actCenPt);
}

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

	return false;
}

void CPipeStyle6::CreateOutLine()
{
	ads_point virPt, EndPt, StartPt;		// 虚拟点，终点，起点
	if(m_pCenLine == NULL)
	{
		acutPrintf(_T("\nm_pCenLine == NULL"));
		return;
	}
	m_pCenLine->GetEndPt(StartPt);
	m_LineArr1[0]->GetStartPt(EndPt);
	TransToVirtualPt(EndPt, virPt);

	switch(m_nEntryType)
	{
	case 1:
	case 4:
		acutPolar(virPt, 0, m_nDist, virPt);
		break;
	case 2:
	case 7:
		acutPolar(virPt, 0.5*_PI, m_nDist, virPt);
		break;
	case 3:
	case 6:
		acutPolar(virPt, 1.5*_PI, m_nDist, virPt);
		break;
	case 5:
	case 8:
		acutPolar(virPt, _PI, m_nDist, virPt);
		break;
	default:
		return;
	}
	TransToActualPt(virPt, EndPt);

	m_pOutLine = new CPipeLine;
	m_pOutLine->SetStartPt(StartPt);
	m_pOutLine->SetEndPt(EndPt);
}