2048 lines
46 KiB
C++
2048 lines
46 KiB
C++
// 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);
|
||
}
|
||
|
||
}
|
||
|