6881 lines
184 KiB
C++
6881 lines
184 KiB
C++
#include "stdafx.h"
|
||
#include "ImpHvacCross.h"
|
||
#include "AecDbObjXDataMap.h"
|
||
#include "AuxTools.h"
|
||
#include "math.h"
|
||
#include "AecDbEntityBase.h"
|
||
|
||
static const Adesk::UInt16 kColorByLayer = 256;
|
||
extern double MayAsMUnit(double dVal);
|
||
|
||
double g_dCmdOff = 100;
|
||
|
||
ImpHvacCross::ImpHvacCross()
|
||
{
|
||
m_pXDataMap = NULL;
|
||
m_pOwnerEnt = NULL;
|
||
}
|
||
|
||
ImpHvacCross::~ImpHvacCross()
|
||
{
|
||
}
|
||
|
||
AcGeVector3d ImpHvacCross::normal() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
AcGeVector3d vtStart, vtBr1;
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
|
||
return vtStart.crossProduct(vtBr1);
|
||
}
|
||
|
||
double ImpHvacCross::GetEdgeLineWidth() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dWidth(0.0);
|
||
m_pXDataMap->GetAt(HVAC_EdgeWidth, dWidth);
|
||
|
||
return dWidth;
|
||
}
|
||
|
||
double ImpHvacCross::GetCentLineWidth() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dWidth(0.0);
|
||
m_pXDataMap->GetAt(HVAC_CentWidth, dWidth);
|
||
|
||
return dWidth;
|
||
}
|
||
|
||
double ImpHvacCross::GetEndLineWidth() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dWidth(0.0);
|
||
m_pXDataMap->GetAt(HVAC_EndWidth, dWidth);
|
||
|
||
return dWidth;
|
||
}
|
||
|
||
BOOL ImpHvacCross::SetSingleDashWidth(double& dSta,double& dEnd,double& dBr1,double& dBr2) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
if (!IsSingleLine())
|
||
{
|
||
return FALSE;
|
||
}
|
||
double dSingleWidth(0.0);
|
||
m_pXDataMap->GetAt(KEY_HIDEWIDTH, dSingleWidth);
|
||
if (dSingleWidth > 0)
|
||
{
|
||
dSta = dEnd = dBr1 = dBr2 = dSingleWidth;
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void ImpHvacCross::list() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
// 管件类型
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 暖通：四通"));
|
||
|
||
// 截面类型
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
|
||
switch (eSectType)
|
||
{
|
||
case eRect: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 截面：矩形")); break;
|
||
case eCircle:acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 截面：圆形")); break;
|
||
case eOblate:acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 截面：扁圆形")); break;
|
||
}
|
||
|
||
double dRadRatio = 0.0;
|
||
m_pXDataMap->GetAt(HCRS_RadRatio, dRadRatio);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t曲率值：%.2f"), dRadRatio);
|
||
|
||
// 圆型截面显示直径
|
||
if (eCircle == eSectType)
|
||
{
|
||
double dStartDiameter = 0.0, dEndDiameter = 0.0;
|
||
m_pXDataMap->GetAt(HCRS_StartDiameter, dStartDiameter);
|
||
m_pXDataMap->GetAt(HCRS_EndDiameter, dEndDiameter);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t始端直径：%.2f 末端直径：%.2f"), dStartDiameter, dEndDiameter);
|
||
double dBranch1Diameter = 0.0, dBranch2Diameter = 0.0;
|
||
m_pXDataMap->GetAt(HCRS_Branch1Diameter, dBranch1Diameter);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Diameter, dBranch2Diameter);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t支管1直径：%.2f 支管2直径：%.2f"), dBranch1Diameter, dBranch2Diameter);
|
||
}
|
||
// 非圆型截面显示宽度和厚度
|
||
else
|
||
{
|
||
double dStartWidth = 0.0, dEndWidth = 0.0, dThick = 0.0;
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t始端宽度：%.2f 末端宽度：%.2f 厚度：%.2f"), dStartWidth, dEndWidth, dThick);
|
||
double dBranchWidth = 0.0, dBranchThick = 0.0;
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBranchWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Thick, dBranchThick);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t支管1宽度：%.2f 支管1厚度：%.2f"), dBranchWidth, dBranchThick);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBranchWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Thick, dBranchThick);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t支管2宽度：%.2f 支管2厚度：%.2f"), dBranchWidth, dBranchThick);
|
||
}
|
||
|
||
// 起点
|
||
AcGePoint3d pt;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, pt);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t自 点，X=%.4f\t Y=%.4f\t Z=%.4f"), pt.x, pt.y, pt.z);
|
||
|
||
// 终点
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, pt);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t到 点，X=%.4f\t Y=%.4f\t Z=%.4f"), pt.x, pt.y, pt.z);
|
||
|
||
// 支管1
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, pt);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t支管1，X=%.4f\t Y=%.4f\t Z=%.4f"), pt.x, pt.y, pt.z);
|
||
|
||
// 支管2
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, pt);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t支管2，X=%.4f\t Y=%.4f\t Z=%.4f"), pt.x, pt.y, pt.z);
|
||
}
|
||
|
||
BOOL ImpHvacCross::IsHorzAlignment() const
|
||
{
|
||
// 获得法向量
|
||
AcGeVector3d vtStart, vtBr1;
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
vtNormal = vtStart.crossProduct(vtBr1);
|
||
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
AcGeTol tolTmp;
|
||
tolTmp.setEqualVector(1);
|
||
tolTmp.setEqualPoint(1);
|
||
return vtNormal.isParallelTo(vtZAxis, tolTmp);
|
||
}
|
||
|
||
BOOL ImpHvacCross::IsVertAlignment() const
|
||
{
|
||
// 获得法向量
|
||
AcGeVector3d vtStart, vtBr1;
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
vtNormal = vtStart.crossProduct(vtBr1);
|
||
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
|
||
return vtNormal.isPerpendicularTo(vtZAxis);
|
||
}
|
||
|
||
BOOL ImpHvacCross::IsStartVertAlignment() const
|
||
{
|
||
// 获得法向量
|
||
AcGeVector3d vtStart, vtBr1;
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
|
||
return vtStart.isPerpendicularTo(vtZAxis);
|
||
}
|
||
|
||
BOOL ImpHvacCross::IsBr1VertAlignment() const
|
||
{
|
||
// 获得法向量
|
||
AcGeVector3d vtStart, vtBr1;
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
|
||
return vtStart.isParallelTo(vtZAxis);
|
||
}
|
||
|
||
BOOL ImpHvacCross::IsSingleLine() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
BOOL bSingleLine = FALSE;
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine, (int&)bSingleLine);
|
||
|
||
return bSingleLine;
|
||
}
|
||
|
||
BOOL ImpHvacCross::HasBaseLine() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
BOOL bHasBaseLIne = FALSE;
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLIne);
|
||
|
||
return bHasBaseLIne;
|
||
}
|
||
|
||
AcGeVector3d ImpHvacCross::GetSectNormal() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
// 获取四通各点位置
|
||
double dOffset = 0.0;
|
||
AcGeVector3d vtStart, vtBr1;
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
AcGeVector3d vtTmp = vtStart.crossProduct(vtBr1);
|
||
vtTmp.normalize();
|
||
return vtTmp;
|
||
}
|
||
|
||
int ImpHvacCross::AbleConnect(AcGeLine3d line1, AcGeLine3d line2,double dTick1, double dThick2) const
|
||
{
|
||
double dMaxDis = fabs(dTick1 - dThick2) / 2.0;
|
||
AcGePoint3d ptInLine1, ptInLine2;
|
||
|
||
line1.projIntersectWith(line2, normal(), ptInLine1, ptInLine2);
|
||
double dDis = ptInLine1.distanceTo(ptInLine2);
|
||
if (dDis > dMaxDis)
|
||
return 0; // 不能生成四通
|
||
else if (dDis > 0.0)
|
||
return 1; // 中心线不等高，但可以生成四通
|
||
else if (dDis == 0.0)
|
||
return 2; // 中心线等高
|
||
else
|
||
return -1; // 失败
|
||
}
|
||
|
||
BOOL ImpHvacCross::IsValidConst() const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
AcGePoint3d ptStart, ptEnd, ptBr1, ptBr2;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
|
||
AcGeVector3d vtNornal = normal();
|
||
AcGeVector3d vtStart, vtEnd, vtBr1, vtBr2;
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
|
||
double dSThick = 0, dEThick = 0, dBThick1 = 0, dBThick2 = 0;
|
||
m_pXDataMap->GetAt(HCRS_Thick, dSThick);
|
||
m_pXDataMap->GetAt(HCRS_EndThick, dEThick);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Thick, dBThick1);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Thick, dBThick2);
|
||
|
||
AecHvac::HvacCrossType eTeeType(AecHvac::eOrthoCross);
|
||
AecHvac::HvacSectType eSectType(AecHvac::eRectangular);
|
||
m_pXDataMap->GetAt(HCRS_Type, (int &)eTeeType);
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int &)eSectType);
|
||
BOOL bIsIntubCross = (eTeeType == AecHvac::eInsertCross || eTeeType == AecHvac::eInsertIntubCross
|
||
|| eTeeType == AecHvac::eArcuateIntubCross);
|
||
|
||
// 构造与四通接口方向一致的四条线
|
||
AcGePoint3d ptStartStart = ptStart - vtStart * 500;
|
||
AcGePoint3d ptStartEnd = ptStart + vtStart * 500;
|
||
AcGePoint3d ptEndStart = ptEnd - vtEnd * 500;
|
||
AcGePoint3d ptEndEnd = ptEnd + vtEnd * 500;
|
||
AcGePoint3d ptBr1Start = ptBr1 - vtBr1 * 500;
|
||
AcGePoint3d ptBr1End = ptBr1 + vtBr1 * 500;
|
||
AcGePoint3d ptBr2Start = ptBr2 - vtBr2 * 500;
|
||
AcGePoint3d ptBr2End = ptBr2 + vtBr2 * 500;
|
||
AcGeLine3d lineStart(ptStartStart, ptStartEnd);
|
||
AcGeLine3d lineEnd(ptEndStart, ptEndEnd);
|
||
AcGeLine3d lineBr1(ptBr1Start, ptBr1End);
|
||
AcGeLine3d lineBr2(ptBr2Start, ptBr2End);
|
||
|
||
AcGePlane planSta(ptStart, normal());
|
||
AcGePlane planEnd(ptEnd, normal());
|
||
AcGePoint3d ptInt;
|
||
|
||
if (!bIsIntubCross && (1e-6 < fabs(dSThick + dEThick - dBThick1 - dBThick2)
|
||
|| 1e-6 < fabs(dSThick + dBThick1 - dEThick - dBThick2)))
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
if (!lineBr1.intersectWith(lineStart, ptInt))
|
||
{
|
||
if (eSectType == eRect && bIsIntubCross &&
|
||
1 == AbleConnect(lineStart, lineBr1, dSThick, dBThick1))
|
||
{
|
||
ptBr1Start = ptBr1Start.orthoProject(planSta);
|
||
ptBr1End = ptBr1End.orthoProject(planSta);
|
||
lineBr1.set(ptBr1Start, ptBr1End);
|
||
if (!lineStart.intersectWith(lineBr1, ptInt))
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
if (!lineBr1.intersectWith(lineEnd, ptInt))
|
||
{
|
||
if (eSectType == eRect && bIsIntubCross)
|
||
{
|
||
AcGePoint3d ptStartThirdCom = ptBr1Start;
|
||
AcGePoint3d ptEndThirdCom = ptBr1End;
|
||
ptStartThirdCom = ptStartThirdCom.orthoProject(planEnd);
|
||
ptEndThirdCom = ptEndThirdCom.orthoProject(planEnd);
|
||
AcGeLine3d lineThirdCom;
|
||
lineThirdCom.set(ptStartThirdCom, ptEndThirdCom);
|
||
if (!lineEnd.intersectWith(lineThirdCom, ptInt))
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
if (!lineBr2.intersectWith(lineStart, ptInt))
|
||
{
|
||
if (eSectType == eRect && bIsIntubCross
|
||
&& 1 == AbleConnect(lineStart, lineBr2, dSThick, dBThick2))
|
||
{
|
||
ptBr2Start = ptBr2Start.orthoProject(planSta);
|
||
ptBr2End = ptBr2End.orthoProject(planSta);
|
||
lineBr2.set(ptBr2Start, ptBr2End);
|
||
if (!lineStart.intersectWith(lineBr2, ptInt))
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
if (!lineBr2.intersectWith(lineEnd, ptInt))
|
||
{
|
||
if (eSectType == eRect && bIsIntubCross)
|
||
{
|
||
AcGePoint3d ptStartFourthCom = ptBr2Start;
|
||
AcGePoint3d ptEndFourthCom = ptBr2End;
|
||
ptStartFourthCom = ptStartFourthCom.orthoProject(planEnd);
|
||
ptEndFourthCom = ptEndFourthCom.orthoProject(planEnd);
|
||
AcGeLine3d lineThirdCom;
|
||
lineThirdCom.set(ptStartFourthCom, ptEndFourthCom);
|
||
if (!lineEnd.intersectWith(lineThirdCom, ptInt))
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacCross::Draw3d(AcGiDraw &mode) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotImplementedYet;
|
||
|
||
int nColorIndexOld = mode.GetColor();
|
||
|
||
// 四通类型
|
||
AecHvac::HvacCrossType eCrossType = AecHvac::eOrthoCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eCrossType);
|
||
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
|
||
|
||
if (!IsValidConst() && eRect == eSectType)
|
||
{
|
||
DrawSpecial3d(mode);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
switch(eCrossType)
|
||
{
|
||
// 普通
|
||
case AecHvac::eOrthoCross:
|
||
DrawOrthoCross3d(mode);
|
||
break;
|
||
// 承插
|
||
case AecHvac::eInsertCross:
|
||
case AecHvac::eInsertIntubCross:
|
||
DrawInsertCross3d(mode);
|
||
break;
|
||
// 斜接
|
||
case AecHvac::eInclineCross:
|
||
DrawInclineCross3d(mode);
|
||
break;
|
||
// 圆角
|
||
case AecHvac::eArcuateCross:
|
||
case AecHvac::eArcuateIntubCross:
|
||
DrawArcuateCross3d(mode);
|
||
break;
|
||
// 直角
|
||
case AecHvac::eLinearCross:
|
||
DrawLinearCross3d(mode);
|
||
break;
|
||
// 交叉
|
||
case AecHvac::eInterCross:
|
||
DrawInterCross3d(mode);
|
||
break;
|
||
}
|
||
mode.SetColor(nColorIndexOld);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
BOOL ImpHvacCross::DrawMesh(AcGiDraw &mode,const Adesk::UInt32 rows,const Adesk::UInt32 columns,const AcGePoint3d* pVertexList) const
|
||
{
|
||
AcGePoint3dArray vertexArray;
|
||
AcArray<Adesk::Int32> faceArray;
|
||
|
||
int nV0 = 0,nV1 = 0,nV2 = 0;
|
||
int nV3= 0;
|
||
int nFaceIndex = 0;
|
||
AcGePoint3d ptFace[4];
|
||
|
||
for (int i = 0;i < rows - 1;i++)
|
||
{
|
||
for (int j = 0;j < columns - 1;j++)
|
||
{
|
||
nV0 = i * columns + j;
|
||
nV1 = nV0 + 1;
|
||
|
||
//第二行,第一个
|
||
nV2 = (i + 1) * columns + j;
|
||
|
||
nV3 = nV2 + 1;
|
||
|
||
//三角:nV0-nV1-nV2
|
||
faceArray.append(3);
|
||
faceArray.append(nV0);//v0
|
||
faceArray.append(nV1);//v1
|
||
faceArray.append(nV2);//v2
|
||
|
||
ptFace[0] = pVertexList[nV0];
|
||
ptFace[1] = pVertexList[nV1];
|
||
ptFace[2] = pVertexList[nV2];
|
||
ptFace[3] = ptFace[0];
|
||
//mode.DrawFace(ptFace);
|
||
|
||
//三角:nV2-nV1-nV3
|
||
faceArray.append(3);
|
||
faceArray.append(nV2);//v2
|
||
faceArray.append(nV1);//v1
|
||
faceArray.append(nV3);//v3
|
||
|
||
ptFace[0] = pVertexList[nV2];
|
||
ptFace[1] = pVertexList[nV1];
|
||
ptFace[2] = pVertexList[nV3];
|
||
ptFace[3] = ptFace[0];
|
||
//mode.DrawFace(ptFace);
|
||
}
|
||
}
|
||
|
||
if (!faceArray.isEmpty())
|
||
{
|
||
int nIndex = 0;
|
||
for (int i = 0;i < rows;i++)
|
||
{
|
||
for (int j = 0;j < columns;j++)
|
||
{
|
||
nIndex = i * columns + j;
|
||
vertexArray.append(pVertexList[nIndex]);
|
||
}
|
||
}
|
||
|
||
AcDbSubDMesh* pSubMesh = new AcDbSubDMesh;
|
||
if ( Acad::eOk == pSubMesh->setSubDMesh(vertexArray,faceArray,0) )
|
||
{
|
||
mode.DrawEntity(pSubMesh);
|
||
m_ar3DDrableBufPtrs_.append(pSubMesh);
|
||
|
||
//有时候失败?
|
||
/*Acad::ErrorStatus es;
|
||
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
||
if ( Acad::eOk == (es = pSubMesh->convertToSolid(false,false,pSolid) ) )
|
||
{
|
||
mode.DrawEntity(pSolid);
|
||
}
|
||
delete pSubMesh;
|
||
*/
|
||
return TRUE;
|
||
}
|
||
delete pSubMesh;
|
||
}
|
||
|
||
mode.DrawMeshS(rows,columns,pVertexList,false);
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL ImpHvacCross::DrawShell(AcGiDraw &mode,const Adesk::UInt32 nbVertex,const AcGePoint3d* pVertexList,const Adesk::UInt32 faceListSize,const Adesk::Int32* pFaceList) const
|
||
{
|
||
AcGePoint3dArray vertexArray;
|
||
AcArray<Adesk::Int32> faceArray;
|
||
|
||
for(int i = 0;i < nbVertex;i++)
|
||
{
|
||
vertexArray.append(pVertexList[i]);
|
||
}
|
||
for (int j = 0;j < faceListSize;j++)
|
||
{
|
||
faceArray.append(pFaceList[j]);
|
||
}
|
||
|
||
AcDbSubDMesh* pSubMesh = new AcDbSubDMesh;
|
||
if ( Acad::eOk == pSubMesh->setSubDMesh(vertexArray,faceArray,0) )
|
||
{
|
||
mode.DrawEntity(pSubMesh);
|
||
m_ar3DDrableBufPtrs_.append(pSubMesh);
|
||
|
||
//有时候失败?
|
||
/*Acad::ErrorStatus es;
|
||
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
||
if ( Acad::eOk == (es = pSubMesh->convertToSolid(false,false,pSolid) ) )
|
||
{
|
||
mode.DrawEntity(pSolid);
|
||
}
|
||
delete pSubMesh;
|
||
*/
|
||
return TRUE;
|
||
}
|
||
delete pSubMesh;
|
||
|
||
mode.DrawShell(nbVertex,pVertexList,faceListSize,pFaceList);
|
||
return FALSE;
|
||
}
|
||
|
||
void ImpHvacCross::Move3DBuffer(AcDbVoidPtrArray& ar3DBuffer) const
|
||
{
|
||
if (!m_ar3DDrableBufPtrs_.isEmpty())
|
||
{
|
||
ar3DBuffer.append(m_ar3DDrableBufPtrs_);
|
||
m_ar3DDrableBufPtrs_.removeAll();
|
||
}
|
||
}
|
||
|
||
bool ImpHvacCross::Has3DBuffer() const
|
||
{
|
||
return !m_ar3DDrableBufPtrs_.isEmpty();
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacCross::Draw2d(AcGiDraw &mode) const
|
||
{
|
||
if (m_pXDataMap == NULL)
|
||
{
|
||
return Acad::eNotImplementedYet;
|
||
}
|
||
|
||
AecComplexCurve cplCurve;
|
||
MakeCurves(cplCurve);
|
||
|
||
AecComplexCurveDraw edage;
|
||
edage.SetEdage(cplCurve);
|
||
|
||
BOOL bWeight = FALSE;
|
||
|
||
AcDbObjectId idReal = m_idDoubleLayer;
|
||
AcDbObjectId idDash = m_idDashLayer;
|
||
AcDbObjectId idCent = m_idCenterLayer;
|
||
|
||
edage.Draw2d(mode,idReal,idDash,idCent,NULL,bWeight,FALSE);
|
||
|
||
AecComplexCurve cplCen;
|
||
GetCurvesInSide(cplCen);
|
||
|
||
edage.SetEdage(cplCen);
|
||
edage.Draw2d(mode,idReal,idDash,idCent,NULL,bWeight,FALSE);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
BOOL ImpHvacCross::MakeCurves(AecComplexCurve& cplCurve) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 四通类型
|
||
AecHvac::HvacCrossType eCrossType = AecHvac::eOrthoCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eCrossType);
|
||
|
||
int nIsSingleLine = 0;
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine, nIsSingleLine);
|
||
int nType = 0;
|
||
//单线形式直接return
|
||
if (1 == nIsSingleLine)
|
||
{
|
||
return FALSE;
|
||
}
|
||
switch(eCrossType)
|
||
{
|
||
// 普通
|
||
case AecHvac::eOrthoCross:
|
||
MakeOrthoCross2dCurves(cplCurve,nType);
|
||
break;
|
||
// 承插
|
||
case AecHvac::eInsertCross:
|
||
MakeInsertCross2dCurves(cplCurve,nType);
|
||
break;
|
||
// 承插(插管式)
|
||
case AecHvac::eInsertIntubCross:
|
||
MakeInsertCross2dCurves(cplCurve,nType, TRUE);
|
||
break;
|
||
// 斜接
|
||
case AecHvac::eInclineCross:
|
||
MakeInclineCross2dCurves(cplCurve,nType);
|
||
break;
|
||
// 圆角
|
||
case AecHvac::eArcuateCross:
|
||
MakeArcuateCross2dCurves(cplCurve,nType);
|
||
break;
|
||
// 圆角(插管)
|
||
case AecHvac::eArcuateIntubCross:
|
||
MakeArcuateCross2dCurves(cplCurve,nType, TRUE);
|
||
break;
|
||
// 直角
|
||
case AecHvac::eLinearCross:
|
||
MakeLinearCross2dCurves(cplCurve,nType);
|
||
break;
|
||
// 交叉
|
||
case AecHvac::eInterCross:
|
||
MakeInterCross2dCurves(cplCurve,nType);
|
||
break;
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
BOOL ImpHvacCross::GetCurvesInSide(AecComplexCurve& compCurve) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 四通类型
|
||
AecHvac::HvacCrossType eCrossType = AecHvac::eOrthoCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eCrossType);
|
||
int nType = 1;
|
||
switch(eCrossType)
|
||
{
|
||
// 普通
|
||
case AecHvac::eOrthoCross:
|
||
MakeOrthoCross2dCurves(compCurve,nType);
|
||
break;
|
||
// 承插
|
||
case AecHvac::eInsertCross:
|
||
case AecHvac::eInsertIntubCross:
|
||
MakeInsertCross2dCurves(compCurve,nType);
|
||
break;
|
||
// 斜接
|
||
case AecHvac::eInclineCross:
|
||
MakeInclineCross2dCurves(compCurve,nType);
|
||
break;
|
||
// 圆角
|
||
case AecHvac::eArcuateCross:
|
||
case AecHvac::eArcuateIntubCross:
|
||
MakeArcuateCross2dCurves(compCurve,nType);
|
||
break;
|
||
// 直角
|
||
case AecHvac::eLinearCross:
|
||
MakeLinearCross2dCurves(compCurve,nType);
|
||
break;
|
||
// 交叉
|
||
case AecHvac::eInterCross:
|
||
MakeInterCross2dCurves(compCurve,nType);
|
||
break;
|
||
}
|
||
return compCurve.length() > 0;
|
||
}
|
||
|
||
AecEqui::Position ImpHvacCross::ExplainGripIndex(int nIndex) const
|
||
{
|
||
AecEqui::Position ePos = AecEqui::eStart;
|
||
switch(nIndex)
|
||
{
|
||
case 0:
|
||
ePos = AecEqui::eStart;
|
||
break;
|
||
case 1:
|
||
ePos = AecEqui::eEnd;
|
||
break;
|
||
case 2:
|
||
ePos = AecEqui::eBr1;
|
||
break;
|
||
case 3:
|
||
ePos = AecEqui::eBr2;
|
||
break;
|
||
case 4:
|
||
ePos = AecEqui::eCommand0;
|
||
break;
|
||
case 5:
|
||
ePos = AecEqui::eCommand1;
|
||
break;
|
||
case 6:
|
||
ePos = AecEqui::eCommand2;
|
||
break;
|
||
case 7:
|
||
ePos = AecEqui::eCommand3;
|
||
}
|
||
return ePos;
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacCross::transformBy(const AcGeMatrix3d& xform)
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotApplicable;
|
||
|
||
// 获取四通各点位置
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
|
||
// 变换位置
|
||
ptStart.transformBy(xform);
|
||
ptEnd.transformBy(xform);
|
||
ptBr1.transformBy(xform);
|
||
ptBr2.transformBy(xform);
|
||
|
||
vtStart.transformBy(xform);
|
||
vtEnd.transformBy(xform);
|
||
vtBr1.transformBy(xform);
|
||
vtBr2.transformBy(xform);
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtBr1.normalize();
|
||
vtBr2.normalize();
|
||
|
||
// 设置尺寸
|
||
double dScale = xform.scale();
|
||
double dStaWidth(0.0), dEndWidth(0.), dThick(0.0), dBran1Width(0.0),
|
||
dBran2Width(0.0), dBran1Thick(0.0), dBran2Thick(0.0);
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dStaWidth);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBran1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBran2Width);
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Thick, dBran1Thick);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Thick, dBran1Thick);
|
||
|
||
dStaWidth *= dScale;
|
||
dEndWidth *= dScale;
|
||
dBran1Width *= dScale;
|
||
dBran2Width *= dScale;
|
||
dThick *= dScale;
|
||
dBran1Thick *= dScale;
|
||
dBran2Thick *= dScale;
|
||
|
||
m_pXDataMap->SetAt(HCRS_StartWidth, dStaWidth);
|
||
m_pXDataMap->SetAt(HCRS_EndWidth, dEndWidth);
|
||
m_pXDataMap->SetAt(HCRS_Branch1Width, dBran1Width);
|
||
m_pXDataMap->SetAt(HCRS_Branch2Width, dBran2Width);
|
||
m_pXDataMap->SetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->SetAt(HCRS_Branch1Thick, dBran1Thick);
|
||
m_pXDataMap->SetAt(HCRS_Branch2Thick, dBran1Thick);
|
||
|
||
// 更新点
|
||
m_pXDataMap->SetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->SetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->SetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->SetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->SetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->SetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->SetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->SetAt(HCRS_BranchDir2, vtBr2);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacCross::getStretchPoints(AcGePoint3dArray& stretchPoints) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotApplicable;
|
||
|
||
// 取得位置点
|
||
AcGePoint3d ptStart, ptEnd, ptBr1, ptBr2;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
|
||
stretchPoints.append(ptStart);
|
||
stretchPoints.append(ptEnd);
|
||
stretchPoints.append(ptBr1);
|
||
stretchPoints.append(ptBr2);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacCross::getGripPoints(AcGePoint3dArray& gripPoints,
|
||
AcDbIntArray& osnapModes,
|
||
AcDbIntArray& geomIds) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotApplicable;
|
||
|
||
// 获取四通各点位置
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
|
||
//夹点
|
||
gripPoints.append(ptStart);
|
||
gripPoints.append(ptEnd);
|
||
gripPoints.append(ptBr1);
|
||
gripPoints.append(ptBr2);
|
||
|
||
|
||
//增加4个命令夹点
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtBr1.normalize();
|
||
vtBr2.normalize();
|
||
|
||
gripPoints.append(ptStart + vtStart * g_dCmdOff); //cmd0
|
||
gripPoints.append(ptEnd + vtEnd * g_dCmdOff); //cmd1
|
||
gripPoints.append(ptBr1 + vtBr1 * g_dCmdOff); //cmd2
|
||
gripPoints.append(ptBr2 + vtBr2 * g_dCmdOff); //cmd3
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacCross::getOsnapPoints(AcDb::OsnapMode osnapMode,
|
||
INT_PTR gsSelectionMark,
|
||
const AcGePoint3d& pickPoint,
|
||
const AcGePoint3d& lastPoint,
|
||
const AcGeMatrix3d& viewXform,
|
||
AcGePoint3dArray& snapPoints,
|
||
AcDbIntArray& geomIds) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotApplicable;
|
||
|
||
// 获取四通各点位置
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
|
||
// 根据捕捉模式处理
|
||
switch(osnapMode)
|
||
{
|
||
case AcDb::kOsModeEnd:
|
||
snapPoints.append(ptStart);
|
||
snapPoints.append(ptEnd);
|
||
snapPoints.append(ptBr1);
|
||
snapPoints.append(ptBr2);
|
||
break;
|
||
case AcDb::kOsModeMid:
|
||
break;
|
||
case AcDb::kOsModeCen:
|
||
break;
|
||
case AcDb::kOsModePerp:
|
||
break;
|
||
case AcDb::kOsModeNear:
|
||
break;
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
|
||
// 7━━━━━6
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// 0━━━━┛ ┃ ┗━━━━5
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// ━━━━━━━━━━━━━━━━
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// 1━━━━┓ ┃ ┏━━━━4
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// 2━━━━━3
|
||
BOOL ImpHvacCross::DrawSpecial3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
AcGePoint3dArray arptUp, arptDown;
|
||
if (!GetInterfaceKeyPt(arptUp, arptDown))
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
// 上面
|
||
AcGePoint3d ptArUpPoly[4] = {arptUp[0], arptUp[1], arptUp[5], arptUp[4]};
|
||
// 下面
|
||
AcGePoint3d ptArDownPoly[4] = {arptDown[0], arptDown[1], arptDown[5], arptDown[4]};
|
||
// 支管1左侧
|
||
AcGePoint3d ptArBranLeft1[4] = {arptUp[1], arptDown[1], arptUp[2], arptDown[2]};
|
||
// 支管1右侧
|
||
AcGePoint3d ptArBranRight1[4] = {arptUp[3], arptDown[3], arptUp[4], arptDown[4]};
|
||
// 支管1上
|
||
AcGePoint3d ptArBranUp1[4] = {arptUp[1], arptUp[2], arptUp[4], arptUp[3]};
|
||
// 支管1下
|
||
AcGePoint3d ptArBranDown1[4] = {arptDown[1], arptDown[2], arptDown[4], arptDown[3]};
|
||
// 支管2左侧
|
||
AcGePoint3d ptArBranLeft2[4] = {arptUp[5], arptDown[5], arptUp[6], arptDown[6]};
|
||
// 支管2右侧
|
||
AcGePoint3d ptArBranRight2[4] = {arptUp[7], arptDown[7], arptUp[0], arptDown[0]};
|
||
// 支管2上
|
||
AcGePoint3d ptArBranUp2[4] = {arptUp[5], arptUp[6], arptUp[0], arptUp[7]};
|
||
// 支管2下
|
||
AcGePoint3d ptArBranDown2[4] = {arptDown[5], arptDown[6], arptDown[0], arptDown[7]};
|
||
|
||
DrawMesh(mode,2, 2, ptArUpPoly);
|
||
DrawMesh(mode,2, 2, ptArDownPoly);
|
||
DrawMesh(mode,2, 2, ptArBranLeft1);
|
||
DrawMesh(mode,2, 2, ptArBranRight1);
|
||
DrawMesh(mode,2, 2, ptArBranUp1);
|
||
DrawMesh(mode,2, 2, ptArBranDown1);
|
||
DrawMesh(mode,2, 2, ptArBranLeft2);
|
||
DrawMesh(mode,2, 2, ptArBranRight2);
|
||
DrawMesh(mode,2, 2, ptArBranUp2);
|
||
DrawMesh(mode,2, 2, ptArBranDown2);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
//3维模型
|
||
void ImpHvacCross::DrawOrthoCross3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
//方截面
|
||
if (eSectType == eRect)
|
||
{
|
||
double dThick = 200.0;
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
AcGePoint3dArray arPts,arPtsU,arPtsD,arptSides;
|
||
GetCrossPts(arPts,FALSE,TRUE);
|
||
AcGeMatrix3d mat;
|
||
vtNor.normalize();
|
||
vtNor *= dThick * 0.5;
|
||
mat.setToTranslation(vtNor);
|
||
//从第8个点开始把所有点向下偏移半个厚度
|
||
for (int i = 8; i < arPts.length(); i++)
|
||
{
|
||
arPtsU.append(arPts[i].transformBy(mat));
|
||
}
|
||
vtNor.normalize();
|
||
vtNor *= -dThick;
|
||
mat.setToTranslation(vtNor);
|
||
//从第8个点开始把所有点向上偏移半个厚度
|
||
for (i = 8; i < arPts.length(); i++)
|
||
{
|
||
arPtsD.append(arPts[i].transformBy(mat));
|
||
}
|
||
//开始面
|
||
arptSides.append(arPtsU[0]);
|
||
arptSides.append(arPtsU[11]);
|
||
arptSides.append(arPtsD[11]);
|
||
arptSides.append(arPtsD[0]);
|
||
arptSides.append(arPtsU[0]);
|
||
//交点面S
|
||
arptSides.append(arPtsU[1]);
|
||
arptSides.append(arPtsU[10]);
|
||
arptSides.append(arPtsD[10]);
|
||
arptSides.append(arPtsD[1]);
|
||
arptSides.append(arPtsU[1]);
|
||
//交点面E
|
||
arptSides.append(arPtsU[4]);
|
||
arptSides.append(arPtsU[7]);
|
||
arptSides.append(arPtsD[7]);
|
||
arptSides.append(arPtsD[4]);
|
||
arptSides.append(arPtsU[4]);
|
||
//末点面
|
||
arptSides.append(arPtsU[5]);
|
||
arptSides.append(arPtsU[6]);
|
||
arptSides.append(arPtsD[6]);
|
||
arptSides.append(arPtsD[5]);
|
||
arptSides.append(arPtsU[5]);
|
||
DrawMesh(mode,4, 5, arptSides.asArrayPtr());
|
||
|
||
arptSides.setLogicalLength(0);
|
||
//Br1面
|
||
arptSides.append(arPtsU[2]);
|
||
arptSides.append(arPtsU[3]);
|
||
arptSides.append(arPtsD[3]);
|
||
arptSides.append(arPtsD[2]);
|
||
arptSides.append(arPtsU[2]);
|
||
//交点面Br1
|
||
arptSides.append(arPtsU[1]);
|
||
arptSides.append(arPtsU[4]);
|
||
arptSides.append(arPtsD[4]);
|
||
arptSides.append(arPtsD[1]);
|
||
arptSides.append(arPtsU[1]);
|
||
DrawMesh(mode,2, 5, arptSides.asArrayPtr());
|
||
|
||
arptSides.setLogicalLength(0);
|
||
//Br2面
|
||
arptSides.append(arPtsU[8]);
|
||
arptSides.append(arPtsU[9]);
|
||
arptSides.append(arPtsD[9]);
|
||
arptSides.append(arPtsD[8]);
|
||
arptSides.append(arPtsU[8]);
|
||
//交点面Br2
|
||
arptSides.append(arPtsU[7]);
|
||
arptSides.append(arPtsU[10]);
|
||
arptSides.append(arPtsD[10]);
|
||
arptSides.append(arPtsD[7]);
|
||
arptSides.append(arPtsU[7]);
|
||
DrawMesh(mode,2, 5, arptSides.asArrayPtr());
|
||
}
|
||
//圆截面
|
||
else if (eSectType == eCircle)
|
||
{
|
||
AcGePoint3dArray arPts,arPtsU,arPtsD,arptSides;
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
double dSWidth = 300.0, dEWidth = 300.0, dThick = 200.0, dBr1Width = 300.0, dBr2Width = 300.0;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBr2Width);
|
||
|
||
double dMinDiffAng = TAuxTools::GetMinDiffAngle();
|
||
//按照90°弯头分成nSect1个圆截面，每个圆截面分成nSect个点
|
||
int nSect = int(PI * 2 / dMinDiffAng);
|
||
AcGeVector3d vtNor;
|
||
vtNor = vtStart.crossProduct(vtBr1);
|
||
vtNor.normalize();
|
||
//Start到End点
|
||
AcGePoint3d pt, ptInter;
|
||
pt = ptStart + vtNor * dSWidth * 0.5;
|
||
for (int i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtStart,ptStart));
|
||
}
|
||
pt = ptEnd + vtNor * dEWidth * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtStart,ptEnd));
|
||
}
|
||
DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());
|
||
|
||
//Br1
|
||
arptSides.setLogicalLength(0);
|
||
pt = ptBr1 + vtNor * dBr1Width * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtBr1,ptBr1));
|
||
}
|
||
GetIntersectWith(ptStart, ptBr1, vtStart, vtBr1, ptInter);
|
||
pt = ptInter + vtNor * dBr1Width * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtBr1,ptInter));
|
||
}
|
||
|
||
DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());
|
||
//Br2
|
||
arptSides.setLogicalLength(0);
|
||
pt = ptBr2 + vtNor * dBr2Width * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtBr2,ptBr2));
|
||
}
|
||
GetIntersectWith(ptStart, ptBr2, vtStart, vtBr2, ptInter);
|
||
pt = ptInter + vtNor * dBr2Width * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtBr2,ptInter));
|
||
}
|
||
DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());
|
||
}
|
||
}
|
||
|
||
// 承插
|
||
void ImpHvacCross::DrawInsertCross3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
|
||
AcGeVector3d vtStart = AcGeVector3d::kIdentity;
|
||
AcGeVector3d vtBr1 = AcGeVector3d::kIdentity;
|
||
AcGeVector3d vtBr2 = AcGeVector3d::kIdentity;
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
|
||
AcGeVector3d vtEnd = AcGeVector3d::kIdentity;
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
|
||
// 矩形口
|
||
if (eSectType == eRect)
|
||
{
|
||
double dThick = 200.0;
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
|
||
double dThickSub = 200.0;
|
||
if (!m_pXDataMap->GetAt(KEY_EndThick, dThickSub))
|
||
{
|
||
dThickSub = dThick;
|
||
}
|
||
|
||
double dBrThick1 = 0.0;
|
||
double dBrThick2 = 0.0;
|
||
m_pXDataMap->GetAt(HCRS_Branch1Thick, dBrThick1);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Thick, dBrThick2);
|
||
AcGePoint3d ptSta, ptBran1, ptBran2;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptSta);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBran1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBran2);
|
||
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
AcGePlane planSta(ptSta, vtNor);
|
||
|
||
AcGePoint3d ptEnd;
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
AcGePlane planEnd(ptEnd, vtNor);
|
||
|
||
AcGePlane planBr1(ptBran1, vtNor);
|
||
AcGePlane planBr2(ptBran2, vtNor);
|
||
|
||
AcGePoint3dArray arPts,arPtsU,arPtsD,arptSides;
|
||
|
||
GetCrossPts(arPts,FALSE,TRUE);
|
||
|
||
// ?÷ì?μ?
|
||
AcGePoint3dArray arPtsMajor, arPtsBr;
|
||
arPtsMajor.append(arPts[8]);
|
||
AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
|
||
ptTmp = arPts[8] - vtStart * 50.0;
|
||
arPtsMajor.append(ptTmp);
|
||
ptTmp = arPts[12];
|
||
ptTmp = ptTmp.orthoProject(planSta);
|
||
arPtsMajor.append(ptTmp);
|
||
arPtsMajor.append(arPts[13]);
|
||
arPtsMajor.append(arPts[14]);
|
||
ptTmp = arPts[15];
|
||
ptTmp = ptTmp.orthoProject(planSta);
|
||
arPtsMajor.append(ptTmp);
|
||
ptTmp = arPts[19] - vtStart * 50.0;
|
||
arPtsMajor.append(ptTmp);
|
||
arPtsMajor.append(arPts[19]);
|
||
|
||
// ·??§μ?
|
||
arPtsBr.append(arPts[11]);
|
||
ptTmp = arPts[11] - vtBr1 * 50.0;
|
||
arPtsBr.append(ptTmp);
|
||
arPtsBr.append(arPts[12]);
|
||
ptTmp = arPts[8] - vtStart * 50.0;
|
||
ptTmp = ptTmp.orthoProject(planBr1);
|
||
arPtsBr.append(ptTmp);
|
||
ptTmp = arPts[10] - vtBr1 * 50.0;
|
||
arPtsBr.append(ptTmp);
|
||
arPtsBr.append(arPts[10]);
|
||
|
||
arPtsBr.append(arPts[17]);
|
||
ptTmp = arPts[17] - vtBr2 * 50.0;
|
||
arPtsBr.append(ptTmp);
|
||
ptTmp = arPts[19] - vtStart * 50.0;
|
||
ptTmp = ptTmp.orthoProject(planBr2);
|
||
arPtsBr.append(ptTmp);
|
||
arPtsBr.append(arPts[15]);
|
||
ptTmp = arPts[16] - vtBr2 * 50.0;
|
||
arPtsBr.append(ptTmp);
|
||
arPtsBr.append(arPts[16]);
|
||
|
||
AcGeMatrix3d mat;
|
||
vtNor.normalize();
|
||
vtNor *= dThick * 0.5;
|
||
mat.setToTranslation(vtNor);
|
||
|
||
AcGeMatrix3d matSub;
|
||
vtNor.normalize();
|
||
vtNor *= dThickSub * 0.5;
|
||
matSub.setToTranslation(vtNor);
|
||
|
||
int i = 0;
|
||
AcGePoint3dArray arPtsMajorU, arPtsMajorD;
|
||
for (i = 0; i < arPtsMajor.length(); i++)
|
||
{
|
||
if (2 == i || 5 == i || 3 == i || 4 == i)
|
||
{
|
||
arPtsMajor[i] = arPtsMajor[i].orthoProject(planEnd);
|
||
arPtsMajorU.append(arPtsMajor[i].transformBy(matSub));
|
||
}
|
||
else
|
||
{
|
||
arPtsMajorU.append(arPtsMajor[i].transformBy(mat));
|
||
}
|
||
|
||
}
|
||
|
||
vtNor.normalize();
|
||
vtNor *= -dThick;
|
||
mat.setToTranslation(vtNor);
|
||
|
||
vtNor.normalize();
|
||
vtNor *= dThickSub;
|
||
matSub.setToTranslation(vtNor);
|
||
|
||
for (i = 0; i < arPtsMajor.length(); i++)
|
||
{
|
||
if (2 == i || 5 == i || 3 == i || 4 == i)
|
||
{
|
||
arPtsMajorD.append(arPtsMajor[i].transformBy(matSub));
|
||
}
|
||
else
|
||
{
|
||
arPtsMajorD.append(arPtsMajor[i].transformBy(mat));
|
||
}
|
||
}
|
||
|
||
arptSides.append(arPtsMajorU[0]);
|
||
arptSides.append(arPtsMajorU[7]);
|
||
arptSides.append(arPtsMajorD[7]);
|
||
arptSides.append(arPtsMajorD[0]);
|
||
arptSides.append(arPtsMajorU[0]);
|
||
|
||
arptSides.append(arPtsMajorU[1]);
|
||
arptSides.append(arPtsMajorU[6]);
|
||
arptSides.append(arPtsMajorD[6]);
|
||
arptSides.append(arPtsMajorD[1]);
|
||
arptSides.append(arPtsMajorU[1]);
|
||
|
||
arptSides.append(arPtsMajorU[2]);
|
||
arptSides.append(arPtsMajorU[5]);
|
||
arptSides.append(arPtsMajorD[5]);
|
||
arptSides.append(arPtsMajorD[2]);
|
||
arptSides.append(arPtsMajorU[2]);
|
||
|
||
arptSides.append(arPtsMajorU[3]);
|
||
arptSides.append(arPtsMajorU[4]);
|
||
arptSides.append(arPtsMajorD[4]);
|
||
arptSides.append(arPtsMajorD[3]);
|
||
arptSides.append(arPtsMajorU[3]);
|
||
|
||
DrawMesh(mode,4, 5, arptSides.asArrayPtr());
|
||
arptSides.setLogicalLength(0);
|
||
|
||
AcGePoint3dArray arPtBrU, arPtBrD;
|
||
vtNor.normalize();
|
||
vtNor *= dBrThick1 * 0.5;
|
||
mat.setToTranslation(vtNor);
|
||
for (i = 0; i < 6; i++)
|
||
{
|
||
arPtBrU.append(arPtsBr[i].transformBy(mat));
|
||
}
|
||
vtNor.normalize();
|
||
vtNor *= -dBrThick1;
|
||
mat.setToTranslation(vtNor);
|
||
for (i = 0; i < 6; i++)
|
||
{
|
||
arPtBrD.append(arPtsBr[i].transformBy(mat));
|
||
}
|
||
vtNor.normalize();
|
||
vtNor *= dBrThick2 * 0.5;
|
||
mat.setToTranslation(vtNor);
|
||
for (i = 6; i < 12; i++)
|
||
{
|
||
arPtBrU.append(arPtsBr[i].transformBy(mat));
|
||
}
|
||
vtNor.normalize();
|
||
vtNor *= -dBrThick2;
|
||
mat.setToTranslation(vtNor);
|
||
for (i = 6; i < 12; i++)
|
||
{
|
||
arPtBrD.append(arPtsBr[i].transformBy(mat));
|
||
}
|
||
|
||
arptSides.append(arPtBrU[0]);
|
||
arptSides.append(arPtBrU[5]);
|
||
arptSides.append(arPtBrD[5]);
|
||
arptSides.append(arPtBrD[0]);
|
||
arptSides.append(arPtBrU[0]);
|
||
|
||
arptSides.append(arPtBrU[1]);
|
||
arptSides.append(arPtBrU[4]);
|
||
arptSides.append(arPtBrD[4]);
|
||
arptSides.append(arPtBrD[1]);
|
||
arptSides.append(arPtBrU[1]);
|
||
|
||
arptSides.append(arPtBrU[2]);
|
||
arptSides.append(arPtBrU[3]);
|
||
arptSides.append(arPtBrD[3]);
|
||
arptSides.append(arPtBrD[2]);
|
||
arptSides.append(arPtBrU[2]);
|
||
DrawMesh(mode,3, 5, arptSides.asArrayPtr());
|
||
|
||
arptSides.setLogicalLength(0);
|
||
|
||
arptSides.append(arPtBrU[6]);
|
||
arptSides.append(arPtBrU[11]);
|
||
arptSides.append(arPtBrD[11]);
|
||
arptSides.append(arPtBrD[6]);
|
||
arptSides.append(arPtBrU[6]);
|
||
|
||
arptSides.append(arPtBrU[7]);
|
||
arptSides.append(arPtBrU[10]);
|
||
arptSides.append(arPtBrD[10]);
|
||
arptSides.append(arPtBrD[7]);
|
||
arptSides.append(arPtBrU[7]);
|
||
|
||
arptSides.append(arPtBrU[8]);
|
||
arptSides.append(arPtBrU[9]);
|
||
arptSides.append(arPtBrD[9]);
|
||
arptSides.append(arPtBrD[8]);
|
||
arptSides.append(arPtBrU[8]);
|
||
|
||
DrawMesh(mode,3, 5, arptSides.asArrayPtr());
|
||
}
|
||
if (eSectType == eCircle)
|
||
{
|
||
DrawOrthoCross3d(mode);
|
||
}
|
||
}
|
||
|
||
// 斜接
|
||
void ImpHvacCross::DrawInclineCross3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
|
||
if (eSectType == eRect)
|
||
{
|
||
// 矩形口三维画法与圆角类型类似，
|
||
// 稍作修改后直接调用圆角类型的三维绘制函数
|
||
DrawArcuateCross3d(mode);
|
||
}
|
||
else if (eSectType == eCircle)
|
||
{
|
||
AcGePoint3dArray arPts;
|
||
if (!GetInclineCirPts(arPts))
|
||
return;
|
||
|
||
AcGePoint3dArray arPtsU,arPtsD,arptSides;
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
double dSWidth = 300.0, dEWidth = 300.0, dThick = 200.0, dBr1Width = 300.0, dBr2Width = 300.0;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBr2Width);
|
||
|
||
double dMinDiffAng = TAuxTools::GetMinDiffAngle();
|
||
//按照90°弯头分成nSect1个圆截面，每个圆截面分成nSect个点
|
||
int nSect = int(PI * 2 / dMinDiffAng);
|
||
AcGeVector3d vtNor;
|
||
vtNor = vtStart.crossProduct(vtBr1);
|
||
vtNor.normalize();
|
||
// 主管
|
||
AcGeVector3d vtM = arPts[12] - arPts[15];
|
||
vtM.normalize();
|
||
AcGePoint3d pt = arPts[12] + vtNor * dSWidth * 0.5;
|
||
for (int i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtM,arPts[12]));
|
||
}
|
||
pt = arPts[15] + vtNor * dEWidth * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtM,arPts[15]));
|
||
}
|
||
DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());
|
||
|
||
// 主管直边
|
||
arptSides.setLogicalLength(0);
|
||
pt = arPts[0] + vtNor * dSWidth * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtStart,arPts[0]));
|
||
}
|
||
pt = arPts[12] + vtNor * dSWidth * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtStart,arPts[12]));
|
||
}
|
||
DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());
|
||
|
||
arptSides.setLogicalLength(0);
|
||
pt = arPts[3] + vtNor * dEWidth * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtEnd,arPts[3]));
|
||
}
|
||
pt = arPts[15] + vtNor * dEWidth * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtEnd,arPts[15]));
|
||
}
|
||
DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());
|
||
|
||
|
||
|
||
// 支管2
|
||
arptSides.setLogicalLength(0);
|
||
pt = arPts[21] + vtNor * dBr2Width * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtBr2,arPts[21]));
|
||
}
|
||
AcGeVector3d vtD = arPts[25] - arPts[23];
|
||
vtD.normalize();
|
||
AcGePoint3d ptTmp = arPts[23] + vtD * arPts[14].distanceTo(arPts[22]);
|
||
AcGeVector3d vtTmp = arPts[14] - ptTmp;
|
||
vtTmp.normalize();
|
||
ptTmp = ptTmp + vtTmp * arPts[14].distanceTo(ptTmp) / 2.0;
|
||
|
||
pt = ptTmp + vtNor * arPts[14].distanceTo(ptTmp);
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng, vtBr2, ptTmp));
|
||
}
|
||
DrawMesh(mode,2, nSect + 1, arptSides.asArrayPtr());
|
||
|
||
// 支管2直边
|
||
arptSides.setLogicalLength(0);
|
||
pt = arPts[9] + vtNor * dBr2Width * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtBr2,arPts[9]));
|
||
}
|
||
pt = arPts[21] + vtNor * dBr2Width * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtBr2,arPts[21]));
|
||
}
|
||
DrawMesh(mode,2, nSect + 1, arptSides.asArrayPtr());
|
||
|
||
// 支管1
|
||
arptSides.setLogicalLength(0);
|
||
pt = arPts[18] + vtNor * dBr1Width * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtBr1,arPts[18]));
|
||
}
|
||
vtD = arPts[24] - arPts[19];
|
||
vtD.normalize();
|
||
ptTmp = arPts[19] + vtD * arPts[13].distanceTo(arPts[20]);
|
||
vtTmp = arPts[13] - ptTmp;
|
||
vtTmp.normalize();
|
||
ptTmp = ptTmp + vtTmp * arPts[13].distanceTo(ptTmp) / 2.0;
|
||
pt = ptTmp + vtNor * arPts[13].distanceTo(ptTmp);
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng, vtBr1, ptTmp));
|
||
}
|
||
DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());
|
||
|
||
// 支管1直边
|
||
arptSides.setLogicalLength(0);
|
||
pt = arPts[6] + vtNor * dBr1Width * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtBr1,arPts[6]));
|
||
}
|
||
pt = arPts[18] + vtNor * dBr1Width * 0.5;
|
||
for (i = 0; i <= nSect; i++)
|
||
{
|
||
arptSides.append(pt.rotateBy(dMinDiffAng,vtBr1,arPts[18]));
|
||
}
|
||
DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());
|
||
}
|
||
}
|
||
|
||
// 圆角
|
||
void ImpHvacCross::DrawArcuateCross3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dThick = 200.0;
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
|
||
double dThickSub = 200.0;
|
||
if (!m_pXDataMap->GetAt(KEY_EndThick, dThickSub))
|
||
{
|
||
dThickSub = dThick;
|
||
}
|
||
|
||
double dBran1Thick = 200.0, dBran2Thick = 200.0;
|
||
m_pXDataMap->GetAt(HCRS_Branch1Thick, dBran1Thick);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Thick, dBran2Thick);
|
||
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
AcGePoint3dArray arPts, arPts1, arPts2, arPts3, arPts4, arPtsU, arPtsD, arptSides;
|
||
GetArcuateCrossPts(arPts);
|
||
|
||
AecHvac::HvacCrossType eType = AecHvac::eArcuateCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eType);
|
||
double dMinDiffAng = TAuxTools::GetMinDiffAngle();
|
||
|
||
if (eType == AecHvac::eArcuateIntubCross) // 插管圆角
|
||
{
|
||
AcGePoint3d ptSta, ptBr1, ptBr2;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptSta);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
|
||
AcGePlane planSta(ptSta, vtNor);
|
||
|
||
AcGePoint3d ptEnd;
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
AcGePlane planEnd(ptEnd, vtNor);
|
||
|
||
AcGePlane planBr1(ptBr1, vtNor);
|
||
AcGePlane planBr2(ptBr2, vtNor);
|
||
|
||
arPts1.append(arPts[3]);
|
||
AcGeCircArc3d circArc(arPts[3], arPts[28], arPts[11]);
|
||
AcGeVector3d vts, vte;
|
||
vts = circArc.center() - arPts[3];
|
||
vte = circArc.center() - arPts[11];
|
||
double dAngle = vts.angleTo(vte,circArc.normal());
|
||
if (dAngle > PI)
|
||
{
|
||
dAngle = 2 * PI - dAngle;
|
||
}
|
||
|
||
int nSect = int(dAngle / dMinDiffAng);
|
||
AcGePoint3d pt;
|
||
pt = arPts[3];
|
||
int i = 0;
|
||
for (i = 0; i < nSect; i++)
|
||
{
|
||
arPts1.append(pt.rotateBy(dMinDiffAng, circArc.normal(), circArc.center()));
|
||
}
|
||
arPts1.append(arPts[11]);
|
||
arPts1.append(arPts[8]);
|
||
|
||
arPts2.append(arPts[7]);
|
||
arPts2.append(arPts[9]);
|
||
circArc.set(arPts[9], arPts[30], arPts[29]);
|
||
vts = circArc.center() - arPts[9];
|
||
vte = circArc.center() - arPts[29];
|
||
dAngle = vts.angleTo(vte,circArc.normal());
|
||
if (dAngle > PI)
|
||
{
|
||
dAngle = 2 * PI - dAngle ;
|
||
}
|
||
nSect = int(dAngle / dMinDiffAng);
|
||
pt = arPts[9];
|
||
for (i = 0; i < nSect; i++)
|
||
{
|
||
arPts2.append(pt.rotateBy(dMinDiffAng, circArc.normal(), circArc.center()));
|
||
}
|
||
arPts2.append(arPts[29]);
|
||
|
||
arptSides.append(arPts1);
|
||
arptSides.append(arPts2);
|
||
|
||
int nSize = arptSides.length();
|
||
|
||
AcGeMatrix3d mat1,mat2;
|
||
AcArray<Adesk::Int32> arlFaceList;
|
||
arlFaceList.append(nSize);
|
||
vtNor.normalize();
|
||
vtNor *= dBran1Thick * 0.5;
|
||
mat1.setToTranslation(vtNor);
|
||
vtNor.normalize();
|
||
vtNor *= -dBran1Thick;
|
||
mat2.setToTranslation(vtNor);
|
||
//所有点向上偏移半个厚度
|
||
for (i = 0; i < nSize; i++)
|
||
{
|
||
arPtsU.append(arptSides[i].transformBy(mat1));
|
||
arPtsD.append(arptSides[i].transformBy(mat2));
|
||
arlFaceList.append(i);
|
||
}
|
||
DrawShell(mode,nSize, arPtsU.asArrayPtr(), nSize + 1, arlFaceList.asArrayPtr());
|
||
DrawShell(mode,nSize, arPtsD.asArrayPtr(), nSize + 1, arlFaceList.asArrayPtr());
|
||
|
||
//侧面的面
|
||
for (int j = 0; j < 2; j++)
|
||
{
|
||
arptSides.setLogicalLength(0);
|
||
arPtsU.setLogicalLength(0);
|
||
arPtsD.setLogicalLength(0);
|
||
AcGePoint3dArray arPtsKK;
|
||
switch(j)
|
||
{
|
||
case 0:
|
||
arPtsKK.append(arPts1);
|
||
break;
|
||
case 1:
|
||
arPtsKK.append(arPts2);
|
||
break;
|
||
case 2:
|
||
arPtsKK.append(arPts3);
|
||
break;
|
||
case 3:
|
||
arPtsKK.append(arPts4);
|
||
break;
|
||
}
|
||
for (i = 0; i < arPtsKK.length(); i++)
|
||
{
|
||
arPtsU.append(arPtsKK[i].transformBy(mat1));
|
||
arPtsD.append(arPtsKK[i].transformBy(mat2));
|
||
}
|
||
arptSides.append(arPtsU);
|
||
arptSides.append(arPtsD);
|
||
DrawMesh(mode,2, arPtsU.length(), arptSides.asArrayPtr());
|
||
}
|
||
|
||
//右下角的各个点
|
||
arPts3.append(arPts[32]);
|
||
circArc.set(arPts[32], arPts[33], arPts[23]);
|
||
vts = circArc.center() - arPts[32];
|
||
vte = circArc.center() - arPts[23];
|
||
dAngle = vts.angleTo(vte,circArc.normal());
|
||
if (dAngle > PI)
|
||
{
|
||
dAngle = 2 * PI - dAngle ;
|
||
}
|
||
nSect = int(dAngle / dMinDiffAng);
|
||
pt = arPts[32];
|
||
for (i = 0; i < nSect; i++)
|
||
{
|
||
arPts3.append(pt.rotateBy(dMinDiffAng, circArc.normal(), circArc.center()));
|
||
}
|
||
arPts3.append(arPts[23]);
|
||
arPts3.append(arPts[20]);
|
||
|
||
//左下下角的各个点
|
||
arPts4.append(arPts[19]);
|
||
arPts4.append(arPts[21]);
|
||
if (eType == AecHvac::eArcuateCross || eType == AecHvac::eArcuateIntubCross)
|
||
{
|
||
circArc.set(arPts[21], arPts[31], arPts[5]);
|
||
vts = circArc.center() - arPts[21];
|
||
vte = circArc.center() - arPts[5];
|
||
dAngle = vts.angleTo(vte,circArc.normal());
|
||
if (dAngle > PI)
|
||
{
|
||
dAngle = 2 * PI - dAngle ;
|
||
}
|
||
nSect = int(dAngle / dMinDiffAng);
|
||
pt = arPts[21];
|
||
for (i = 0; i < nSect; i++)
|
||
{
|
||
arPts4.append(pt.rotateBy(dMinDiffAng, circArc.normal(), circArc.center()));
|
||
}
|
||
}
|
||
arPts4.append(arPts[5]);
|
||
|
||
arptSides.setLogicalLength(0);
|
||
arptSides.append(arPts3);
|
||
arptSides.append(arPts4);
|
||
|
||
nSize = arptSides.length();
|
||
|
||
arlFaceList.setLogicalLength(0);
|
||
arlFaceList.append(nSize);
|
||
vtNor.normalize();
|
||
vtNor *= dBran2Thick * 0.5;
|
||
mat1.setToTranslation(vtNor);
|
||
vtNor.normalize();
|
||
vtNor *= -dBran2Thick;
|
||
mat2.setToTranslation(vtNor);
|
||
arPtsU.setLogicalLength(0);
|
||
arPtsD.setLogicalLength(0);
|
||
|
||
//所有点向上偏移半个厚度
|
||
for (i = 0; i < nSize; i++)
|
||
{
|
||
arPtsU.append(arptSides[i].transformBy(mat1));
|
||
arPtsD.append(arptSides[i].transformBy(mat2));
|
||
arlFaceList.append(i);
|
||
}
|
||
DrawShell(mode,nSize, arPtsU.asArrayPtr(), nSize + 1, arlFaceList.asArrayPtr());
|
||
DrawShell(mode,nSize, arPtsD.asArrayPtr(), nSize + 1, arlFaceList.asArrayPtr());
|
||
|
||
//侧面的面
|
||
for (j = 2; j < 4; j++)
|
||
{
|
||
arptSides.setLogicalLength(0);
|
||
arPtsU.setLogicalLength(0);
|
||
arPtsD.setLogicalLength(0);
|
||
AcGePoint3dArray arPtsKK;
|
||
switch(j)
|
||
{
|
||
case 0:
|
||
arPtsKK.append(arPts1);
|
||
break;
|
||
case 1:
|
||
arPtsKK.append(arPts2);
|
||
break;
|
||
case 2:
|
||
arPtsKK.append(arPts3);
|
||
break;
|
||
case 3:
|
||
arPtsKK.append(arPts4);
|
||
break;
|
||
}
|
||
for (i = 0; i < arPtsKK.length(); i++)
|
||
{
|
||
arPtsU.append(arPtsKK[i].transformBy(mat1));
|
||
arPtsD.append(arPtsKK[i].transformBy(mat2));
|
||
}
|
||
arptSides.append(arPtsU);
|
||
arptSides.append(arPtsD);
|
||
DrawMesh(mode,2, arPtsU.length(), arptSides.asArrayPtr());
|
||
}
|
||
|
||
arptSides.setLogicalLength(0);
|
||
arptSides.append(arPts[1]);
|
||
AcGePoint3d ptProj = arPts[3];
|
||
ptProj = ptProj.orthoProject(planSta);
|
||
arptSides.append(ptProj);
|
||
ptProj = arPts[29];
|
||
|
||
ptProj = ptProj.orthoProject(planEnd);
|
||
arptSides.append(ptProj);
|
||
ptProj = arPts[14];
|
||
ptProj = ptProj.orthoProject(planEnd);
|
||
arptSides.append(ptProj);
|
||
ptProj = arPts[13];
|
||
ptProj = ptProj.orthoProject(planEnd);
|
||
arptSides.append(ptProj);
|
||
ptProj = arPts[32];
|
||
ptProj = ptProj.orthoProject(planEnd);
|
||
arptSides.append(ptProj);
|
||
|
||
ptProj = arPts[5];
|
||
ptProj = ptProj.orthoProject(planSta);
|
||
arptSides.append(ptProj);
|
||
arptSides.append(arPts[2]);
|
||
|
||
vtNor.normalize();
|
||
vtNor *= dThick * 0.5;
|
||
mat1.setToTranslation(vtNor);
|
||
|
||
vtNor.normalize();
|
||
vtNor *= dThickSub * 0.5;
|
||
AcGeMatrix3d mat3;
|
||
mat3.setToTranslation(vtNor);
|
||
|
||
vtNor.normalize();
|
||
vtNor *= -dThick;
|
||
mat2.setToTranslation(vtNor);
|
||
|
||
vtNor.normalize();
|
||
vtNor *= dThickSub;
|
||
AcGeMatrix3d mat4;
|
||
mat4.setToTranslation(vtNor);
|
||
|
||
arPtsU.setLogicalLength(0);
|
||
arPtsD.setLogicalLength(0);
|
||
|
||
for (i = 0; i < arptSides.length(); i++)
|
||
{
|
||
if (2 == i || 3 == i || 4 == i || 5 == i)//尾管端四个点
|
||
{
|
||
arPtsU.append(arptSides[i].transformBy(mat3));
|
||
arPtsD.append(arptSides[i].transformBy(mat4));
|
||
}
|
||
else//主管端四个点
|
||
{
|
||
arPtsU.append(arptSides[i].transformBy(mat1));
|
||
arPtsD.append(arptSides[i].transformBy(mat2));
|
||
}
|
||
}
|
||
|
||
arptSides.setLogicalLength(0);
|
||
arptSides.append(arPtsU[0]);
|
||
arptSides.append(arPtsU[7]);
|
||
arptSides.append(arPtsD[7]);
|
||
arptSides.append(arPtsD[0]);
|
||
arptSides.append(arPtsU[0]);
|
||
|
||
arptSides.append(arPtsU[1]);
|
||
arptSides.append(arPtsU[6]);
|
||
arptSides.append(arPtsD[6]);
|
||
arptSides.append(arPtsD[1]);
|
||
arptSides.append(arPtsU[1]);
|
||
|
||
arptSides.append(arPtsU[2]);
|
||
arptSides.append(arPtsU[5]);
|
||
arptSides.append(arPtsD[5]);
|
||
arptSides.append(arPtsD[2]);
|
||
arptSides.append(arPtsU[2]);
|
||
|
||
arptSides.append(arPtsU[3]);
|
||
arptSides.append(arPtsU[4]);
|
||
arptSides.append(arPtsD[4]);
|
||
arptSides.append(arPtsD[3]);
|
||
arptSides.append(arPtsU[3]);
|
||
|
||
DrawMesh(mode,4, 5, arptSides.asArrayPtr());
|
||
}
|
||
else // 普通圆角
|
||
{
|
||
//左上角的各个点
|
||
arPts1.append(arPts[1]);
|
||
arPts1.append(arPts[3]);
|
||
|
||
AcGeCircArc3d circArc(arPts[3], arPts[28], arPts[11]);
|
||
AcGeVector3d vts, vte;
|
||
vts = circArc.center() - arPts[3];
|
||
vte = circArc.center() - arPts[11];
|
||
double dAngle = vts.angleTo(vte,circArc.normal());
|
||
if (dAngle > PI)
|
||
{
|
||
dAngle = 2 * PI - dAngle;
|
||
}
|
||
|
||
int nSect = int(dAngle / dMinDiffAng);
|
||
AcGePoint3d pt;
|
||
pt = arPts[3];
|
||
int i = 0;
|
||
if (eType == AecHvac::eArcuateCross || eType == AecHvac::eArcuateIntubCross)
|
||
{
|
||
for (i = 0; i < nSect; i++)
|
||
{
|
||
arPts1.append(pt.rotateBy(dMinDiffAng, circArc.normal(), circArc.center()));
|
||
}
|
||
}
|
||
arPts1.append(arPts[11]);
|
||
arPts1.append(arPts[8]);
|
||
|
||
//右上角的各个点
|
||
arPts2.append(arPts[7]);
|
||
arPts2.append(arPts[9]);
|
||
circArc.set(arPts[9], arPts[30], arPts[29]);
|
||
vts = circArc.center() - arPts[9];
|
||
vte = circArc.center() - arPts[29];
|
||
dAngle = vts.angleTo(vte,circArc.normal());
|
||
if (dAngle > PI)
|
||
{
|
||
dAngle = 2 * PI - dAngle ;
|
||
}
|
||
nSect = int(dAngle / dMinDiffAng);
|
||
pt = arPts[9];
|
||
for (i = 0; i < nSect; i++)
|
||
{
|
||
arPts2.append(pt.rotateBy(dMinDiffAng, circArc.normal(), circArc.center()));
|
||
}
|
||
arPts2.append(arPts[29]);
|
||
arPts2.append(arPts[17]);
|
||
arPts2.append(arPts[14]);
|
||
|
||
//右下角的各个点
|
||
arPts3.append(arPts[13]);
|
||
arPts3.append(arPts[15]);
|
||
arPts3.append(arPts[32]);
|
||
circArc.set(arPts[32], arPts[33], arPts[23]);
|
||
vts = circArc.center() - arPts[32];
|
||
vte = circArc.center() - arPts[23];
|
||
dAngle = vts.angleTo(vte,circArc.normal());
|
||
if (dAngle > PI)
|
||
{
|
||
dAngle = 2 * PI - dAngle ;
|
||
}
|
||
nSect = int(dAngle / dMinDiffAng);
|
||
pt = arPts[32];
|
||
for (i = 0; i < nSect; i++)
|
||
{
|
||
arPts3.append(pt.rotateBy(dMinDiffAng, circArc.normal(), circArc.center()));
|
||
}
|
||
arPts3.append(arPts[23]);
|
||
arPts3.append(arPts[20]);
|
||
|
||
//左下下角的各个点
|
||
arPts4.append(arPts[19]);
|
||
arPts4.append(arPts[21]);
|
||
if (eType == AecHvac::eArcuateCross || eType == AecHvac::eArcuateIntubCross)
|
||
{
|
||
circArc.set(arPts[21], arPts[31], arPts[5]);
|
||
vts = circArc.center() - arPts[21];
|
||
vte = circArc.center() - arPts[5];
|
||
dAngle = vts.angleTo(vte,circArc.normal());
|
||
if (dAngle > PI)
|
||
{
|
||
dAngle = 2 * PI - dAngle ;
|
||
}
|
||
nSect = int(dAngle / dMinDiffAng);
|
||
pt = arPts[21];
|
||
for (i = 0; i < nSect; i++)
|
||
{
|
||
arPts4.append(pt.rotateBy(dMinDiffAng, circArc.normal(), circArc.center()));
|
||
}
|
||
}
|
||
|
||
arPts4.append(arPts[5]);
|
||
arPts4.append(arPts[2]);
|
||
arptSides.append(arPts1);
|
||
arptSides.append(arPts2);
|
||
arptSides.append(arPts3);
|
||
arptSides.append(arPts4);
|
||
|
||
int nSize = arptSides.length();
|
||
|
||
AcGeMatrix3d mat1,mat2;
|
||
AcArray<Adesk::Int32> arlFaceList;
|
||
arlFaceList.append(nSize);
|
||
vtNor.normalize();
|
||
vtNor *= dThick * 0.5;
|
||
mat1.setToTranslation(vtNor);
|
||
vtNor.normalize();
|
||
vtNor *= -dThick;
|
||
mat2.setToTranslation(vtNor);
|
||
//所有点向上偏移半个厚度
|
||
for (i = 0; i < nSize; i++)
|
||
{
|
||
arPtsU.append(arptSides[i].transformBy(mat1));
|
||
arPtsD.append(arptSides[i].transformBy(mat2));
|
||
arlFaceList.append(i);
|
||
}
|
||
DrawShell(mode,nSize, arPtsU.asArrayPtr(), nSize + 1, arlFaceList.asArrayPtr());
|
||
DrawShell(mode,nSize, arPtsD.asArrayPtr(), nSize + 1, arlFaceList.asArrayPtr());
|
||
//侧面的面
|
||
for (int j = 0; j < 4; j++)
|
||
{
|
||
arptSides.setLogicalLength(0);
|
||
arPtsU.setLogicalLength(0);
|
||
arPtsD.setLogicalLength(0);
|
||
arPts.setLogicalLength(0);
|
||
switch(j)
|
||
{
|
||
case 0:
|
||
arPts.append(arPts1);
|
||
break;
|
||
case 1:
|
||
arPts.append(arPts2);
|
||
break;
|
||
case 2:
|
||
arPts.append(arPts3);
|
||
break;
|
||
case 3:
|
||
arPts.append(arPts4);
|
||
break;
|
||
}
|
||
for (i = 0; i < arPts.length(); i++)
|
||
{
|
||
arPtsU.append(arPts[i].transformBy(mat1));
|
||
arPtsD.append(arPts[i].transformBy(mat2));
|
||
}
|
||
arptSides.append(arPtsU);
|
||
arptSides.append(arPtsD);
|
||
DrawMesh(mode,2, arPtsU.length(), arptSides.asArrayPtr());
|
||
}
|
||
}
|
||
}
|
||
|
||
// 直角
|
||
void ImpHvacCross::DrawLinearCross3d(AcGiDraw &mode) const
|
||
{
|
||
DrawInterCross3d(mode);
|
||
}
|
||
|
||
// 交叉
|
||
void ImpHvacCross::DrawInterCross3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dThick = 200.0;
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
AcGePoint3dArray arPts,arPtsU,arPtsD,arptSides;
|
||
GetIntersectCrossPts(arPts);
|
||
AcGeMatrix3d mat;
|
||
vtNor.normalize();
|
||
vtNor *= dThick * 0.5;
|
||
mat.setToTranslation(vtNor);
|
||
//去掉四个中心线点，把所有点向上偏移半个厚度
|
||
for (int i = 0; i < arPts.length() - 4; i++)
|
||
{
|
||
arPtsU.append(arPts[i].transformBy(mat));
|
||
}
|
||
vtNor.normalize();
|
||
vtNor *= -dThick;
|
||
mat.setToTranslation(vtNor);
|
||
//去掉四个中心线点，把所有点向下偏移半个厚度
|
||
for (i = 0; i < arPts.length() - 4; i++)
|
||
{
|
||
arPtsD.append(arPts[i].transformBy(mat));
|
||
}
|
||
//开始面
|
||
arptSides.append(arPtsU[1]);
|
||
arptSides.append(arPtsU[2]);
|
||
arptSides.append(arPtsD[2]);
|
||
arptSides.append(arPtsD[1]);
|
||
arptSides.append(arPtsU[1]);
|
||
//开始直边段
|
||
arptSides.append(arPtsU[3]);
|
||
arptSides.append(arPtsU[5]);
|
||
arptSides.append(arPtsD[5]);
|
||
arptSides.append(arPtsD[3]);
|
||
arptSides.append(arPtsU[3]);
|
||
//
|
||
arptSides.append(arPtsU[11]);
|
||
arptSides.append(arPtsU[21]);
|
||
arptSides.append(arPtsD[21]);
|
||
arptSides.append(arPtsD[11]);
|
||
arptSides.append(arPtsU[11]);
|
||
|
||
// 如果是直角四通，修改9，15点为交点
|
||
AecHvac::HvacCrossType eCrossType = AecHvac::eOrthoCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eCrossType);
|
||
if(eCrossType == AecHvac::eLinearCross)
|
||
{
|
||
arptSides.append(arPtsU[9]);
|
||
arptSides.append(arPtsU[23]);
|
||
arptSides.append(arPtsD[23]);
|
||
arptSides.append(arPtsD[9]);
|
||
arptSides.append(arPtsU[9]);
|
||
//末点面
|
||
arptSides.append(arPtsU[14]);
|
||
arptSides.append(arPtsU[13]);
|
||
arptSides.append(arPtsD[13]);
|
||
arptSides.append(arPtsD[14]);
|
||
arptSides.append(arPtsU[14]);
|
||
DrawMesh(mode,5, 5, arptSides.asArrayPtr());
|
||
}
|
||
else if (eCrossType == AecHvac::eInterCross)
|
||
{
|
||
//
|
||
arptSides.append(arPtsU[9]);
|
||
arptSides.append(arPtsU[23]);
|
||
arptSides.append(arPtsD[23]);
|
||
arptSides.append(arPtsD[9]);
|
||
arptSides.append(arPtsU[9]);
|
||
//末点直边段
|
||
arptSides.append(arPtsU[17]);
|
||
arptSides.append(arPtsU[15]);
|
||
arptSides.append(arPtsD[15]);
|
||
arptSides.append(arPtsD[17]);
|
||
arptSides.append(arPtsU[17]);
|
||
//末点面
|
||
arptSides.append(arPtsU[14]);
|
||
arptSides.append(arPtsU[13]);
|
||
arptSides.append(arPtsD[13]);
|
||
arptSides.append(arPtsD[14]);
|
||
arptSides.append(arPtsU[14]);
|
||
DrawMesh(mode,6, 5, arptSides.asArrayPtr());
|
||
}
|
||
|
||
//支管BR1
|
||
arptSides.setLogicalLength(0);
|
||
arptSides.append(arPtsU[20]);
|
||
arptSides.append(arPtsU[19]);
|
||
arptSides.append(arPtsD[19]);
|
||
arptSides.append(arPtsD[20]);
|
||
arptSides.append(arPtsU[20]);
|
||
|
||
arptSides.append(arPtsU[23]);
|
||
arptSides.append(arPtsU[21]);
|
||
arptSides.append(arPtsD[21]);
|
||
arptSides.append(arPtsD[23]);
|
||
arptSides.append(arPtsU[23]);
|
||
DrawMesh(mode,2, 5, arptSides.asArrayPtr());
|
||
|
||
//支管BR2
|
||
arptSides.setLogicalLength(0);
|
||
arptSides.append(arPtsU[7]);
|
||
arptSides.append(arPtsU[8]);
|
||
arptSides.append(arPtsD[8]);
|
||
arptSides.append(arPtsD[7]);
|
||
arptSides.append(arPtsU[7]);
|
||
//末点面
|
||
arptSides.append(arPtsU[9]);
|
||
arptSides.append(arPtsU[11]);
|
||
arptSides.append(arPtsD[11]);
|
||
arptSides.append(arPtsD[9]);
|
||
arptSides.append(arPtsU[9]);
|
||
DrawMesh(mode,2, 5, arptSides.asArrayPtr());
|
||
}
|
||
|
||
//二维曲线
|
||
BOOL ImpHvacCross::MakeOrthoCross2dCurves(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
AcGePoint3dArray arPts;
|
||
GetCrossPts(arPts,FALSE,TRUE);
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
//水平放置
|
||
if (IsHorzAlignment())
|
||
{
|
||
//方口
|
||
if (arPts.length() == 20)
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPts[8];
|
||
el.ptGe[1] = arPts[9];
|
||
el.ptGe[2] = arPts[9];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[9];
|
||
el.ptGe[1] = arPts[10];
|
||
el.ptGe[2] = arPts[10];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[11];
|
||
el.ptGe[1] = arPts[12];
|
||
el.ptGe[2] = arPts[12];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[13];
|
||
el.ptGe[2] = arPts[13];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[14];
|
||
el.ptGe[1] = arPts[15];
|
||
el.ptGe[2] = arPts[15];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[15];
|
||
el.ptGe[1] = arPts[16];
|
||
el.ptGe[2] = arPts[16];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[17];
|
||
el.ptGe[1] = arPts[18];
|
||
el.ptGe[2] = arPts[18];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[18];
|
||
el.ptGe[1] = arPts[19];
|
||
el.ptGe[2] = arPts[19];
|
||
cplCurve.append(el);
|
||
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = arPts[10];
|
||
el.ptGe[1] = arPts[11];
|
||
el.ptGe[2] = arPts[11];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[13];
|
||
el.ptGe[1] = arPts[14];
|
||
el.ptGe[2] = arPts[14];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[16];
|
||
el.ptGe[1] = arPts[17];
|
||
el.ptGe[2] = arPts[17];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[19];
|
||
el.ptGe[1] = arPts[8];
|
||
el.ptGe[2] = arPts[8];
|
||
cplCurve.append(el);
|
||
}
|
||
//中心线
|
||
if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
|
||
AcGePoint3d ptCen = arPts[7];
|
||
if (arPts[0].distanceTo(arPts[1]) < arPts[0].distanceTo(arPts[7]))
|
||
{
|
||
ptCen = arPts[1];
|
||
}
|
||
AcGePoint3d ptPlusEdgeS = GetPlusEdgeStartPt();
|
||
AcGePoint3d ptPlusEdgeE = GetPlusEdgeEndPt();
|
||
AcGePoint3d ptPlusEdgeB1 = GetPlusEdgeBra1Pt();
|
||
AcGePoint3d ptPlusEdgeB2 = GetPlusEdgeBra2Pt();
|
||
el.ptGe[0] = arPts[0];
|
||
el.ptGe[1] = ptPlusEdgeS;
|
||
el.ptGe[2] = ptPlusEdgeS;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[2];
|
||
el.ptGe[1] = ptPlusEdgeE;
|
||
el.ptGe[2] = ptPlusEdgeE;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[4];
|
||
el.ptGe[1] = ptPlusEdgeB1;
|
||
el.ptGe[2] = ptPlusEdgeB1;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[6];
|
||
el.ptGe[1] = ptPlusEdgeB2;
|
||
el.ptGe[2] = ptPlusEdgeB2;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptPlusEdgeS;
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptPlusEdgeE;
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptPlusEdgeB1;
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptPlusEdgeB2;
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
//圆口
|
||
if (arPts.length() == 34)
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
//直边段
|
||
for (int i = 0; i <= 18; i+=6)
|
||
{
|
||
el.ptGe[0] = arPts[i + 1];
|
||
el.ptGe[1] = arPts[i + 3];
|
||
el.ptGe[2] = arPts[i + 3];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[i + 2];
|
||
el.ptGe[1] = arPts[i + 5];
|
||
el.ptGe[2] = arPts[i + 5];
|
||
cplCurve.append(el);
|
||
}
|
||
el.ptGe[0] = arPts[3];
|
||
el.ptGe[1] = arPts[24];
|
||
el.ptGe[2] = arPts[24];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[24];
|
||
el.ptGe[1] = arPts[11];
|
||
el.ptGe[2] = arPts[11];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[9];
|
||
el.ptGe[1] = arPts[25];
|
||
el.ptGe[2] = arPts[25];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[25];
|
||
el.ptGe[1] = arPts[17];
|
||
el.ptGe[2] = arPts[17];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[15];
|
||
el.ptGe[1] = arPts[26];
|
||
el.ptGe[2] = arPts[26];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[26];
|
||
el.ptGe[1] = arPts[23];
|
||
el.ptGe[2] = arPts[23];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[21];
|
||
el.ptGe[1] = arPts[27];
|
||
el.ptGe[2] = arPts[27];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[27];
|
||
el.ptGe[1] = arPts[5];
|
||
el.ptGe[2] = arPts[5];
|
||
cplCurve.append(el);
|
||
|
||
//上下弧
|
||
el.ptGe[0] = arPts[24];
|
||
el.ptGe[1] = arPts[32];
|
||
el.ptGe[2] = arPts[25];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[27];
|
||
el.ptGe[1] = arPts[33];
|
||
el.ptGe[2] = arPts[26];
|
||
cplCurve.append(el);
|
||
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
for (i = 0; i <= 18; i+=6)
|
||
{
|
||
el.ptGe[0] = arPts[i + 1];
|
||
el.ptGe[1] = arPts[i + 2];
|
||
el.ptGe[2] = arPts[i + 2];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
|
||
//中心线
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
//直边段
|
||
for (int i = 0; i <= 18; i+=6)
|
||
{
|
||
el.ptGe[0] = arPts[i];
|
||
el.ptGe[1] = arPts[i + 4];
|
||
el.ptGe[2] = arPts[i + 4];
|
||
cplCurve.append(el);
|
||
}
|
||
AcGePoint3d ptCen = arPts[31];
|
||
if (arPts[0].distanceTo(arPts[28]) < arPts[0].distanceTo(arPts[31]))
|
||
{
|
||
ptCen = arPts[28];
|
||
}
|
||
el.ptGe[0] = arPts[4];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[10];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[16];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[22];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
//垂直放置（立管）
|
||
else if (IsVertAlignment())
|
||
{
|
||
//方口
|
||
if (eSectType == eRect)
|
||
{
|
||
double dThick = 300.0;
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
AcGePoint3d pt, ptTemp;
|
||
AcGePoint3dArray arPtsV;
|
||
//开始矢量和Z轴垂直（前视）
|
||
if (IsStartVertAlignment())
|
||
{
|
||
pt = arPts[8];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[10];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[11];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[13];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
}
|
||
//br1矢量和Z轴垂直（左视）
|
||
else if (IsBr1VertAlignment())
|
||
{
|
||
pt = arPts[10];
|
||
pt.z = arPts[0].z;
|
||
ptTemp = arPts[11];
|
||
ptTemp.z = arPts[0].z;
|
||
if (arPts[0].distanceTo(pt) < arPts[0].distanceTo(ptTemp))
|
||
{
|
||
pt = ptTemp;
|
||
}
|
||
arPtsV.append(pt);
|
||
pt = arPts[8];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[19];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[17];
|
||
pt.z = arPts[0].z;
|
||
ptTemp = arPts[16];
|
||
ptTemp.z = arPts[0].z;
|
||
if (arPts[0].distanceTo(pt) < arPts[0].distanceTo(ptTemp))
|
||
{
|
||
pt = ptTemp;
|
||
}
|
||
arPtsV.append(pt);
|
||
}
|
||
else
|
||
return FALSE;
|
||
|
||
AcGeMatrix3d mat;
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
vtNor.normalize();
|
||
vtNor *= dThick * 0.5;
|
||
mat.setToTranslation(vtNor);
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
arPtsV.append(arPtsV[i].transformBy(mat));
|
||
}
|
||
vtNor.normalize();
|
||
vtNor *= -dThick;
|
||
mat.setToTranslation(vtNor);
|
||
for (i = 0; i < 4; i++)
|
||
{
|
||
arPtsV.append(arPtsV[i].transformBy(mat));
|
||
}
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.idSubLay = NULL;
|
||
el.ptGe[0] = arPtsV[4];
|
||
el.ptGe[1] = arPtsV[7];
|
||
el.ptGe[2] = arPtsV[7];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPtsV[8];
|
||
el.ptGe[1] = arPtsV[11];
|
||
el.ptGe[2] = arPtsV[11];
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = arPtsV[4];
|
||
el.ptGe[1] = arPtsV[8];
|
||
el.ptGe[2] = arPtsV[8];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[7];
|
||
el.ptGe[1] = arPtsV[11];
|
||
el.ptGe[2] = arPtsV[11];
|
||
cplCurve.append(el);
|
||
}
|
||
if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.dWidth = dCenWidth;
|
||
el.idSubLay = idBaseLayer;
|
||
el.ptGe[0] = arPtsV[5];
|
||
el.ptGe[1] = arPtsV[9];
|
||
el.ptGe[2] = arPtsV[9];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[6];
|
||
el.ptGe[1] = arPtsV[10];
|
||
el.ptGe[2] = arPtsV[10];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
//圆口
|
||
else if (eSectType == eCircle)
|
||
{
|
||
AcGeVector3d vtStar, vtBr1, vtNor;
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStar);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
double dAngle = vtStar.angleTo(vtBr1);
|
||
//支管垂直
|
||
if (fabs(dAngle - PI / 2) < 1e-3)
|
||
{
|
||
arPts.setLogicalLength(0);
|
||
GetCrossPtsVerCir(arPts);
|
||
//BR管径大，有交点
|
||
if (arPts.length() == 15)
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPts[3];
|
||
el.ptGe[1] = arPts[11];
|
||
el.ptGe[2] = arPts[11];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[11];
|
||
el.ptGe[1] = arPts[8];
|
||
el.ptGe[2] = arPts[12];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[4];
|
||
el.ptGe[2] = arPts[4];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[5];
|
||
el.ptGe[1] = arPts[13];
|
||
el.ptGe[2] = arPts[13];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[13];
|
||
el.ptGe[1] = arPts[10];
|
||
el.ptGe[2] = arPts[14];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[14];
|
||
el.ptGe[1] = arPts[6];
|
||
el.ptGe[2] = arPts[6];
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = arPts[4];
|
||
el.ptGe[1] = arPts[5];
|
||
el.ptGe[2] = arPts[5];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[3];
|
||
el.ptGe[1] = arPts[6];
|
||
el.ptGe[2] = arPts[6];
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = arPts[11];
|
||
el.ptGe[1] = arPts[7];
|
||
el.ptGe[2] = arPts[14];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[9];
|
||
el.ptGe[2] = arPts[13];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
//Br管径小，没有交点
|
||
else if (arPts.length() == 11)
|
||
{
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPts[3];
|
||
el.ptGe[1] = arPts[4];
|
||
el.ptGe[2] = arPts[4];
|
||
cplCurve.append(el);
|
||
|
||
|
||
el.ptGe[0] = arPts[5];
|
||
el.ptGe[1] = arPts[6];
|
||
el.ptGe[2] = arPts[6];
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = arPts[4];
|
||
el.ptGe[1] = arPts[5];
|
||
el.ptGe[2] = arPts[5];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[6];
|
||
el.ptGe[1] = arPts[3];
|
||
el.ptGe[2] = arPts[3];
|
||
cplCurve.append(el);
|
||
}
|
||
if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = arPts[7];
|
||
el.ptGe[1] = arPts[8];
|
||
el.ptGe[2] = arPts[9];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[7];
|
||
el.ptGe[1] = arPts[10];
|
||
el.ptGe[2] = arPts[9];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
//非支管90°
|
||
else
|
||
{
|
||
double dSWidth, dEWidth, dBr1Width, dBr2Width;
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBr2Width);
|
||
vtNor = GetSectNormal();
|
||
vtNor.normal();
|
||
dSWidth *= 0.5;
|
||
dEWidth *= 0.5;
|
||
dBr1Width *=0.5;
|
||
dBr2Width *=0.5;
|
||
AcGePoint3d pts, pte, ptm, ptlineStaU, ptlineStaD, ptlineEndU, ptlineEndD;
|
||
//开始矢量和Z轴垂直（前视）
|
||
el.dWidth = dEdgeWidth;
|
||
if (IsStartVertAlignment())
|
||
{
|
||
//主管4点
|
||
pts = arPts[0];
|
||
pte = arPts[12];
|
||
pte.z = pts.z;
|
||
el.ptGe[0] = pts + vtNor * dSWidth;
|
||
el.ptGe[1] = pte + vtNor * dEWidth;
|
||
el.ptGe[2] = pte + vtNor * dEWidth;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pte + vtNor * dEWidth;
|
||
el.ptGe[1] = pte - vtNor * dEWidth;
|
||
el.ptGe[2] = pte - vtNor * dEWidth;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pte - vtNor * dEWidth;
|
||
el.ptGe[1] = pts - vtNor * dSWidth;
|
||
el.ptGe[2] = pts - vtNor * dSWidth;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pts + vtNor * dSWidth;
|
||
el.ptGe[1] = pts - vtNor * dSWidth;
|
||
el.ptGe[2] = pts - vtNor * dSWidth;
|
||
cplCurve.append(el);
|
||
//Br1投影椭圆1
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
AcDbPolyline pPolyLine, pPolyLine1, pPolyLine2;
|
||
AcGePoint3dArray arPtsEll;
|
||
pte = arPts[6];
|
||
pte.z = pts.z;
|
||
int iRes = TAuxTools::GetEllipseFromCircle(pte, dBr1Width * 2, vtBr1, vtZAxis, pPolyLine,vtStar);
|
||
if (iRes == 2)
|
||
{
|
||
arPtsEll.setLogicalLength(0);
|
||
|
||
TAuxTools::GetArcPoint(pPolyLine, arPtsEll);//Lixl add 2011-11-23
|
||
for(int i = 0; i < arPtsEll.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arPtsEll[i];
|
||
el.ptGe[1] = arPtsEll[i+1];
|
||
el.ptGe[2] = arPtsEll[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
//椭圆2
|
||
iRes = TAuxTools::GetEllipseFromCircle(pte, dBr1Width * 2, vtBr1, vtZAxis, pPolyLine1, -vtStar);
|
||
if (iRes == 2)
|
||
{
|
||
arPtsEll.setLogicalLength(0);
|
||
|
||
TAuxTools::GetArcPoint(pPolyLine1, arPtsEll);//Lixl add 2011-11-23
|
||
for(int i = 0; i < arPtsEll.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arPtsEll[i];
|
||
el.ptGe[1] = arPtsEll[i+1];
|
||
el.ptGe[2] = arPtsEll[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
ptlineStaU = arPtsEll.first();
|
||
ptlineStaD = arPtsEll.last();
|
||
}
|
||
//椭圆3
|
||
pte = arPts[28];
|
||
pte.z = pts.z;
|
||
iRes = TAuxTools::GetEllipseFromCircle(pte, dBr1Width * 2, vtBr1, vtZAxis, pPolyLine2, vtStar);
|
||
if (iRes == 2)
|
||
{
|
||
arPtsEll.setLogicalLength(0);
|
||
|
||
TAuxTools::GetArcPoint(pPolyLine2, arPtsEll);//Lixl add 2011-11-23
|
||
for(int i = 0; i < arPtsEll.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arPtsEll[i];
|
||
el.ptGe[1] = arPtsEll[i+1];
|
||
el.ptGe[2] = arPtsEll[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
ptlineEndU = arPtsEll.last();
|
||
ptlineEndD = arPtsEll.first();
|
||
}
|
||
//椭圆的两根直线
|
||
el.ptGe[0] = ptlineStaU;
|
||
el.ptGe[1] = ptlineEndU;
|
||
el.ptGe[2] = ptlineEndU;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptlineStaD;
|
||
el.ptGe[1] = ptlineEndD;
|
||
el.ptGe[2] = ptlineEndD;
|
||
cplCurve.append(el);
|
||
|
||
}
|
||
else if (IsBr1VertAlignment())
|
||
{
|
||
AcGeVector3d vtTemp = vtNor;
|
||
vtTemp.rotateBy(PI / 2, vtStar);
|
||
vtTemp.normalize();
|
||
|
||
//主管4点
|
||
pts = arPts[0];
|
||
el.ptGe[0] = pts + vtNor * dSWidth;
|
||
el.ptGe[1] = pts + vtTemp * dSWidth;
|
||
el.ptGe[2] = pts - vtNor * dSWidth;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pts + vtNor * dSWidth;
|
||
el.ptGe[1] = pts - vtTemp * dSWidth;
|
||
el.ptGe[2] = pts - vtNor * dSWidth;
|
||
cplCurve.append(el);
|
||
//Br1投影椭圆1
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
AcDbPolyline pPolyLine, pPolyLine1, pPolyLine2;
|
||
AcGeVector3d vtBr1toBr2;
|
||
AcGePoint3dArray arPtsEll;
|
||
pte = arPts[6];
|
||
pte.z = pts.z;
|
||
ptm = arPts[18];
|
||
ptm.z = pts.z;
|
||
vtBr1toBr2 = pte - ptm;
|
||
|
||
int iRes = TAuxTools::GetEllipseFromCircle(pte, dBr1Width * 2, vtBr1, vtZAxis, pPolyLine, vtBr1toBr2);
|
||
if (iRes == 2)
|
||
{
|
||
arPtsEll.setLogicalLength(0);
|
||
|
||
TAuxTools::GetArcPoint(pPolyLine, arPtsEll);
|
||
for(int i = 0; i < arPtsEll.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arPtsEll[i];
|
||
el.ptGe[1] = arPtsEll[i+1];
|
||
el.ptGe[2] = arPtsEll[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
ptlineEndU = arPtsEll.first();
|
||
ptlineEndD = arPtsEll.last();
|
||
|
||
}
|
||
//椭圆2
|
||
iRes = TAuxTools::GetEllipseFromCircle(ptm, dBr2Width * 2, vtBr1, vtZAxis, pPolyLine2, -vtBr1toBr2);
|
||
if (iRes == 2)
|
||
{
|
||
arPtsEll.setLogicalLength(0);
|
||
|
||
TAuxTools::GetArcPoint(pPolyLine2, arPtsEll);
|
||
for(int i = 0; i < arPtsEll.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arPtsEll[i];
|
||
el.ptGe[1] = arPtsEll[i+1];
|
||
el.ptGe[2] = arPtsEll[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
ptlineEndU = arPtsEll.last();
|
||
ptlineEndD = arPtsEll.first();
|
||
}
|
||
AcGePoint3d ptIntersect1, ptIntersect2, ptIntersect3, ptIntersect4;
|
||
AcGeCircArc3d cirarc(arPts[0], vtStar, dSWidth);
|
||
AcGeLine3d pline1(ptlineStaU, ptlineStaU + vtBr1toBr2 * 100);
|
||
AcGeLine3d pline2(ptlineStaD, ptlineStaD + vtBr1toBr2 * 100);
|
||
AcGeLine3d pline3(ptlineEndU, ptlineEndU + vtBr1toBr2 * 100);
|
||
AcGeLine3d pline4(ptlineEndD, ptlineEndD + vtBr1toBr2 * 100);
|
||
int nNum = 0, nNum2 = 0;
|
||
cirarc.intersectWith((AcGeLinearEnt3d&)pline1, nNum, ptIntersect1, ptIntersect2);
|
||
if (2 == nNum)
|
||
{
|
||
if (ptlineStaU.distanceTo(ptIntersect1) > ptlineStaU.distanceTo(ptIntersect2))
|
||
{
|
||
ptIntersect1 = ptIntersect2;
|
||
}
|
||
}
|
||
el.ptGe[0] = ptlineStaU;
|
||
el.ptGe[1] = ptIntersect1;
|
||
el.ptGe[2] = ptIntersect1;
|
||
cplCurve.append(el);
|
||
cirarc.intersectWith((AcGeLinearEnt3d&)pline2, nNum, ptIntersect1, ptIntersect2);
|
||
if (2 == nNum)
|
||
{
|
||
if (ptlineStaD.distanceTo(ptIntersect1) > ptlineStaD.distanceTo(ptIntersect2))
|
||
{
|
||
ptIntersect1 = ptIntersect2;
|
||
}
|
||
}
|
||
el.ptGe[0] = ptlineStaD;
|
||
el.ptGe[1] = ptIntersect1;
|
||
el.ptGe[2] = ptIntersect1;
|
||
cplCurve.append(el);
|
||
|
||
cirarc.intersectWith((AcGeLinearEnt3d&)pline3, nNum, ptIntersect1, ptIntersect2);
|
||
if (2 == nNum)
|
||
{
|
||
if (ptlineEndU.distanceTo(ptIntersect1) > ptlineEndU.distanceTo(ptIntersect2))
|
||
{
|
||
ptIntersect1 = ptIntersect2;
|
||
}
|
||
}
|
||
el.ptGe[0] = ptlineEndU;
|
||
el.ptGe[1] = ptIntersect1;
|
||
el.ptGe[2] = ptIntersect1;
|
||
cplCurve.append(el);
|
||
|
||
cirarc.intersectWith((AcGeLinearEnt3d&)pline4, nNum, ptIntersect1, ptIntersect2);
|
||
if (2 == nNum)
|
||
{
|
||
if (ptlineEndD.distanceTo(ptIntersect1) > ptlineEndD.distanceTo(ptIntersect2))
|
||
{
|
||
ptIntersect1 = ptIntersect2;
|
||
}
|
||
}
|
||
el.ptGe[0] = ptlineEndD;
|
||
el.ptGe[1] = ptIntersect1;
|
||
el.ptGe[2] = ptIntersect1;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
// 承插
|
||
BOOL ImpHvacCross::MakeInsertCross2dCurves( AecComplexCurve& cplCurve, int &nType, BOOL bIntub /*= FALSE*/ ) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
AcGePoint3dArray arPts;
|
||
GetCrossPts(arPts,FALSE,TRUE);
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
AcGeVector3d vtStart = AcGeVector3d::kIdentity;
|
||
AcGeVector3d vtBr1 = AcGeVector3d::kIdentity;
|
||
AcGeVector3d vtBr2 = AcGeVector3d::kIdentity;
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
double dThick = 0.0;
|
||
double dBrThick1 = 0.0;
|
||
double dBrThick2 = 0.0;
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Thick, dBrThick1);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Thick, dBrThick2);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
vtStart.normalize();
|
||
vtBr1.normalize();
|
||
vtBr2.normalize();
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
if (eSectType == eRect)
|
||
{
|
||
if (IsHorzAlignment())
|
||
{
|
||
// 俯视矩形口
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
AcGePoint3d ptTmp1 = AcGePoint3d::kOrigin;
|
||
AcGePoint3d ptTmp2 = AcGePoint3d::kOrigin;
|
||
ptTmp1 = arPts[8] - vtStart * dPlusEdge;
|
||
ptTmp2 = arPts[10] - vtBr1 * dPlusEdge;
|
||
|
||
el.ptGe[0] = arPts[8];
|
||
el.ptGe[1] = ptTmp1;
|
||
el.ptGe[2] = ptTmp1;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptTmp2;
|
||
el.ptGe[1] = arPts[10];
|
||
el.ptGe[2] = arPts[10];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = arPts[12];
|
||
el.ptGe[2] = arPts[12];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[11];
|
||
el.ptGe[1] = arPts[12];
|
||
el.ptGe[2] = arPts[12];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[13];
|
||
el.ptGe[2] = arPts[13];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[14];
|
||
el.ptGe[1] = arPts[15];
|
||
el.ptGe[2] = arPts[15];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[15];
|
||
el.ptGe[1] = arPts[16];
|
||
el.ptGe[2] = arPts[16];
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPts[17] - vtBr2 * dPlusEdge;
|
||
ptTmp2 = arPts[19] - vtStart * dPlusEdge;
|
||
|
||
el.ptGe[0] = arPts[17];
|
||
el.ptGe[1] = ptTmp1;
|
||
el.ptGe[2] = ptTmp1;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptTmp2;
|
||
el.ptGe[1] = arPts[19];
|
||
el.ptGe[2] = arPts[19];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[15];
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = arPts[10];
|
||
el.ptGe[1] = arPts[11];
|
||
el.ptGe[2] = arPts[11];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[16];
|
||
el.ptGe[1] = arPts[17];
|
||
el.ptGe[2] = arPts[17];
|
||
cplCurve.append(el);
|
||
|
||
if (!bIntub)
|
||
{
|
||
el.ptGe[0] = arPts[13];
|
||
el.ptGe[1] = arPts[14];
|
||
el.ptGe[2] = arPts[14];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[19];
|
||
el.ptGe[1] = arPts[8];
|
||
el.ptGe[2] = arPts[8];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
|
||
AcGePoint3d ptCen = arPts[7];
|
||
if (arPts[0].distanceTo(arPts[1]) < arPts[0].distanceTo(arPts[7]))
|
||
{
|
||
ptCen = arPts[1];
|
||
}
|
||
AcGePoint3d ptPlusEdgeS = GetPlusEdgeStartPt();
|
||
AcGePoint3d ptPlusEdgeE = GetPlusEdgeEndPt();
|
||
AcGePoint3d ptPlusEdgeB1 = GetPlusEdgeBra1Pt();
|
||
AcGePoint3d ptPlusEdgeB2 = GetPlusEdgeBra2Pt();
|
||
el.ptGe[0] = arPts[0];
|
||
el.ptGe[1] = ptPlusEdgeS;
|
||
el.ptGe[2] = ptPlusEdgeS;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[2];
|
||
el.ptGe[1] = ptPlusEdgeE;
|
||
el.ptGe[2] = ptPlusEdgeE;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[4];
|
||
el.ptGe[1] = ptPlusEdgeB1;
|
||
el.ptGe[2] = ptPlusEdgeB1;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[6];
|
||
el.ptGe[1] = ptPlusEdgeB2;
|
||
el.ptGe[2] = ptPlusEdgeB2;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptPlusEdgeS;
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptPlusEdgeE;
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptPlusEdgeB1;
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptPlusEdgeB2;
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
else if (IsVertAlignment())
|
||
{
|
||
AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
|
||
AcGePoint3dArray arPtsV;
|
||
if (IsStartVertAlignment())
|
||
{
|
||
ptTmp = arPts[13];
|
||
ptTmp.z = arPts[4].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[11];
|
||
ptTmp.z = arPts[4].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[10];
|
||
ptTmp.z = arPts[4].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[8];
|
||
ptTmp.z = arPts[4].z;
|
||
arPtsV.append(ptTmp);
|
||
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
vtNor.normalize();
|
||
AcGePoint3d ptTmp1 = AcGePoint3d::kOrigin;
|
||
AcGePoint3d ptTmp2 = AcGePoint3d::kOrigin;
|
||
|
||
ptTmp1 = arPtsV[0] + vtNor * dThick / 2.0;
|
||
ptTmp2 = arPtsV[0] - vtNor * dThick / 2.0;
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[1] + vtNor * dBrThick1 / 2.0;
|
||
ptTmp2 = arPtsV[1] - vtNor * dBrThick1 / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[2] + vtNor * dBrThick1 / 2.0;
|
||
ptTmp2 = arPtsV[2] - vtNor * dBrThick1 / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[3] + vtNor * dThick / 2.0;
|
||
ptTmp2 = arPtsV[3] - vtNor * dThick / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[0] + vtNor * dThick / 2.0;
|
||
ptTmp2 = arPtsV[3] + vtNor * dThick / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[0] - vtNor * dThick / 2.0;
|
||
ptTmp2 = arPtsV[3] - vtNor * dThick / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[1] + vtNor * dBrThick1 / 2.0;
|
||
ptTmp2 = arPtsV[2] + vtNor * dBrThick1 / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[1] - vtNor * dBrThick1 / 2.0;
|
||
ptTmp2 = arPtsV[2] - vtNor * dBrThick1 / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
}
|
||
else if (IsBr1VertAlignment())
|
||
{
|
||
ptTmp = arPts[10];
|
||
ptTmp.z = arPts[4].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[8];
|
||
ptTmp.z = arPts[4].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[19];
|
||
ptTmp.z = arPts[4].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[17];
|
||
ptTmp.z = arPts[4].z;
|
||
arPtsV.append(ptTmp);
|
||
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
vtNor.normalize();
|
||
AcGePoint3d ptTmp1 = AcGePoint3d::kOrigin;
|
||
AcGePoint3d ptTmp2 = AcGePoint3d::kOrigin;
|
||
|
||
|
||
ptTmp1 = arPtsV[0] + vtNor * dBrThick1 / 2.0;
|
||
ptTmp2 = arPtsV[0] - vtNor * dBrThick2 / 2.0;
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[1] + vtNor * dThick / 2.0;
|
||
ptTmp2 = arPtsV[1] - vtNor * dThick / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[2] + vtNor * dThick / 2.0;
|
||
ptTmp2 = arPtsV[2] - vtNor * dThick / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[3] + vtNor * dBrThick2 / 2.0;
|
||
ptTmp2 = arPtsV[3] - vtNor * dBrThick2 / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[0] + vtNor * dBrThick1 / 2.0;
|
||
ptTmp2 = arPtsV[1] + vtNor * dBrThick1 / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[0] - vtNor * dBrThick1 / 2.0;
|
||
ptTmp2 = arPtsV[1] - vtNor * dBrThick1 / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[1] + vtNor * dThick / 2.0;
|
||
ptTmp2 = arPtsV[2] + vtNor * dThick / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[1] - vtNor * dThick / 2.0;
|
||
ptTmp2 = arPtsV[2] - vtNor * dThick / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[2] + vtNor * dBrThick2 / 2.0;
|
||
ptTmp2 = arPtsV[3] + vtNor * dBrThick2 / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
|
||
ptTmp1 = arPtsV[2] - vtNor * dBrThick2 / 2.0;
|
||
ptTmp2 = arPtsV[3] - vtNor * dBrThick2 / 2.0;
|
||
|
||
el.ptGe[0] = ptTmp1;
|
||
el.ptGe[1] = ptTmp2;
|
||
el.ptGe[2] = ptTmp2;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
// 圆形口
|
||
if (eSectType == eCircle)
|
||
{
|
||
arPts.setLogicalLength(0);
|
||
if (!GetInsertCirPts(arPts))
|
||
return FALSE;
|
||
|
||
if (IsHorzAlignment())
|
||
{
|
||
// 俯视
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPts[1];
|
||
el.ptGe[1] = arPts[13];
|
||
el.ptGe[2] = arPts[13];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[13];
|
||
el.ptGe[1] = arPts[18];
|
||
el.ptGe[2] = arPts[18];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[18];
|
||
el.ptGe[1] = arPts[8];
|
||
el.ptGe[2] = arPts[8];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[7];
|
||
el.ptGe[1] = arPts[19];
|
||
el.ptGe[2] = arPts[19];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[19];
|
||
el.ptGe[1] = arPts[17];
|
||
el.ptGe[2] = arPts[17];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[17];
|
||
el.ptGe[1] = arPts[5];
|
||
el.ptGe[2] = arPts[5];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[4];
|
||
el.ptGe[1] = arPts[16];
|
||
el.ptGe[2] = arPts[16];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[16];
|
||
el.ptGe[1] = arPts[21];
|
||
el.ptGe[2] = arPts[21];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[21];
|
||
el.ptGe[1] = arPts[11];
|
||
el.ptGe[2] = arPts[11];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[10];
|
||
el.ptGe[1] = arPts[20];
|
||
el.ptGe[2] = arPts[20];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[20];
|
||
el.ptGe[1] = arPts[14];
|
||
el.ptGe[2] = arPts[14];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[14];
|
||
el.ptGe[1] = arPts[2];
|
||
el.ptGe[2] = arPts[2];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[18];
|
||
el.ptGe[1] = arPts[22];
|
||
el.ptGe[2] = arPts[19];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[20];
|
||
el.ptGe[1] = arPts[23];
|
||
el.ptGe[2] = arPts[21];
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
|
||
el.ptGe[0] = arPts[5];
|
||
el.ptGe[1] = arPts[4];
|
||
el.ptGe[2] = arPts[4];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[8];
|
||
el.ptGe[1] = arPts[7];
|
||
el.ptGe[2] = arPts[7];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[2];
|
||
el.ptGe[1] = arPts[1];
|
||
el.ptGe[2] = arPts[1];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[11];
|
||
el.ptGe[1] = arPts[10];
|
||
el.ptGe[2] = arPts[10];
|
||
cplCurve.append(el);
|
||
}
|
||
if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = arPts[0];
|
||
el.ptGe[1] = arPts[12];
|
||
el.ptGe[2] = arPts[12];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[15];
|
||
el.ptGe[2] = arPts[15];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[3];
|
||
el.ptGe[1] = arPts[15];
|
||
el.ptGe[2] = arPts[15];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[6];
|
||
el.ptGe[1] = arPts[12];
|
||
el.ptGe[2] = arPts[12];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[9];
|
||
el.ptGe[1] = arPts[12];
|
||
el.ptGe[2] = arPts[12];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
else if (IsVertAlignment())
|
||
{
|
||
MakeOrthoCross2dCurves(cplCurve, nType);
|
||
}
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
// 斜接
|
||
BOOL ImpHvacCross::MakeInclineCross2dCurves(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
idBaseLayer = layerId();
|
||
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
|
||
if (eSectType == eRect)
|
||
{
|
||
MakeArcuateCross2dCurves(cplCurve, nType);
|
||
}
|
||
else if (eSectType == eCircle)
|
||
{
|
||
AcGePoint3dArray arPts;
|
||
if(!GetInclineCirPts(arPts))
|
||
return FALSE;
|
||
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
|
||
if (IsHorzAlignment())
|
||
{
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPts[1];
|
||
el.ptGe[1] = arPts[13];
|
||
el.ptGe[2] = arPts[13];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[13];
|
||
el.ptGe[1] = arPts[20];
|
||
el.ptGe[2] = arPts[20];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[20];
|
||
el.ptGe[1] = arPts[8];
|
||
el.ptGe[2] = arPts[8];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[7];
|
||
el.ptGe[1] = arPts[19];
|
||
el.ptGe[2] = arPts[19];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[19];
|
||
el.ptGe[1] = arPts[24];
|
||
el.ptGe[2] = arPts[24];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[24];
|
||
el.ptGe[1] = arPts[17];
|
||
el.ptGe[2] = arPts[17];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[17];
|
||
el.ptGe[1] = arPts[5];
|
||
el.ptGe[2] = arPts[5];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[4];
|
||
el.ptGe[1] = arPts[16];
|
||
el.ptGe[2] = arPts[16];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[16];
|
||
el.ptGe[1] = arPts[25];
|
||
el.ptGe[2] = arPts[25];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[25];
|
||
el.ptGe[1] = arPts[23];
|
||
el.ptGe[2] = arPts[23];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[23];
|
||
el.ptGe[1] = arPts[11];
|
||
el.ptGe[2] = arPts[11];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[10];
|
||
el.ptGe[1] = arPts[22];
|
||
el.ptGe[2] = arPts[22];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[22];
|
||
el.ptGe[1] = arPts[14];
|
||
el.ptGe[2] = arPts[14];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[14];
|
||
el.ptGe[1] = arPts[2];
|
||
el.ptGe[2] = arPts[2];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[0];
|
||
el.ptGe[1] = arPts[12];
|
||
el.ptGe[2] = arPts[12];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[24];
|
||
el.ptGe[2] = arPts[24];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[25];
|
||
el.ptGe[2] = arPts[25];
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = arPts[8];
|
||
el.ptGe[1] = arPts[7];
|
||
el.ptGe[2] = arPts[7];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[2];
|
||
el.ptGe[1] = arPts[1];
|
||
el.ptGe[2] = arPts[1];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[5];
|
||
el.ptGe[1] = arPts[4];
|
||
el.ptGe[2] = arPts[4];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[11];
|
||
el.ptGe[1] = arPts[10];
|
||
el.ptGe[2] = arPts[10];
|
||
cplCurve.append(el);
|
||
|
||
}
|
||
if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[0];
|
||
el.ptGe[2] = arPts[0];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[6];
|
||
el.ptGe[1] = arPts[18];
|
||
el.ptGe[2] = arPts[18];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[9];
|
||
el.ptGe[1] = arPts[21];
|
||
el.ptGe[2] = arPts[21];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[3];
|
||
el.ptGe[1] = arPts[15];
|
||
el.ptGe[2] = arPts[15];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[18];
|
||
el.ptGe[2] = arPts[18];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[15];
|
||
el.ptGe[2] = arPts[15];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[21];
|
||
el.ptGe[2] = arPts[21];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
else if (IsVertAlignment())
|
||
{
|
||
if (IsBr1VertAlignment()) // 侧视
|
||
{
|
||
AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
|
||
AcGePoint3dArray arPtsV;
|
||
ptTmp = arPts[8];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[6];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[1];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[0];
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[2];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[9];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[10];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[18];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[21];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
|
||
double dBr1Width = 0.0;
|
||
double dBr2Width = 0.0;
|
||
double dSWidth = 0.0;
|
||
AcGeVector3d vtBr1 = AcGeVector3d::kIdentity;
|
||
AcGeVector3d vtBr2 = AcGeVector3d::kIdentity;
|
||
m_pXDataMap->GetAt(HCRS_StartDiameter, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Diameter, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Diameter, dBr2Width);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
|
||
AcDbPolyline pPolyLine;
|
||
int iRes = TAuxTools::GetEllipseFromCircle(arPtsV[1], dBr1Width, vtBr1, vtZAxis, pPolyLine, arPtsV[0] - arPtsV[6]);
|
||
el.dWidth = dEdgeWidth;
|
||
|
||
if (iRes == 2 || iRes == 0)
|
||
{
|
||
AcGePoint3dArray arPtsEll;
|
||
|
||
TAuxTools::GetArcPoint(pPolyLine, arPtsEll);
|
||
for(int i = 0; i < arPtsEll.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arPtsEll[i];
|
||
el.ptGe[1] = arPtsEll[i+1];
|
||
el.ptGe[2] = arPtsEll[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
el.ptGe[0] = arPtsV[1] - vtNor * dBr1Width / 2.0;
|
||
el.ptGe[1] = arPtsV[1] + vtNor * dBr1Width / 2.0;
|
||
el.ptGe[2] = arPtsV[1] + vtNor * dBr1Width / 2.0;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
el.ptGe[0] = arPtsV[1] - vtNor * dBr1Width / 2.0;
|
||
el.ptGe[1] = arPtsV[7] - vtNor * dBr1Width / 2.0;
|
||
el.ptGe[2] = arPtsV[7] - vtNor * dBr1Width / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[1] + vtNor * dBr1Width / 2.0;
|
||
el.ptGe[1] = arPtsV[7] + vtNor * dBr1Width / 2.0;
|
||
el.ptGe[2] = arPtsV[7] + vtNor * dBr1Width / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[3] - vtNor * dSWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[2];
|
||
el.ptGe[2] = arPtsV[3] + vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[3] - vtNor * dSWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[4];
|
||
el.ptGe[2] = arPtsV[3] + vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
AcDbPolyline pPolyLine1;
|
||
iRes = TAuxTools::GetEllipseFromCircle(arPtsV[5], dBr2Width, vtBr2, vtZAxis, pPolyLine1, arPtsV[6] - arPtsV[0]);
|
||
if (iRes == 2 || iRes == 0)
|
||
{
|
||
AcGePoint3dArray arPtsEll;
|
||
|
||
TAuxTools::GetArcPoint(pPolyLine1, arPtsEll);
|
||
for(int i = 0; i < arPtsEll.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arPtsEll[i];
|
||
el.ptGe[1] = arPtsEll[i+1];
|
||
el.ptGe[2] = arPtsEll[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
el.ptGe[0] = arPtsV[5] - vtNor * dBr2Width / 2.0;
|
||
el.ptGe[1] = arPtsV[5] + vtNor * dBr2Width / 2.0;
|
||
el.ptGe[2] = arPtsV[5] + vtNor * dBr2Width / 2.0;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
el.ptGe[0] = arPtsV[5] - vtNor * dBr2Width / 2.0;
|
||
el.ptGe[1] = arPtsV[8] - vtNor * dBr2Width / 2.0;
|
||
el.ptGe[2] = arPtsV[8] - vtNor * dBr2Width / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[5] + vtNor * dBr2Width / 2.0;
|
||
el.ptGe[1] = arPtsV[8] + vtNor * dBr2Width / 2.0;
|
||
el.ptGe[2] = arPtsV[8] + vtNor * dBr2Width / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
if (dBr1Width < dSWidth)
|
||
{
|
||
AcGePoint3d ptIntersect1,ptIntersect2;
|
||
//求出直线于圆弧的交点
|
||
AcGeCircArc3d circArc(arPtsV[3] - vtNor * dSWidth / 2.0, arPtsV[2], arPtsV[3] + vtNor * dSWidth / 2.0);
|
||
//定义求交直线
|
||
AcGeLine3d *pLine = new AcGeLine3d(arPtsV[7] - vtNor * dBr1Width / 2.0, arPtsV[3] - vtNor * dSWidth / 2.0);
|
||
int nNum=0;//交点数
|
||
circArc.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
|
||
delete pLine;
|
||
if (2 == nNum)
|
||
{
|
||
AcGePoint3d ptTmp = arPtsV[7] - vtNor * dBr1Width / 2.0;
|
||
|
||
if (ptTmp.distanceTo(ptIntersect1) < ptTmp.distanceTo(ptIntersect2))
|
||
{
|
||
el.ptGe[0] = ptTmp;
|
||
el.ptGe[1] = ptIntersect1;
|
||
el.ptGe[2] = ptIntersect1;
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
el.ptGe[0] = ptTmp;
|
||
el.ptGe[1] = ptIntersect2;
|
||
el.ptGe[2] = ptIntersect2;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
pLine = new AcGeLine3d(arPtsV[7] + vtNor * dBr1Width / 2.0, arPtsV[3] + vtNor * dSWidth / 2.0);
|
||
nNum = 0;
|
||
circArc.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
|
||
delete pLine;
|
||
if (2 == nNum)
|
||
{
|
||
AcGePoint3d ptTmp = arPtsV[7] + vtNor * dBr1Width / 2.0;
|
||
|
||
if (ptTmp.distanceTo(ptIntersect1) < ptTmp.distanceTo(ptIntersect2))
|
||
{
|
||
el.ptGe[0] = ptTmp;
|
||
el.ptGe[1] = ptIntersect1;
|
||
el.ptGe[2] = ptIntersect1;
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
el.ptGe[0] = ptTmp;
|
||
el.ptGe[1] = ptIntersect2;
|
||
el.ptGe[2] = ptIntersect2;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
el.ptGe[0] = arPtsV[7] - vtNor * dBr1Width / 2.0;
|
||
el.ptGe[1] = arPtsV[3] - vtNor * dSWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[3] - vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[7] + vtNor * dBr1Width / 2.0;
|
||
el.ptGe[1] = arPtsV[3] + vtNor * dSWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[3] + vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
if (dBr2Width < dSWidth)
|
||
{
|
||
AcGePoint3d ptIntersect1,ptIntersect2;
|
||
//求出直线于圆弧的交点
|
||
AcGeCircArc3d circArc(arPtsV[3] - vtNor * dSWidth / 2.0, arPtsV[4], arPtsV[3] + vtNor * dSWidth / 2.0);
|
||
//定义求交直线
|
||
AcGeLine3d *pLine = new AcGeLine3d(arPtsV[8] - vtNor * dBr2Width / 2.0, arPtsV[3] - vtNor * dSWidth / 2.0);
|
||
int nNum=0;//交点数
|
||
circArc.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
|
||
delete pLine;
|
||
if (2 == nNum)
|
||
{
|
||
AcGePoint3d ptTmp = arPtsV[8] - vtNor * dBr2Width / 2.0;
|
||
|
||
if (ptTmp.distanceTo(ptIntersect1) < ptTmp.distanceTo(ptIntersect2))
|
||
{
|
||
el.ptGe[0] = ptTmp;
|
||
el.ptGe[1] = ptIntersect1;
|
||
el.ptGe[2] = ptIntersect1;
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
el.ptGe[0] = ptTmp;
|
||
el.ptGe[1] = ptIntersect2;
|
||
el.ptGe[2] = ptIntersect2;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
pLine = new AcGeLine3d(arPtsV[8] + vtNor * dBr2Width / 2.0, arPtsV[3] + vtNor * dSWidth / 2.0);
|
||
nNum = 0;
|
||
circArc.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
|
||
delete pLine;
|
||
if (2 == nNum)
|
||
{
|
||
AcGePoint3d ptTmp = arPtsV[8] + vtNor * dBr2Width / 2.0;
|
||
|
||
if (ptTmp.distanceTo(ptIntersect1) < ptTmp.distanceTo(ptIntersect2))
|
||
{
|
||
el.ptGe[0] = ptTmp;
|
||
el.ptGe[1] = ptIntersect1;
|
||
el.ptGe[2] = ptIntersect1;
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
el.ptGe[0] = ptTmp;
|
||
el.ptGe[1] = ptIntersect2;
|
||
el.ptGe[2] = ptIntersect2;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
el.ptGe[0] = arPtsV[8] - vtNor * dBr2Width / 2.0;
|
||
el.ptGe[1] = arPtsV[3] - vtNor * dSWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[3] - vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[8] + vtNor * dBr2Width / 2.0;
|
||
el.ptGe[1] = arPtsV[3] + vtNor * dSWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[3] + vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
|
||
if (IsStartVertAlignment()) // 主视
|
||
{
|
||
AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
|
||
AcGePoint3dArray arPtsV;
|
||
ptTmp = arPts[1];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[5];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[8];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[6];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[7];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[13];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
ptTmp = arPts[17];
|
||
ptTmp.z = arPts[0].z;
|
||
arPtsV.append(ptTmp);
|
||
|
||
double dSWidth = 0.0;
|
||
double dEWidth = 0.0;
|
||
double dBr1Width = 0.0;
|
||
AcGeVector3d vtBr1 = AcGeVector3d::kIdentity;
|
||
m_pXDataMap->GetAt(HCRS_StartDiameter, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_EndDiameter, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Diameter, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
vtNor.normalize();
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPtsV[0] - vtNor * dSWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[0] + vtNor * dSWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[0] + vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[1] - vtNor * dEWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[1] + vtNor * dEWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[1] + vtNor * dEWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[0] - vtNor * dSWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[5] - vtNor * dSWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[5] - vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[6] - vtNor * dEWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[5] - vtNor * dSWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[5] - vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[1] - vtNor * dEWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[6] - vtNor * dEWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[6] - vtNor * dEWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[0] + vtNor * dSWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[5] + vtNor * dSWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[5] + vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[6] + vtNor * dEWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[5] + vtNor * dSWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[5] + vtNor * dSWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[6] + vtNor * dEWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[1] + vtNor * dEWidth / 2.0;
|
||
el.ptGe[2] = arPtsV[1] + vtNor * dEWidth / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[5] - vtNor * dSWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[3] - vtNor * dBr1Width / 2.0;
|
||
el.ptGe[2] = arPtsV[3] - vtNor * dBr1Width / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[5] + vtNor * dSWidth / 2.0;
|
||
el.ptGe[1] = arPtsV[3] + vtNor * dBr1Width / 2.0;
|
||
el.ptGe[2] = arPtsV[3] + vtNor * dBr1Width / 2.0;
|
||
cplCurve.append(el);
|
||
|
||
AcGeVector3d vtTmp1, vtTmp2;
|
||
vtTmp1 = GetSectNormal();
|
||
vtTmp2 = arPtsV[1] - arPtsV[0];
|
||
AcGeVector3d vtTmp = AcGeVector3d::kZAxis;//vtTmp1.crossProduct(vtTmp2)
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
AcDbPolyline pPolyLine;
|
||
int iRes = TAuxTools::GetEllipseFromCircle(arPtsV[3], dBr1Width, vtBr1, vtZAxis, pPolyLine, vtTmp2);
|
||
|
||
if (iRes == 2 || iRes == 0)
|
||
{
|
||
AcGePoint3dArray arEllpts;
|
||
TAuxTools::GetArcPoint(pPolyLine, arEllpts);// Lixl add 2011-11-23
|
||
|
||
el.ptGe[0] = arPtsV[3] - vtNor * dBr1Width * 0.5;
|
||
el.ptGe[1] = arEllpts[3];
|
||
el.ptGe[2] = arPtsV[3] + vtNor * dBr1Width * 0.5;
|
||
cplCurve.append(el);
|
||
|
||
AcDbPolyline pPolyLine1;
|
||
TAuxTools::GetEllipseFromCircle(arPtsV[3], dBr1Width, vtBr1, vtZAxis, pPolyLine1, -vtTmp2);
|
||
AcGePoint3dArray arEllpts1;
|
||
TAuxTools::GetArcPoint(pPolyLine1, arEllpts1);// Lixl add 2011-11-23
|
||
el.ptGe[0] = arPtsV[3] - vtNor * dBr1Width * 0.5;
|
||
el.ptGe[1] = arEllpts1[3];
|
||
el.ptGe[2] = arPtsV[3] + vtNor * dBr1Width * 0.5;
|
||
cplCurve.append(el);
|
||
}
|
||
if (iRes == 1)
|
||
{
|
||
el.ptGe[0] = arPtsV[3] - vtNor * dBr1Width / 2.0;
|
||
el.ptGe[1] = arPtsV[3] + vtNor * dBr1Width / 2.0;
|
||
el.ptGe[2] = arPtsV[3] + vtNor * dBr1Width / 2.0;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
// 圆角
|
||
BOOL ImpHvacCross::MakeArcuateCross2dCurves( AecComplexCurve& cplCurve, int &nType, BOOL bIntub /*= FALSE*/ ) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
AcGePoint3dArray arPts;
|
||
GetArcuateCrossPts(arPts);
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
|
||
AecHvac::HvacCrossType eType = AecHvac::eArcuateCross;
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
//m_pXDataMap->GetAt(HVAC_BaseLayer, idBaseLayer);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eType);
|
||
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
//水平放置
|
||
if (IsHorzAlignment())
|
||
{
|
||
if (arPts.length() == 34)
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPts[1];
|
||
el.ptGe[1] = arPts[3];
|
||
el.ptGe[2] = arPts[3];
|
||
cplCurve.append(el);
|
||
|
||
if (eType == AecHvac::eArcuateCross || eType == AecHvac::eArcuateIntubCross)
|
||
{
|
||
el.ptGe[0] = arPts[3];
|
||
el.ptGe[1] = arPts[28];
|
||
el.ptGe[2] = arPts[11];
|
||
cplCurve.append(el);
|
||
}
|
||
else if (eType == AecHvac::eInclineCross)
|
||
{
|
||
el.ptGe[0] = arPts[3];
|
||
el.ptGe[1] = arPts[11];
|
||
el.ptGe[2] = arPts[11];
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
el.ptGe[0] = arPts[11];
|
||
el.ptGe[1] = arPts[8];
|
||
el.ptGe[2] = arPts[8];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[7];
|
||
el.ptGe[1] = arPts[9];
|
||
el.ptGe[2] = arPts[9];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[9];
|
||
el.ptGe[1] = arPts[30];
|
||
el.ptGe[2] = arPts[29];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[29];
|
||
el.ptGe[1] = arPts[17];
|
||
el.ptGe[2] = arPts[17];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[17];
|
||
el.ptGe[1] = arPts[14];
|
||
el.ptGe[2] = arPts[14];
|
||
cplCurve.append(el);
|
||
|
||
|
||
el.ptGe[0] = arPts[13];
|
||
el.ptGe[1] = arPts[15];
|
||
el.ptGe[2] = arPts[15];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[15];
|
||
el.ptGe[1] = arPts[32];
|
||
el.ptGe[2] = arPts[32];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[32];
|
||
el.ptGe[1] = arPts[33];
|
||
el.ptGe[2] = arPts[23];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[23];
|
||
el.ptGe[1] = arPts[20];
|
||
el.ptGe[2] = arPts[20];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[19];
|
||
el.ptGe[1] = arPts[21];
|
||
el.ptGe[2] = arPts[21];
|
||
cplCurve.append(el);
|
||
|
||
if (eType == AecHvac::eArcuateCross || eType == AecHvac::eArcuateIntubCross)
|
||
{
|
||
el.ptGe[0] = arPts[21];
|
||
el.ptGe[1] = arPts[31];
|
||
el.ptGe[2] = arPts[5];
|
||
cplCurve.append(el);
|
||
}
|
||
else if (eType == AecHvac::eInclineCross)
|
||
{
|
||
el.ptGe[0] = arPts[21];
|
||
el.ptGe[1] = arPts[5];
|
||
el.ptGe[2] = arPts[5];
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
el.ptGe[0] = arPts[5];
|
||
el.ptGe[1] = arPts[2];
|
||
el.ptGe[2] = arPts[2];
|
||
cplCurve.append(el);
|
||
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = arPts[8];
|
||
el.ptGe[1] = arPts[7];
|
||
el.ptGe[2] = arPts[7];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[20];
|
||
el.ptGe[1] = arPts[19];
|
||
el.ptGe[2] = arPts[19];
|
||
cplCurve.append(el);
|
||
|
||
// 插管式，添加管壁线及不绘制两端线
|
||
if (bIntub)
|
||
{
|
||
el.idSubLay.setNull();
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPts[3];
|
||
el.ptGe[1] = arPts[29];
|
||
el.ptGe[2] = arPts[29];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[5];
|
||
el.ptGe[1] = arPts[32];
|
||
el.ptGe[2] = arPts[32];
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
el.ptGe[0] = arPts[2];
|
||
el.ptGe[1] = arPts[1];
|
||
el.ptGe[2] = arPts[1];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[13];
|
||
el.ptGe[1] = arPts[14];
|
||
el.ptGe[2] = arPts[14];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
//中心线
|
||
if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
AcGePoint3d ptCen,ptInter1,ptInter2;
|
||
GetIntersectWith(arPts[0],arPts[4],arPts[6],arPts[10],ptInter1);
|
||
GetIntersectWith(arPts[0],arPts[4],arPts[18],arPts[22],ptInter2);
|
||
ptCen = ptInter2;
|
||
if (arPts[0].distanceTo(ptInter1) < arPts[0].distanceTo(ptInter2))
|
||
{
|
||
ptCen = ptInter1;
|
||
}
|
||
el.ptGe[0] = arPts[0];
|
||
el.ptGe[1] = arPts[4];
|
||
el.ptGe[2] = arPts[4];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[4];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[6];
|
||
el.ptGe[1] = arPts[10];
|
||
el.ptGe[2] = arPts[10];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[10];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[16];
|
||
el.ptGe[2] = arPts[16];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[16];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[18];
|
||
el.ptGe[1] = arPts[22];
|
||
el.ptGe[2] = arPts[22];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[22];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
//垂直放置（立管）
|
||
else if (IsVertAlignment())
|
||
{
|
||
double dThick = 300.0;
|
||
double dBran1Thick = 300.0, dBran2Thick = 300.0;
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Thick, dBran1Thick);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Thick, dBran2Thick);
|
||
|
||
AcGePoint3d pt;
|
||
AcGePoint3dArray arPtsV;
|
||
//开始矢量和Z轴垂直（前视）
|
||
if (IsStartVertAlignment())
|
||
{
|
||
//标高与开始点相同
|
||
pt = arPts[1];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[8];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[7];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[14];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
}
|
||
//br1矢量和Z轴垂直（左视）
|
||
else if (IsBr1VertAlignment())
|
||
{
|
||
//标高与Br1点相同
|
||
pt = arPts[8];
|
||
pt.z = arPts[6].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[1];
|
||
pt.z = arPts[6].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[2];
|
||
pt.z = arPts[6].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[19];
|
||
pt.z = arPts[6].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[3];
|
||
pt.z = arPts[6].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[5];
|
||
pt.z = arPts[6].z;
|
||
arPtsV.append(pt);
|
||
}
|
||
else
|
||
return FALSE;
|
||
|
||
if (eType == AecHvac::eArcuateIntubCross) // 圆角（插管）
|
||
{
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
{
|
||
if (IsStartVertAlignment())
|
||
{
|
||
AcGePoint3d pt1, pt2, pt3, pt4;
|
||
pt1 = arPtsV[0] + vtNor * dThick * 0.5;
|
||
pt2 = arPtsV[0] - vtNor * dThick * 0.5;
|
||
pt3 = arPtsV[3] + vtNor * dThick * 0.5;
|
||
pt4 = arPtsV[3] - vtNor * dThick * 0.5;
|
||
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = pt1;
|
||
el.ptGe[1] = pt3;
|
||
el.ptGe[2] = pt3;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pt2;
|
||
el.ptGe[1] = pt4;
|
||
el.ptGe[2] = pt4;
|
||
cplCurve.append(el);
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = pt2;
|
||
el.ptGe[1] = pt1;
|
||
el.ptGe[2] = pt1;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pt3;
|
||
el.ptGe[1] = pt4;
|
||
el.ptGe[2] = pt4;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
pt1 = arPtsV[1] + vtNor * dBran1Thick * 0.5;
|
||
pt2 = arPtsV[1] - vtNor * dBran1Thick * 0.5;
|
||
pt3 = arPtsV[2] + vtNor * dBran1Thick * 0.5;
|
||
pt4 = arPtsV[2] - vtNor * dBran1Thick * 0.5;
|
||
//if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
//{
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = pt3;
|
||
el.ptGe[1] = pt4;
|
||
el.ptGe[2] = pt4;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pt1;
|
||
el.ptGe[1] = pt2;
|
||
el.ptGe[2] = pt2;
|
||
cplCurve.append(el);
|
||
|
||
if (dBran1Thick < dThick)
|
||
{
|
||
el.ptGe[0] = pt3;
|
||
el.ptGe[1] = pt1;
|
||
el.ptGe[2] = pt1;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pt2;
|
||
el.ptGe[1] = pt4;
|
||
el.ptGe[2] = pt4;
|
||
cplCurve.append(el);
|
||
}
|
||
//}
|
||
|
||
}
|
||
else if (IsBr1VertAlignment())
|
||
{
|
||
AcGePoint3d pt1, pt2, pt3, pt4;
|
||
pt1 = arPtsV[0] + vtNor * dBran1Thick * 0.5;
|
||
pt2 = arPtsV[0] - vtNor * dBran1Thick * 0.5;
|
||
pt3 = arPtsV[4] + vtNor * dBran1Thick * 0.5;
|
||
pt4 = arPtsV[4] - vtNor * dBran1Thick * 0.5;
|
||
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = pt1;
|
||
el.ptGe[1] = pt3;
|
||
el.ptGe[2] = pt3;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pt2;
|
||
el.ptGe[1] = pt4;
|
||
el.ptGe[2] = pt4;
|
||
cplCurve.append(el);
|
||
|
||
pt1 = arPtsV[1] + vtNor * dThick * 0.5;
|
||
pt2 = arPtsV[1] - vtNor * dThick * 0.5;
|
||
pt3 = arPtsV[2] + vtNor * dThick * 0.5;
|
||
pt4 = arPtsV[2] - vtNor * dThick * 0.5;
|
||
el.ptGe[0] = pt1;
|
||
el.ptGe[1] = pt3;
|
||
el.ptGe[2] = pt3;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pt2;
|
||
el.ptGe[1] = pt4;
|
||
el.ptGe[2] = pt4;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pt1;
|
||
el.ptGe[1] = pt2;
|
||
el.ptGe[2] = pt2;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pt4;
|
||
el.ptGe[1] = pt3;
|
||
el.ptGe[2] = pt3;
|
||
cplCurve.append(el);
|
||
|
||
pt1 = arPtsV[3] + vtNor * dBran2Thick * 0.5;
|
||
pt2 = arPtsV[3] - vtNor * dBran2Thick * 0.5;
|
||
pt3 = arPtsV[5] + vtNor * dBran2Thick * 0.5;
|
||
pt4 = arPtsV[5] - vtNor * dBran2Thick * 0.5;
|
||
el.ptGe[0] = pt1;
|
||
el.ptGe[1] = pt3;
|
||
el.ptGe[2] = pt3;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pt2;
|
||
el.ptGe[1] = pt4;
|
||
el.ptGe[2] = pt4;
|
||
cplCurve.append(el);
|
||
|
||
pt1 = arPtsV[0] + vtNor * dBran1Thick * 0.5;
|
||
pt2 = arPtsV[0] - vtNor * dBran1Thick * 0.5;
|
||
pt3 = arPtsV[3] + vtNor * dBran2Thick * 0.5;
|
||
pt4 = arPtsV[3] - vtNor * dBran2Thick * 0.5;
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = pt1;
|
||
el.ptGe[1] = pt2;
|
||
el.ptGe[2] = pt2;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pt3;
|
||
el.ptGe[1] = pt4;
|
||
el.ptGe[2] = pt4;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
AcGeMatrix3d mat;
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
vtNor.normalize();
|
||
vtNor *= dThick * 0.5;
|
||
mat.setToTranslation(vtNor);
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
arPtsV.append(arPtsV[i].transformBy(mat));
|
||
}
|
||
vtNor.normalize();
|
||
vtNor *= -dThick;
|
||
mat.setToTranslation(vtNor);
|
||
for (i = 0; i < 4; i++)
|
||
{
|
||
arPtsV.append(arPtsV[i].transformBy(mat));
|
||
}
|
||
//外轮廓
|
||
if (IsStartVertAlignment())
|
||
{
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPtsV[4];
|
||
el.ptGe[1] = arPtsV[7];
|
||
el.ptGe[2] = arPtsV[7];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPtsV[8];
|
||
el.ptGe[1] = arPtsV[11];
|
||
el.ptGe[2] = arPtsV[11];
|
||
cplCurve.append(el);
|
||
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
|
||
el.ptGe[0] = arPtsV[4];
|
||
el.ptGe[1] = arPtsV[8];
|
||
el.ptGe[2] = arPtsV[8];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[7];
|
||
el.ptGe[1] = arPtsV[11];
|
||
el.ptGe[2] = arPtsV[11];
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = arPtsV[5];
|
||
el.ptGe[1] = arPtsV[9];
|
||
el.ptGe[2] = arPtsV[9];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[6];
|
||
el.ptGe[1] = arPtsV[10];
|
||
el.ptGe[2] = arPtsV[10];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[5];
|
||
el.ptGe[1] = arPtsV[6];
|
||
el.ptGe[2] = arPtsV[6];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[9];
|
||
el.ptGe[1] = arPtsV[10];
|
||
el.ptGe[2] = arPtsV[10];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
else if (IsBr1VertAlignment())
|
||
{
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
|
||
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = arPtsV[6];
|
||
el.ptGe[1] = arPtsV[10];
|
||
el.ptGe[2] = arPtsV[10];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[9];
|
||
el.ptGe[1] = arPtsV[13];
|
||
el.ptGe[2] = arPtsV[13];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPtsV[7];
|
||
el.ptGe[1] = arPtsV[11];
|
||
el.ptGe[2] = arPtsV[11];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[8];
|
||
el.ptGe[1] = arPtsV[12];
|
||
el.ptGe[2] = arPtsV[12];
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
el.ptGe[0] = arPtsV[6];
|
||
el.ptGe[1] = arPtsV[9];
|
||
el.ptGe[2] = arPtsV[9];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[13];
|
||
el.ptGe[1] = arPtsV[10];
|
||
el.ptGe[2] = arPtsV[10];
|
||
cplCurve.append(el);
|
||
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dCenWidth;
|
||
|
||
el.ptGe[0] = arPtsV[7];
|
||
el.ptGe[1] = arPtsV[8];
|
||
el.ptGe[2] = arPtsV[8];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[11];
|
||
el.ptGe[1] = arPtsV[12];
|
||
el.ptGe[2] = arPtsV[12];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
// 直角
|
||
BOOL ImpHvacCross::MakeLinearCross2dCurves(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
MakeInterCross2dCurves(cplCurve, nType);
|
||
return FALSE;
|
||
}
|
||
|
||
// 交叉
|
||
BOOL ImpHvacCross::MakeInterCross2dCurves(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
AcGePoint3dArray arPts;
|
||
GetIntersectCrossPts(arPts);
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
//水平放置
|
||
if (IsHorzAlignment())
|
||
{
|
||
//方口
|
||
if (arPts.length() == 29)
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPts[1];
|
||
el.ptGe[1] = arPts[3];
|
||
el.ptGe[2] = arPts[3];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[3];
|
||
el.ptGe[1] = arPts[11];
|
||
el.ptGe[2] = arPts[11];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[11];
|
||
el.ptGe[1] = arPts[8];
|
||
el.ptGe[2] = arPts[8];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[7];
|
||
el.ptGe[1] = arPts[9];
|
||
el.ptGe[2] = arPts[9];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[9];
|
||
el.ptGe[1] = arPts[17];
|
||
el.ptGe[2] = arPts[17];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[17];
|
||
el.ptGe[1] = arPts[14];
|
||
el.ptGe[2] = arPts[14];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[13];
|
||
el.ptGe[1] = arPts[15];
|
||
el.ptGe[2] = arPts[15];
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = arPts[15];
|
||
el.ptGe[1] = arPts[23];
|
||
el.ptGe[2] = arPts[23];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[23];
|
||
el.ptGe[1] = arPts[20];
|
||
el.ptGe[2] = arPts[20];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[21];
|
||
el.ptGe[1] = arPts[5];
|
||
el.ptGe[2] = arPts[5];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[5];
|
||
el.ptGe[1] = arPts[2];
|
||
el.ptGe[2] = arPts[2];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[19];
|
||
el.ptGe[1] = arPts[21];
|
||
el.ptGe[2] = arPts[21];
|
||
cplCurve.append(el);
|
||
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = arPts[8];
|
||
el.ptGe[1] = arPts[7];
|
||
el.ptGe[2] = arPts[7];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[14];
|
||
el.ptGe[1] = arPts[13];
|
||
el.ptGe[2] = arPts[13];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[20];
|
||
el.ptGe[1] = arPts[19];
|
||
el.ptGe[2] = arPts[19];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[2];
|
||
el.ptGe[1] = arPts[1];
|
||
el.ptGe[2] = arPts[1];
|
||
cplCurve.append(el);
|
||
}
|
||
//中心线
|
||
if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
AcGePoint3d ptCen = arPts[24];
|
||
if (arPts[0].distanceTo(arPts[27]) < arPts[0].distanceTo(arPts[24]))
|
||
{
|
||
ptCen = arPts[27];
|
||
}
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = arPts[0];
|
||
el.ptGe[1] = arPts[4];
|
||
el.ptGe[2] = arPts[4];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[4];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[6];
|
||
el.ptGe[1] = arPts[10];
|
||
el.ptGe[2] = arPts[10];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[10];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[12];
|
||
el.ptGe[1] = arPts[16];
|
||
el.ptGe[2] = arPts[16];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[16];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[18];
|
||
el.ptGe[1] = arPts[22];
|
||
el.ptGe[2] = arPts[22];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPts[22];
|
||
el.ptGe[1] = ptCen;
|
||
el.ptGe[2] = ptCen;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
//垂直放置（立管）
|
||
else if (IsVertAlignment())
|
||
{
|
||
double dThick = 300.0;
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
AcGePoint3d pt;
|
||
AcGePoint3dArray arPtsV;
|
||
//开始矢量和Z轴垂直（前视）
|
||
if (IsStartVertAlignment())
|
||
{
|
||
//标高与开始点相同
|
||
pt = arPts[1];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[8];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[7];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[14];
|
||
pt.z = arPts[0].z;
|
||
arPtsV.append(pt);
|
||
}
|
||
//br1矢量和Z轴垂直（左视）
|
||
else if (IsBr1VertAlignment())
|
||
{
|
||
//标高与Br1点相同
|
||
pt = arPts[8];
|
||
pt.z = arPts[6].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[1];
|
||
pt.z = arPts[6].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[2];
|
||
pt.z = arPts[6].z;
|
||
arPtsV.append(pt);
|
||
pt = arPts[19];
|
||
pt.z = arPts[6].z;
|
||
arPtsV.append(pt);
|
||
}
|
||
else
|
||
return FALSE;
|
||
|
||
AcGeMatrix3d mat;
|
||
AcGeVector3d vtNor = GetSectNormal();
|
||
vtNor.normalize();
|
||
vtNor *= dThick * 0.5;
|
||
mat.setToTranslation(vtNor);
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
arPtsV.append(arPtsV[i].transformBy(mat));
|
||
}
|
||
vtNor.normalize();
|
||
vtNor *= -dThick;
|
||
mat.setToTranslation(vtNor);
|
||
for (i = 0; i < 4; i++)
|
||
{
|
||
arPtsV.append(arPtsV[i].transformBy(mat));
|
||
}
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = arPtsV[4];
|
||
el.ptGe[1] = arPtsV[7];
|
||
el.ptGe[2] = arPtsV[7];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[8];
|
||
el.ptGe[1] = arPtsV[11];
|
||
el.ptGe[2] = arPtsV[11];
|
||
cplCurve.append(el);
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
|
||
el.ptGe[0] = arPtsV[4];
|
||
el.ptGe[1] = arPtsV[8];
|
||
el.ptGe[2] = arPtsV[8];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[7];
|
||
el.ptGe[1] = arPtsV[11];
|
||
el.ptGe[2] = arPtsV[11];
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
el.dWidth = dCenWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = arPtsV[5];
|
||
el.ptGe[1] = arPtsV[9];
|
||
el.ptGe[2] = arPtsV[9];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[6];
|
||
el.ptGe[1] = arPtsV[10];
|
||
el.ptGe[2] = arPtsV[10];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[5];
|
||
el.ptGe[1] = arPtsV[6];
|
||
el.ptGe[2] = arPtsV[6];
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = arPtsV[9];
|
||
el.ptGe[1] = arPtsV[10];
|
||
el.ptGe[2] = arPtsV[10];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
//斜接俯视顶点
|
||
// 8 6 7
|
||
// ╱╲
|
||
// ╱ ╱
|
||
// 1 ╱ ╱12
|
||
// │ └──┐5
|
||
// 0│ │3
|
||
// │ ┌──┘4
|
||
// 2 ╲ ╲13
|
||
// ╲ ╲
|
||
// ╲╱
|
||
// 10 9 11
|
||
//
|
||
|
||
BOOL ImpHvacCross::GetInclineCirPts(AcGePoint3dArray& arPts, BOOL nDefault) const
|
||
{
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
|
||
double dSWidth = MayAsMUnit(300.0), dEWidth = MayAsMUnit(300.0), dThick = MayAsMUnit(200.0);
|
||
double dBr1Width = MayAsMUnit(300.0), dBr2Width = MayAsMUnit(300.0), dPlusEdge = MayAsMUnit(50.0);
|
||
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
m_pXDataMap->GetAt(HCRS_StartDiameter, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_EndDiameter, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Diameter, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Diameter, dBr2Width);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis;
|
||
vtNor = GetSectNormal();
|
||
dSWidth *= 0.5;
|
||
dEWidth *= 0.5;
|
||
dBr1Width *= 0.5;
|
||
dBr2Width *= 0.5;
|
||
AcGePoint3d ptTemp1,ptTemp2,ptInter;
|
||
AcGeVector3d vtStartv, vtEndv, vtBr1v, vtBr2v;
|
||
vtStartv = vtStart;
|
||
vtEndv = vtEnd;
|
||
vtBr1v = vtBr1;
|
||
vtBr2v = vtBr2;
|
||
vtStartv.rotateBy(PI * 0.5,vtNor);
|
||
vtEndv.rotateBy(PI * 0.5,vtNor);
|
||
vtBr1v.rotateBy(PI * 0.5,vtNor);
|
||
vtBr2v.rotateBy(PI * 0.5,vtNor);
|
||
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtBr1.normalize();
|
||
vtBr2.normalize();
|
||
vtStartv.normalize();
|
||
vtEndv.normalize();
|
||
vtBr1v.normalize();
|
||
vtBr2v.normalize();
|
||
|
||
// 0-23点
|
||
arPts.append(ptStart);
|
||
arPts.append(ptStart + vtStartv * dSWidth);
|
||
arPts.append(ptStart - vtStartv * dSWidth);
|
||
arPts.append(ptEnd);
|
||
arPts.append(ptEnd + vtEndv * dEWidth);
|
||
arPts.append(ptEnd - vtEndv * dEWidth);
|
||
arPts.append(ptBr1);
|
||
arPts.append(ptBr1 + vtBr1v * dBr1Width);
|
||
arPts.append(ptBr1 - vtBr1v * dBr1Width);
|
||
arPts.append(ptBr2);
|
||
arPts.append(ptBr2 + vtBr2v * dBr2Width);
|
||
arPts.append(ptBr2 - vtBr2v * dBr2Width);
|
||
arPts.append(arPts[0] - vtStart * dPlusEdge);
|
||
arPts.append(arPts[1] - vtStart * dPlusEdge);
|
||
arPts.append(arPts[2] - vtStart * dPlusEdge);
|
||
arPts.append(arPts[3] - vtEnd * dPlusEdge);
|
||
arPts.append(arPts[4] - vtEnd * dPlusEdge);
|
||
arPts.append(arPts[5] - vtEnd * dPlusEdge);
|
||
arPts.append(arPts[6] - vtBr1 * dPlusEdge);
|
||
arPts.append(arPts[7] - vtBr1 * dPlusEdge);
|
||
arPts.append(arPts[8] - vtBr1 * dPlusEdge);
|
||
arPts.append(arPts[9] - vtBr2 * dPlusEdge);
|
||
arPts.append(arPts[10] - vtBr2 * dPlusEdge);
|
||
arPts.append(arPts[11] - vtBr2 * dPlusEdge);
|
||
|
||
// 24-25 关键点
|
||
AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
|
||
AcGePoint3d ptInt = AcGePoint3d::kOrigin;
|
||
if (GetIntersectWith(arPts[13], arPts[20], arPts[12], arPts[18], ptTmp))
|
||
{
|
||
if (GetIntersectWith(ptTmp, arPts[19], arPts[17], arPts[13], ptInt))
|
||
{
|
||
arPts.append(ptInt);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
AcGeVector3d vt1 = AcGeVector3d::kIdentity;
|
||
AcGeVector3d vt2 = AcGeVector3d::kIdentity;
|
||
vt1 = arPts[12] - arPts[18];
|
||
vt1.normalize();
|
||
vt2 = arPts[13] - arPts[17];
|
||
vt2.normalize();
|
||
if (GetIntersectWith(arPts[19], arPts[17], vt1, vt2, ptInt))
|
||
{
|
||
arPts.append(ptInt);
|
||
}
|
||
}
|
||
|
||
if (GetIntersectWith(arPts[14], arPts[22], arPts[12], arPts[21], ptTmp))
|
||
{
|
||
if (GetIntersectWith(ptTmp, arPts[23], arPts[16], arPts[14], ptInt))
|
||
{
|
||
arPts.append(ptInt);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
AcGeVector3d vt1 = AcGeVector3d::kIdentity;
|
||
AcGeVector3d vt2 = AcGeVector3d::kIdentity;
|
||
vt1 = arPts[12] - arPts[21];
|
||
vt1.normalize();
|
||
vt2 = arPts[14] - arPts[16];
|
||
vt2.normalize();
|
||
if (GetIntersectWith(arPts[23], arPts[16], vt1, vt2, ptInt))
|
||
{
|
||
arPts.append(ptInt);
|
||
}
|
||
}
|
||
return arPts.length() == 26;
|
||
}
|
||
|
||
BOOL ImpHvacCross::GetInsertCirPts(AcGePoint3dArray& arPts) const
|
||
{
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
double dSWidth = 300.0, dEWidth = 300.0, dBr1Width = 300.0, dBr2Width = 300.0, dPlus = 25.0;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBr2Width);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlus);
|
||
|
||
AcGePoint3d ptInter;
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis;
|
||
vtNor = GetSectNormal();
|
||
AcGeVector3d vtStartv, vtEndv, vtBr1v, vtBr2v;
|
||
vtStartv = vtStart;
|
||
vtEndv = vtEnd;
|
||
vtBr1v = vtBr1;
|
||
vtBr2v = vtBr2;
|
||
vtStartv.rotateBy(PI * 0.5,vtNor);
|
||
vtEndv.rotateBy(PI * 0.5,vtNor);
|
||
vtBr1v.rotateBy(PI * 0.5,vtNor);
|
||
vtBr2v.rotateBy(PI * 0.5,vtNor);
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtBr1.normalize();
|
||
vtBr2.normalize();
|
||
vtStartv.normalize();
|
||
vtEndv.normalize();
|
||
vtBr1v.normalize();
|
||
vtBr2v.normalize();
|
||
|
||
// 0 - 17
|
||
arPts.append(ptStart);
|
||
arPts.append(ptStart + vtStartv * dSWidth * 0.5);
|
||
arPts.append(ptStart - vtStartv * dSWidth * 0.5);
|
||
arPts.append(ptEnd);
|
||
arPts.append(ptEnd + vtEndv * dEWidth * 0.5);
|
||
arPts.append(ptEnd - vtEndv * dEWidth * 0.5);
|
||
arPts.append(ptBr1);
|
||
arPts.append(ptBr1 + vtBr1v * dBr1Width * 0.5);
|
||
arPts.append(ptBr1 - vtBr1v * dBr1Width * 0.5);
|
||
arPts.append(ptBr2);
|
||
arPts.append(ptBr2 + vtBr2v * dBr2Width * 0.5);
|
||
arPts.append(ptBr2 - vtBr2v * dBr2Width * 0.5);
|
||
arPts.append(arPts[0] + vtEnd * dPlus);
|
||
arPts.append(arPts[1] + vtEnd * dPlus);
|
||
arPts.append(arPts[2] + vtEnd * dPlus);
|
||
arPts.append(arPts[3] + vtStart * dPlus);
|
||
arPts.append(arPts[4] + vtStart * dPlus);
|
||
arPts.append(arPts[5] + vtStart * dPlus);
|
||
|
||
// 18 - 21
|
||
AcGeVector3d vtGeTmp = arPts[13] - arPts[17];
|
||
vtGeTmp.normalize();
|
||
if (GetIntersectWith(arPts[13], arPts[8], vtGeTmp, vtBr1, ptInter))
|
||
{
|
||
arPts.append(ptInter);
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
if (GetIntersectWith(arPts[17], arPts[7], vtGeTmp, vtBr1, ptInter))
|
||
{
|
||
arPts.append(ptInter);
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
vtGeTmp = arPts[14] - arPts[16];
|
||
vtGeTmp.normalize();
|
||
if (GetIntersectWith(arPts[14], arPts[10], vtGeTmp, vtBr2, ptInter))
|
||
{
|
||
arPts.append(ptInter);
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
if (GetIntersectWith(arPts[16], arPts[11], vtGeTmp, vtBr2, ptInter))
|
||
{
|
||
arPts.append(ptInter);
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
// 22 - 23
|
||
AcGePoint3d ptArc;
|
||
double dDis1 = arPts[8].distanceTo(arPts[18]);
|
||
double dDis2 = arPts[7].distanceTo(arPts[19]);
|
||
ptArc = arPts[6] - vtBr1 * ((dDis1 + dDis2) * 0.5 + dBr1Width * 0.3);
|
||
arPts.append(ptArc);
|
||
dDis1 = arPts[10].distanceTo(arPts[20]);
|
||
dDis2 = arPts[11].distanceTo(arPts[21]);
|
||
ptArc = arPts[9] - vtBr2 * ((dDis1 + dDis2) * 0.5 + dBr2Width * 0.3);
|
||
arPts.append(ptArc);
|
||
|
||
return arPts.length() == 24;
|
||
}
|
||
|
||
// 4 6
|
||
// 方口 10┏━━-━━┓11 圆口有50直边 8 ┏━━-━━┓7
|
||
// ┃ ┆ ┃ ┃ ┆ ┃
|
||
// 9┃ ┆ ┃ 24┃11 10 9 ┃
|
||
// 8 ┏━━━-━┛ ┆ ┃12 1 ┏━━━-━┛ 32 ┃25
|
||
// ┃ 7 ┆ ┗━━━━┓13 ┃ 3 31 ┆ ┗━━━━┓14
|
||
// 0 ┃--------------┆1 ┃ 0 ┃--4-----------┆ 28 17 ┃
|
||
// ┃ 3┆-----------------┃2 ┃ 30 ┆-------------16--┃12
|
||
// ┃ ┆ 5 ┃ ┃ 5 33 29 15 ┃
|
||
// 19 ┗━━━┓ ┆ ┏━━━━━━┛14 2 ┗━━━┓ ┆ ┏━━━━━━┛13
|
||
// 18┃ ┆ ┃15 27┃21 22 23┃26
|
||
// ┃ ┆ ┃ ┃ ┆ ┃
|
||
// 17┗━━━━┛16 19┗━━━━┛20
|
||
// 6 18
|
||
|
||
BOOL ImpHvacCross::GetCrossPts(AcGePoint3dArray& arPts, BOOL bDefault, BOOL bIs3D) const
|
||
{
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
double dSWidth = 300.0, dEWidth = 300.0, dThick = 200.0, dBr1Width = 300.0, dBr2Width = 300.0;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBr2Width);
|
||
double dRadRatio = 1.0;
|
||
m_pXDataMap->GetAt(HCRS_RadRatio, dRadRatio);
|
||
if (!bIs3D)
|
||
{
|
||
//单线遮挡宽度
|
||
SetSingleDashWidth(dSWidth,dEWidth,dBr1Width,dBr2Width);
|
||
}
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis;
|
||
vtNor = GetSectNormal();
|
||
dSWidth *= 0.5;
|
||
dEWidth *= 0.5;
|
||
dBr1Width *= 0.5;
|
||
dBr2Width *= 0.5;
|
||
AcGePoint3d ptTemp1,ptTemp2,ptInter;
|
||
AcGeVector3d vtStartv, vtEndv, vtBr1v, vtBr2v;
|
||
vtStartv = vtStart;
|
||
vtEndv = vtEnd;
|
||
vtBr1v = vtBr1;
|
||
vtBr2v = vtBr2;
|
||
vtStartv.rotateBy(PI * 0.5,vtNor);
|
||
vtEndv.rotateBy(PI * 0.5,vtNor);
|
||
vtBr1v.rotateBy(PI * 0.5,vtNor);
|
||
vtBr2v.rotateBy(PI * 0.5,vtNor);
|
||
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtBr1.normalize();
|
||
vtBr2.normalize();
|
||
vtStartv.normalize();
|
||
vtEndv.normalize();
|
||
vtBr1v.normalize();
|
||
vtBr2v.normalize();
|
||
AecHvac::HvacCrossType eType = AecHvac::eOrthoCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eType);
|
||
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
if (eSectType == eRect)
|
||
{
|
||
AcGePlane planSta(ptStart, vtNor);
|
||
AcGePlane planBr1(ptBr1, vtNor);
|
||
AcGePlane planBr2(ptBr2, vtNor);
|
||
|
||
AcGePlane planEnd(ptEnd, vtNor);
|
||
|
||
// 投影至主矢量平面
|
||
if (eType == AecHvac::eInsertCross || eType == AecHvac::eInsertIntubCross)
|
||
{
|
||
ptBr1 = ptBr1.orthoProject(planSta);
|
||
ptBr2 = ptBr2.orthoProject(planSta);
|
||
}
|
||
|
||
//0-7
|
||
arPts.append(ptStart);
|
||
GetIntersectWith(ptStart, ptBr1, vtStart, vtBr1, ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptEnd);
|
||
GetIntersectWith(ptEnd, ptBr2, vtEnd, vtBr2, ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptBr1);
|
||
GetIntersectWith(ptEnd, ptBr1, vtEnd, vtBr1, ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptBr2);
|
||
GetIntersectWith(ptStart, ptBr2, vtStart, vtBr2, ptInter);
|
||
arPts.append(ptInter);
|
||
|
||
//8-10
|
||
ptTemp1 = ptStart + vtStartv * dSWidth;
|
||
arPts.append(ptTemp1);
|
||
ptTemp2 = ptBr1 - vtBr1v * dBr1Width;
|
||
GetIntersectWith(ptTemp1,ptTemp2,vtStart,vtBr1,ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptTemp2);
|
||
//11-13
|
||
ptTemp1 = ptBr1 + vtBr1v * dBr1Width;
|
||
arPts.append(ptTemp1);
|
||
ptTemp2 = ptEnd - vtEndv * dEWidth;
|
||
GetIntersectWith(ptTemp1,ptTemp2,vtBr1,vtEnd,ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptTemp2);
|
||
//14-16
|
||
ptTemp1 = ptEnd + vtEndv * dEWidth;
|
||
arPts.append(ptTemp1);
|
||
ptTemp2 = ptBr2 - vtBr2v * dBr2Width;
|
||
GetIntersectWith(ptTemp1,ptTemp2,vtEnd,vtBr2,ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptTemp2);
|
||
//17-19
|
||
ptTemp1 = ptBr2 + vtBr2v * dBr2Width;
|
||
arPts.append(ptTemp1);
|
||
ptTemp2 = ptStart - vtStartv * dSWidth;
|
||
GetIntersectWith(ptTemp1,ptTemp2,vtBr2,vtStart,ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptTemp2);
|
||
|
||
BOOL bIsOK = TRUE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[8],arPts[9],vtStart))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[19],arPts[18],vtStart))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[13],arPts[12],vtEnd))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[14],arPts[15],vtEnd))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[10],arPts[9],vtBr1))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[11],arPts[12],vtBr1))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[16],arPts[15],vtBr2))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[17],arPts[18],vtBr2))
|
||
bIsOK = FALSE;
|
||
|
||
//重新计算标准点
|
||
if (bDefault)
|
||
{
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
double dPlusEnd = MayAsMUnit(50.0);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
AcGePoint3d pt;
|
||
double dLength = max(dBr1Width,dBr2Width);
|
||
if (eType == AecHvac::eOrthoCross)
|
||
{
|
||
dLength = dLength * 2 * dRadRatio;
|
||
arPts[0] = GetFinalPt(arPts[0],arPts[1],arPts[7],arPts[9],arPts[18],vtStart,dLength);
|
||
arPts[2] = GetFinalPt(arPts[2],arPts[3],arPts[5],arPts[15],arPts[12],vtEnd,dLength);
|
||
double dMax = max(dSWidth, dEWidth);
|
||
arPts[4] = arPts[1] + vtBr1 * (dMax + dBr1Width);
|
||
arPts[6] = arPts[7] + vtBr2 * (dMax + dBr2Width);
|
||
}
|
||
//承差
|
||
else
|
||
{
|
||
double dPlusSta = MayAsMUnit(100.0);
|
||
double dPlusBr = MayAsMUnit(150.0);
|
||
|
||
dLength = dLength * 2 * dRadRatio;
|
||
arPts[0] = GetFinalPt(arPts[0],arPts[1],arPts[7],arPts[9],arPts[18],vtStart,dLength);
|
||
arPts[2] = GetFinalPtEnd(arPts[2],arPts[3],arPts[5],arPts[15],arPts[12],vtEnd);
|
||
|
||
AcGePoint3d ptTest = arPts[2];
|
||
arPts[2] = arPts[2].orthoProject(planEnd);
|
||
ptTest = arPts[2];
|
||
|
||
AcGePoint3d ptCor1 = arPts[9],ptCor2 = arPts[18],ptCor3 = arPts[12],ptCor4 = arPts[15];
|
||
|
||
AcGePoint3d ptDis = arPts[4] + vtBr1 * 10000;
|
||
double dis1 = ptDis.distanceTo(ptCor1);
|
||
double dis2 = ptDis.distanceTo(ptCor3);
|
||
if (dis1 < dis2)
|
||
{
|
||
arPts[4] = (ptCor1 + vtBr1 * (dPlusBr + dPlusEdge)) + vtBr1v * dBr1Width;
|
||
}
|
||
else
|
||
{
|
||
arPts[4] = (ptCor3 + vtBr1 * (dPlusBr + dPlusEdge)) - vtBr1v * dBr1Width;
|
||
}
|
||
|
||
ptDis = arPts[6] + vtBr2 * 10000;
|
||
dis1 = ptDis.distanceTo(ptCor2);
|
||
dis2 = ptDis.distanceTo(ptCor4);
|
||
if (dis1 < dis2)
|
||
{
|
||
arPts[6] = (ptCor2 + vtBr2 * (dPlusBr + dPlusEdge)) - vtBr2v * dBr2Width;
|
||
}
|
||
else
|
||
{
|
||
arPts[6] = (ptCor4 + vtBr2 * (dPlusBr + dPlusEdge)) + vtBr2v * dBr2Width;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 投影回支管平面
|
||
if (eType == AecHvac::eInsertCross || eType == AecHvac::eInsertIntubCross)
|
||
{
|
||
AcGePoint3d ptProj = AcGePoint3d::kOrigin;
|
||
ptProj = arPts[4];
|
||
arPts.setAt(4, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[10];
|
||
arPts.setAt(10, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[11];
|
||
arPts.setAt(11, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[9];
|
||
arPts.setAt(9, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[12];
|
||
arPts.setAt(12, ptProj.orthoProject(planBr1));
|
||
|
||
ptProj = arPts[6];
|
||
arPts.setAt(6, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[16];
|
||
arPts.setAt(16, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[17];
|
||
arPts.setAt(17, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[15];
|
||
arPts.setAt(15, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[18];
|
||
arPts.setAt(18, ptProj.orthoProject(planBr2));
|
||
}
|
||
return bIsOK;
|
||
}
|
||
if(eSectType == eCircle)
|
||
{
|
||
//求直边段的各个点
|
||
GetPlusEdgePts(arPts, ptStart, vtStart, vtNor, dSWidth);
|
||
GetPlusEdgePts(arPts, ptBr1, vtBr1, vtNor, dBr1Width);
|
||
GetPlusEdgePts(arPts, ptEnd, vtEnd, vtNor, dEWidth);
|
||
GetPlusEdgePts(arPts, ptBr2, vtBr2, vtNor, dBr2Width);
|
||
|
||
//求交点24,25,26,27
|
||
GetIntersectWith(arPts[3], arPts[17], arPts[11], arPts[8], ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(arPts[3], arPts[17], arPts[7], arPts[9], ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(arPts[5], arPts[15], arPts[20], arPts[23], ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(arPts[5], arPts[15], arPts[19], arPts[21], ptInter);
|
||
arPts.append(ptInter);
|
||
//中心点28,29,30,31
|
||
GetIntersectWith(ptStart, ptBr1, vtStart, vtBr1, ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(ptEnd, ptBr1, vtEnd, vtBr1, ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(ptEnd, ptBr2, vtEnd, vtBr2, ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(ptStart, ptBr2, vtStart, vtBr2, ptInter);
|
||
arPts.append(ptInter);
|
||
//计算上下两条圆弧的点32,33
|
||
AcGePoint3d ptArc;
|
||
double dDis1 = arPts[11].distanceTo(arPts[24]);
|
||
double dDis2 = arPts[9].distanceTo(arPts[25]);
|
||
ptArc = arPts[10] - vtBr1 * ((dDis1 + dDis2) * 0.5 + dBr1Width * 0.3);
|
||
arPts.append(ptArc);
|
||
dDis1 = arPts[21].distanceTo(arPts[27]);
|
||
dDis2 = arPts[23].distanceTo(arPts[26]);
|
||
ptArc = arPts[22] - vtBr2 * ((dDis1 + dDis2) * 0.5 + dBr2Width * 0.3);
|
||
arPts.append(ptArc);
|
||
|
||
BOOL bIsOK = TRUE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[1],arPts[24],vtStart))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[2],arPts[27],vtStart))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[13],arPts[/*12*/26],vtEnd))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[14],arPts[25],vtEnd))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[8],arPts[24],vtBr1))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[7],arPts[25],vtBr1))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[20],arPts[26],vtBr2))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[19],arPts[27],vtBr2))
|
||
bIsOK = FALSE;
|
||
//重新计算标准点
|
||
if (bDefault)
|
||
{
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
double dPlusEnd = MayAsMUnit(50.0);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
AcGePoint3d pt;
|
||
double dLength = max(dBr1Width,dBr2Width);
|
||
|
||
dLength = dLength * 2 * dRadRatio;
|
||
arPts[0] = GetFinalPt(arPts[0],arPts[28],arPts[31],arPts[24],arPts[27],vtStart,dLength);
|
||
arPts[2] = GetFinalPt(arPts[12],arPts[29],arPts[30],arPts[25],arPts[26],vtEnd,dLength);
|
||
arPts[4] = GetFinalPt(arPts[6],arPts[28],arPts[29],arPts[24],arPts[25],vtBr1,dLength);
|
||
arPts[6] = GetFinalPt(arPts[18],arPts[31],arPts[30],arPts[27],arPts[26],vtBr2,dLength);
|
||
}
|
||
return bIsOK;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
// 4 6
|
||
// 方口 10┏━━-━━┓11 圆口有50直边 8 ┏━━-━━┓7
|
||
// ┃ ┆ ┃ ┃ ┆ ┃
|
||
// 9┃ ┆ ┃ 24┃11 10 9 ┃
|
||
// 8 ┏━━━-━┛ ┆ ┃12 1 ┏━━━-━┛ 29 ┃25
|
||
// ┃ 7 ┆ ┗━━━━┓13 ┃ 3 ┆ ┗━━━━┓14
|
||
// 0 ┃--------------┆1 ┃ 0 ┃--4--------- 28 17 ┃
|
||
// ┃ 3┆-----------------┃2 ┃ ------------16--┃12
|
||
// ┃ ┆ 5 ┃ ┃ 5 30 15 ┃
|
||
// 19 ┗━━━┓ ┆ ┏━━━━━━┛14 2 ┗━━━┓ ┆ ┏━━━━━━┛13
|
||
// 18┃ ┆ ┃15 27┃21 22 23┃26
|
||
// ┃ ┆ ┃ ┃ ┆ ┃
|
||
// 17┗━━━━┛16 19┗━━━━┛20
|
||
// 临时 6 18
|
||
|
||
BOOL ImpHvacCross::GetCrossPtsCirRedu(AcGePoint3dArray& arPts) const
|
||
{
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
double dSWidth = 300.0, dEWidth = 300.0, dThick = 200.0, dBr1Width = 300.0, dBr2Width = 300.0;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBr2Width);
|
||
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis;
|
||
vtNor = GetSectNormal();
|
||
dSWidth *= 0.5;
|
||
dEWidth *= 0.5;
|
||
dBr1Width *= 0.5;
|
||
dBr2Width *= 0.5;
|
||
AcGePoint3d ptTemp1,ptTemp2,ptInter;
|
||
AcGeVector3d vtStartv, vtEndv, vtBr1v, vtBr2v;
|
||
vtStartv = vtStart;
|
||
vtEndv = vtEnd;
|
||
vtBr1v = vtBr1;
|
||
vtBr2v = vtBr2;
|
||
vtStartv.rotateBy(PI * 0.5,vtNor);
|
||
vtEndv.rotateBy(PI * 0.5,vtNor);
|
||
vtBr1v.rotateBy(PI * 0.5,vtNor);
|
||
vtBr2v.rotateBy(PI * 0.5,vtNor);
|
||
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtBr1.normalize();
|
||
vtBr2.normalize();
|
||
vtStartv.normalize();
|
||
vtEndv.normalize();
|
||
vtBr1v.normalize();
|
||
vtBr2v.normalize();
|
||
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
if (eSectType == eRect)
|
||
{
|
||
//0-7
|
||
arPts.append(ptStart);
|
||
GetIntersectWith(ptStart, ptBr1, vtStart, vtBr1, ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptEnd);
|
||
GetIntersectWith(ptEnd, ptBr2, vtEnd, vtBr2, ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptBr1);
|
||
GetIntersectWith(ptEnd, ptBr1, vtEnd, vtBr1, ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptBr2);
|
||
GetIntersectWith(ptStart, ptBr2, vtStart, vtBr2, ptInter);
|
||
arPts.append(ptInter);
|
||
|
||
//8-10
|
||
ptTemp1 = ptStart + vtStartv * dSWidth;
|
||
arPts.append(ptTemp1);
|
||
ptTemp2 = ptBr1 - vtBr1v * dBr1Width;
|
||
GetIntersectWith(ptTemp1,ptTemp2,vtStart,vtBr1,ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptTemp2);
|
||
//11-13
|
||
ptTemp1 = ptBr1 + vtBr1v * dBr1Width;
|
||
arPts.append(ptTemp1);
|
||
ptTemp2 = ptEnd - vtEndv * dEWidth;
|
||
GetIntersectWith(ptTemp1,ptTemp2,vtBr1,vtEnd,ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptTemp2);
|
||
//14-16
|
||
ptTemp1 = ptEnd + vtEndv * dEWidth;
|
||
arPts.append(ptTemp1);
|
||
ptTemp2 = ptBr2 - vtBr2v * dBr2Width;
|
||
GetIntersectWith(ptTemp1,ptTemp2,vtEnd,vtBr2,ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptTemp2);
|
||
//17-19
|
||
ptTemp1 = ptBr2 + vtBr2v * dBr2Width;
|
||
arPts.append(ptTemp1);
|
||
ptTemp2 = ptStart - vtStartv * dSWidth;
|
||
GetIntersectWith(ptTemp1,ptTemp2,vtBr2,vtStart,ptInter);
|
||
arPts.append(ptInter);
|
||
arPts.append(ptTemp2);
|
||
}
|
||
else if(eSectType == eCircle)
|
||
{
|
||
//求直边段的各个点
|
||
GetPlusEdgePts(arPts, ptStart, vtStart, vtNor, dSWidth);
|
||
GetPlusEdgePts(arPts, ptBr1, vtBr1, vtNor, dBr1Width);
|
||
GetPlusEdgePts(arPts, ptEnd, vtEnd, vtNor, dEWidth);
|
||
GetPlusEdgePts(arPts, ptBr2, vtBr2, vtNor, dBr2Width);
|
||
|
||
//求交点24,25,26,27
|
||
GetIntersectWith(arPts[3], arPts[17], arPts[11], arPts[21], ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(arPts[3], arPts[17], arPts[9], arPts[23], ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(arPts[5], arPts[15], arPts[9], arPts[23], ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(arPts[5], arPts[15], arPts[11], arPts[21], ptInter);
|
||
arPts.append(ptInter);
|
||
//中心点28
|
||
GetIntersectWith(arPts[4], arPts[16], arPts[10], arPts[22], ptInter);
|
||
arPts.append(ptInter);
|
||
//计算上下两条圆弧的点29,30
|
||
AcGePoint3d ptArc;
|
||
AcGeVector3d vtBr1ToBr2 = arPts[10] - arPts[22];
|
||
vtBr1ToBr2.normalize();
|
||
double dDis1 = arPts[11].distanceTo(arPts[24]);
|
||
double dDis2 = arPts[9].distanceTo(arPts[25]);
|
||
ptArc = arPts[10] - vtBr1ToBr2 * ((dDis1 + dDis2) * 0.5 + dBr1Width * 0.3);
|
||
arPts.append(ptArc);
|
||
dDis1 = arPts[21].distanceTo(arPts[27]);
|
||
dDis2 = arPts[23].distanceTo(arPts[26]);
|
||
ptArc = arPts[22] + vtBr1ToBr2 * ((dDis1 + dDis2) * 0.5 + dBr2Width * 0.3);
|
||
arPts.append(ptArc);
|
||
}
|
||
return arPts.length() > 0;
|
||
}
|
||
|
||
//
|
||
// 8
|
||
// 11╭───╮12
|
||
// 3┌──-│ │-──┐4
|
||
// 0│ 7 │ 2 │9 │1
|
||
// 6└──-│ │-──┘5
|
||
// 14╰───╯13
|
||
// 10
|
||
//
|
||
|
||
BOOL ImpHvacCross::GetCrossPtsVerCir(AcGePoint3dArray& arPts) const
|
||
{
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
double dSWidth = 300.0, dEWidth = 300.0, dThick = 200.0, dBr1Width = 300.0, dBr2Width = 300.0;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBr2Width);
|
||
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis;
|
||
vtNor = GetSectNormal();
|
||
dSWidth *= 0.5;
|
||
dEWidth *= 0.5;
|
||
dBr1Width *= 0.5;
|
||
dBr2Width *= 0.5;
|
||
|
||
//开始矢量和Z轴垂直（前视）
|
||
if (IsStartVertAlignment())
|
||
{
|
||
ptEnd.z = ptStart.z;
|
||
ptBr1.z = ptStart.z;
|
||
//0-6
|
||
arPts.append(ptStart);
|
||
arPts.append(ptEnd);
|
||
arPts.append(ptBr1);
|
||
arPts.append(ptStart - vtNor * dSWidth);
|
||
arPts.append(ptEnd - vtNor * dEWidth);
|
||
arPts.append(ptEnd + vtNor * dEWidth);
|
||
arPts.append(ptStart + vtNor * dSWidth);
|
||
|
||
//7-10
|
||
arPts.append(ptBr1 + vtStart * dBr1Width);
|
||
arPts.append(ptBr1 - vtNor * dBr1Width);
|
||
arPts.append(ptBr1 - vtStart * dBr1Width);
|
||
arPts.append(ptBr1 + vtNor * dBr1Width);
|
||
AcGePoint3d ptIntersect1,ptIntersect2;
|
||
//求出直线于圆弧的交点
|
||
AcGeCircArc3d circArc(ptBr1, vtBr1, dBr1Width);
|
||
//定义求交直线
|
||
AcGeLine3d *pLine = new AcGeLine3d(arPts[3], arPts[4]);
|
||
int nNum=0;//交点数
|
||
circArc.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
|
||
delete pLine;
|
||
if (2 == nNum)
|
||
{
|
||
if (arPts[3].distanceTo(ptIntersect1) < arPts[3].distanceTo(ptIntersect2))
|
||
{
|
||
arPts.append(ptIntersect1);
|
||
arPts.append(ptIntersect2);
|
||
}
|
||
else
|
||
{
|
||
arPts.append(ptIntersect2);
|
||
arPts.append(ptIntersect1);
|
||
}
|
||
}
|
||
//定义求交直线
|
||
pLine = new AcGeLine3d(arPts[5], arPts[6]);
|
||
nNum=0;//交点数
|
||
circArc.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
|
||
delete pLine;
|
||
if (2 == nNum)
|
||
{
|
||
if (arPts[5].distanceTo(ptIntersect1) < arPts[5].distanceTo(ptIntersect2))
|
||
{
|
||
arPts.append(ptIntersect1);
|
||
arPts.append(ptIntersect2);
|
||
}
|
||
else
|
||
{
|
||
arPts.append(ptIntersect2);
|
||
arPts.append(ptIntersect1);
|
||
}
|
||
}
|
||
}
|
||
//br1矢量和Z轴垂直（左视）
|
||
else if (IsBr1VertAlignment())
|
||
{
|
||
ptStart.z = ptBr1.z;
|
||
ptBr2.z = ptBr1.z;
|
||
//0-6
|
||
arPts.append(ptBr1);
|
||
arPts.append(ptBr2);
|
||
arPts.append(ptStart);
|
||
arPts.append(ptBr1 - vtNor * dBr1Width);
|
||
arPts.append(ptBr2 - vtNor * dBr2Width);
|
||
arPts.append(ptBr2 + vtNor * dBr2Width);
|
||
arPts.append(ptBr1 + vtNor * dBr1Width);
|
||
|
||
//7-10
|
||
arPts.append(ptStart + vtBr1 * dSWidth);
|
||
arPts.append(ptStart - vtNor * dSWidth);
|
||
arPts.append(ptStart - vtBr1 * dSWidth);
|
||
arPts.append(ptStart + vtNor * dSWidth);
|
||
AcGePoint3d ptIntersect1,ptIntersect2;
|
||
//求出直线于圆弧的交点
|
||
AcGeCircArc3d circArc(ptStart, vtStart, dSWidth);
|
||
//定义求交直线
|
||
AcGeLine3d *pLine = new AcGeLine3d(arPts[3], arPts[4]);
|
||
AcGePoint3d pt3 = arPts[3], pt4 = arPts[4];
|
||
|
||
int nNum=0;//交点数
|
||
circArc.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
|
||
delete pLine;
|
||
if (2 == nNum)
|
||
{
|
||
if (arPts[3].distanceTo(ptIntersect1) < arPts[3].distanceTo(ptIntersect2))
|
||
{
|
||
arPts.append(ptIntersect1);
|
||
arPts.append(ptIntersect2);
|
||
}
|
||
else
|
||
{
|
||
arPts.append(ptIntersect2);
|
||
arPts.append(ptIntersect1);
|
||
}
|
||
}
|
||
//定义求交直线
|
||
pLine = new AcGeLine3d(arPts[5], arPts[6]);
|
||
nNum=0;//交点数
|
||
circArc.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
|
||
delete pLine;
|
||
if (2 == nNum)
|
||
{
|
||
if (arPts[5].distanceTo(ptIntersect1) < arPts[5].distanceTo(ptIntersect2))
|
||
{
|
||
arPts.append(ptIntersect1);
|
||
arPts.append(ptIntersect2);
|
||
}
|
||
else
|
||
{
|
||
arPts.append(ptIntersect2);
|
||
arPts.append(ptIntersect1);
|
||
}
|
||
}
|
||
}
|
||
return arPts.length() > 0;
|
||
}
|
||
|
||
// 6
|
||
// 方口 50直边 8 ┏━━-━━┓7
|
||
// ┃ ┆ ┃
|
||
// C1╱11 10 9 ╲C3
|
||
// 1 ┏━━━╱ ┆ ╲
|
||
// ┃ 3 27 ┆ -━━┓14
|
||
// 0 ┃--4-----------┆ 24 17 ┃
|
||
// ┃ ┆-------------16--┃12
|
||
// ┃ 5 26┆ 25 15 ┃
|
||
// 2 ┗━-╲ ┆ ╱-━━━━┛13
|
||
// C2 ╲ 21 22 23 ╱ C4
|
||
// ┃ ┆ ┃
|
||
// 19┗━━━━┛20
|
||
// 18
|
||
|
||
BOOL ImpHvacCross::GetIntersectCrossPts(AcGePoint3dArray& arPts, BOOL bDefault) const
|
||
{
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
double dSWidth = 300.0, dEWidth = 300.0, dThick = 200.0, dBr1Width = 300.0, dBr2Width = 300.0;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBr2Width);
|
||
double dRadRatio = 1.5;
|
||
m_pXDataMap->GetAt(HCRS_RadRatio, dRadRatio);
|
||
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis;
|
||
vtNor = GetSectNormal();
|
||
dSWidth *= 0.5;
|
||
dEWidth *= 0.5;
|
||
dBr1Width *= 0.5;
|
||
dBr2Width *= 0.5;
|
||
AcGePoint3d ptTemp1,ptTemp2,ptInter;
|
||
//求直边段的各个点
|
||
GetPlusEdgePts(arPts, ptStart, vtStart, vtNor, dSWidth);
|
||
GetPlusEdgePts(arPts, ptBr1, vtBr1, vtNor, dBr1Width);
|
||
GetPlusEdgePts(arPts, ptEnd, vtEnd, vtNor, dEWidth);
|
||
GetPlusEdgePts(arPts, ptBr2, vtBr2, vtNor, dBr2Width);
|
||
//24-27
|
||
GetIntersectWith(ptStart, ptBr1, vtStart, vtBr1, ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(ptEnd, ptBr1, vtEnd, vtBr1, ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(ptEnd, ptBr2, vtEnd, vtBr2, ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(ptStart, ptBr2, vtStart, vtBr2, ptInter);
|
||
arPts.append(ptInter);
|
||
//交点28
|
||
if(TAuxTools::isCodirectionalPt(arPts[27], arPts[25], vtStart))
|
||
{
|
||
arPts.append(arPts[27]);
|
||
}
|
||
else
|
||
{
|
||
arPts.append(arPts[25]);
|
||
}
|
||
|
||
//重新计算带有变径或偏心的个点
|
||
AcGeVector3d vtStartv, vtEndv, vtBr1v, vtBr2v;
|
||
vtStartv = vtStart;
|
||
vtEndv = vtEnd;
|
||
vtBr1v = vtBr1;
|
||
vtBr2v = vtBr2;
|
||
vtStartv.rotateBy(PI * 0.5,vtNor);
|
||
vtEndv.rotateBy(PI * 0.5,vtNor);
|
||
vtBr1v.rotateBy(PI * 0.5,vtNor);
|
||
vtBr2v.rotateBy(PI * 0.5,vtNor);
|
||
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtBr1.normalize();
|
||
vtBr2.normalize();
|
||
vtStartv.normalize();
|
||
vtEndv.normalize();
|
||
vtBr1v.normalize();
|
||
vtBr2v.normalize();
|
||
|
||
AcGePoint3d pt;
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
double dPlusSta = MayAsMUnit(100.0);
|
||
double dPlusEnd = MayAsMUnit(50.0);
|
||
double dPlusBr = MayAsMUnit(150.0);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
|
||
double dLength = max(dBr1Width,dBr2Width);
|
||
dLength = dPlusEdge + dPlusSta;
|
||
|
||
AecHvac::HvacCrossType eCrossType = AecHvac::eOrthoCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eCrossType);
|
||
|
||
if(eCrossType == AecHvac::eLinearCross)
|
||
{
|
||
GetIntersectWith(arPts[7], arPts[9], arPts[14], arPts[17], ptInter);
|
||
arPts[9] = ptInter;
|
||
|
||
GetIntersectWith(arPts[13], arPts[15], arPts[20], arPts[23], ptInter);
|
||
arPts[23] = ptInter;
|
||
}
|
||
else
|
||
{
|
||
}
|
||
|
||
AcGePoint3d ptCor1,ptCor2,ptCor3,ptCor4;
|
||
BOOL bIsOK = TRUE;
|
||
GetIntersectWith(arPts[1], arPts[3], arPts[8], arPts[11], ptCor1);
|
||
if (!TAuxTools::isCodirectionalPt(arPts[1],ptCor1,vtStart))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[8],ptCor1,vtBr1))
|
||
bIsOK = FALSE;
|
||
GetIntersectWith(arPts[2], arPts[5], arPts[19], arPts[21], ptCor2);
|
||
if (!TAuxTools::isCodirectionalPt(arPts[2],ptCor2,vtStart))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[19],ptCor2,vtBr2))
|
||
bIsOK = FALSE;
|
||
GetIntersectWith(arPts[14], arPts[17], arPts[7], arPts[9], ptCor3);
|
||
if (!TAuxTools::isCodirectionalPt(arPts[14],ptCor3,vtEnd))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[7],ptCor3,vtBr1))
|
||
bIsOK = FALSE;
|
||
GetIntersectWith(arPts[13], arPts[15], arPts[20], arPts[23], ptCor4);
|
||
if (!TAuxTools::isCodirectionalPt(arPts[13],ptCor4,vtEnd))
|
||
bIsOK = FALSE;
|
||
if (!TAuxTools::isCodirectionalPt(arPts[20],ptCor4,vtBr2))
|
||
bIsOK = FALSE;
|
||
|
||
//重新计算标准点
|
||
if (bDefault)
|
||
{
|
||
dLength = max(dSWidth, dEWidth) * 2 * dRadRatio;
|
||
arPts[0] = GetInterFinalPt(arPts[0],arPts[24],arPts[27],ptCor1,ptCor2,vtStart,dLength);
|
||
arPts[2] = GetFinalPtEnd(arPts[12],arPts[25],arPts[26],ptCor3,ptCor4,vtEnd);
|
||
|
||
AcGePoint3d ptDis = arPts[6] + vtBr1 * 10000;
|
||
double dis1 = ptDis.distanceTo(ptCor1);
|
||
double dis2 = ptDis.distanceTo(ptCor3);
|
||
if (dis1 < dis2)
|
||
{
|
||
arPts[4] = (ptCor1 + vtBr1 * (dPlusBr + dPlusEdge)) + vtBr1v * dBr1Width;
|
||
}
|
||
else
|
||
{
|
||
arPts[4] = (ptCor3 + vtBr1 * (dPlusBr + dPlusEdge)) - vtBr1v * dBr1Width;
|
||
}
|
||
|
||
ptDis = arPts[18] + vtBr2 * 10000;
|
||
dis1 = ptDis.distanceTo(ptCor2);
|
||
dis2 = ptDis.distanceTo(ptCor4);
|
||
if (dis1 < dis2)
|
||
{
|
||
arPts[6] = (ptCor2 + vtBr2 * (dPlusBr + dPlusEdge)) - vtBr2v * dBr2Width;
|
||
}
|
||
else
|
||
{
|
||
arPts[6] = (ptCor4 + vtBr2 * (dPlusBr + dPlusEdge)) + vtBr2v * dBr2Width;
|
||
}
|
||
|
||
if(eCrossType == AecHvac::eInterCross)
|
||
{
|
||
arPts[2] = GetInterFinalPt(arPts[12],arPts[25],arPts[26],ptCor3,ptCor4,vtEnd,dLength);
|
||
}
|
||
}
|
||
return bIsOK;
|
||
}
|
||
|
||
|
||
// 6
|
||
// 方口有50直边 8 ┏━━-━━┓7
|
||
// C1 ┃ ┆ ┃
|
||
// 28┃11 10 9 ┃30 C4
|
||
// 1 ┏━━━-━┛ ┆ ┃29
|
||
// ┃ 3 ┆ ┗━━━━┓14
|
||
// 0 ┃--4-----------┆ 17 ┃
|
||
// ┃ ┆-------------16--┃12
|
||
// ┃ 5 ┆ 15 ┃
|
||
// 2 ┗━━━┓ ┆ ┏━━━━━━┛13
|
||
// C2 31┃ ┆ ┃32 C3
|
||
// ┃21 22 23┃33
|
||
// 19┗━━━━┛20
|
||
// 18
|
||
|
||
BOOL ImpHvacCross::GetArcuateCrossPts(AcGePoint3dArray& arPts, BOOL bDefault) const
|
||
{
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
double dSWidth = 300.0, dEWidth = 300.0, dThick = 200.0, dBr1Width = 300.0, dBr2Width = 300.0;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dSWidth);
|
||
m_pXDataMap->GetAt(HCRS_Thick, dThick);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBr2Width);
|
||
AecHvac::HvacCrossType eCrosstype = AecHvac::eArcuateCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eCrosstype);
|
||
|
||
AcGeVector3d vtTT = GetSectNormal();
|
||
AcGePlane planSta(ptStart, vtTT);
|
||
AcGePlane planBr1(ptBr1, vtTT);
|
||
AcGePlane planBr2(ptBr2, vtTT);
|
||
|
||
AcGePlane planEnd;
|
||
|
||
if (eCrosstype == AecHvac::eArcuateIntubCross)
|
||
{
|
||
planEnd.set(ptEnd, vtTT);
|
||
ptEnd = ptEnd.orthoProject(planSta);
|
||
ptBr1 = ptBr1.orthoProject(planSta);
|
||
ptBr2 = ptBr2.orthoProject(planSta);
|
||
}
|
||
|
||
if(vtStart.isCodirectionalTo(vtEnd) || vtStart.isCodirectionalTo(vtBr1) || vtStart.isCodirectionalTo(vtBr2) )
|
||
return FALSE;
|
||
if(vtEnd.isCodirectionalTo(vtBr1) || vtEnd.isCodirectionalTo(vtBr2) )
|
||
return FALSE;
|
||
if(vtBr1.isCodirectionalTo(vtBr2) )
|
||
return FALSE;
|
||
|
||
double dRadRatio = 1.5;
|
||
double dRadRatioBr1 = 1.5;
|
||
double dRadRatioBr2 = 1.5;
|
||
m_pXDataMap->GetAt(HCRS_RadRatio, dRadRatio);
|
||
|
||
dRadRatioBr1 = min(dSWidth, dBr1Width) * (dRadRatio - 0.5);
|
||
dRadRatioBr2 = min(dSWidth, dBr2Width) * (dRadRatio - 0.5);
|
||
|
||
BOOL bIsOK = TRUE;
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis;
|
||
vtNor = GetSectNormal();
|
||
dSWidth *= 0.5;
|
||
dEWidth *= 0.5;
|
||
dBr1Width *= 0.5;
|
||
dBr2Width *= 0.5;
|
||
AcGePoint3d ptInter;
|
||
AcGeVector3d vtStartv, vtEndv, vtBr1v, vtBr2v;
|
||
vtStartv = vtStart;
|
||
vtEndv = vtEnd;
|
||
vtBr1v = vtBr1;
|
||
vtBr2v = vtBr2;
|
||
vtStartv.rotateBy(PI * 0.5,vtNor);
|
||
vtEndv.rotateBy(PI * 0.5,vtNor);
|
||
vtBr1v.rotateBy(PI * 0.5,vtNor);
|
||
vtBr2v.rotateBy(PI * 0.5,vtNor);
|
||
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtBr1.normalize();
|
||
vtBr2.normalize();
|
||
vtStartv.normalize();
|
||
vtEndv.normalize();
|
||
vtBr1v.normalize();
|
||
vtBr2v.normalize();
|
||
|
||
//求直边段的各个点
|
||
GetPlusEdgePts(arPts, ptStart, vtStart, vtNor, dSWidth);
|
||
GetPlusEdgePts(arPts, ptBr1, vtBr1, vtNor, dBr1Width);
|
||
GetPlusEdgePts(arPts, ptEnd, vtEnd, vtNor, dEWidth);
|
||
GetPlusEdgePts(arPts, ptBr2, vtBr2, vtNor, dBr2Width);
|
||
|
||
//求交点24,25
|
||
GetIntersectWith(arPts[1], arPts[3], arPts[8], arPts[11], ptInter);
|
||
arPts.append(ptInter);
|
||
GetIntersectWith(arPts[2], arPts[5], arPts[19], arPts[21], ptInter);
|
||
arPts.append(ptInter);
|
||
|
||
double dAngle = vtStart.angleTo(vtBr1, vtNor);
|
||
if (dAngle > PI)
|
||
{
|
||
dAngle = 2 * PI - dAngle ;
|
||
}
|
||
dAngle *= 0.5;
|
||
double dAngle1 = vtStart.angleTo(vtBr2, vtNor);
|
||
if (dAngle1 > PI)
|
||
{
|
||
dAngle1 = 2 * PI - dAngle1 ;
|
||
}
|
||
dAngle1 *= 0.5;
|
||
//求圆心26,27
|
||
ptInter = arPts[24] + vtStart * dRadRatioBr1 / tan(dAngle);
|
||
ptInter = ptInter + vtStartv * dRadRatioBr1;
|
||
arPts.append(ptInter);
|
||
ptInter = arPts[25] + vtStart * dRadRatioBr2 / tan(dAngle1);
|
||
ptInter = ptInter - vtStartv * dRadRatioBr2;
|
||
arPts.append(ptInter);
|
||
//偏心重新算点
|
||
//上弧
|
||
ptInter = arPts[26] - vtStartv * dRadRatioBr1;
|
||
int nPos = TAuxTools::PositionOnLine(arPts[1], arPts[3], ptInter);
|
||
if (nPos == 1)
|
||
{
|
||
bIsOK = FALSE;
|
||
}
|
||
else if (nPos == 2)
|
||
{
|
||
arPts[3] = ptInter;
|
||
}
|
||
if(!bDefault)
|
||
{
|
||
arPts[11] = arPts[26] + vtBr1v * dRadRatioBr1;
|
||
arPts[9] = arPts[26] + vtBr1v * (dRadRatioBr1 + 2 * dBr1Width);
|
||
}
|
||
//下弧
|
||
ptInter = arPts[27] + vtStartv * dRadRatioBr2;
|
||
nPos = TAuxTools::PositionOnLine(arPts[2], arPts[5], ptInter);
|
||
if (nPos == 1)
|
||
{
|
||
bIsOK = FALSE;
|
||
}
|
||
else if (nPos == 2)
|
||
{
|
||
arPts[5] = ptInter;
|
||
}
|
||
if(!bDefault)
|
||
{
|
||
arPts[21] = arPts[27] - vtBr2v * dRadRatioBr2;
|
||
arPts[23] = arPts[27] - vtBr2v * (dRadRatioBr2 + 2 * dBr2Width);
|
||
}
|
||
//计算上圆弧的点
|
||
AcGeVector3d vtCor = arPts[24] - arPts[26];
|
||
vtCor.normalize();
|
||
ptInter = arPts[26] + vtCor * dRadRatioBr1;
|
||
//28
|
||
arPts.append(ptInter);
|
||
AcDbCircle circArc(arPts[26],vtNor,dRadRatioBr1 + 2 * dBr1Width);
|
||
//定义求交直线
|
||
AcGePoint3dArray arInterpts;
|
||
AcDbLine line(arPts[14], arPts[17]);
|
||
circArc.intersectWith(&line, AcDb::kExtendBoth, arInterpts);
|
||
if (arInterpts.length() == 2)
|
||
{
|
||
//29
|
||
if (arPts[17].distanceTo(arInterpts[0]) > arPts[17].distanceTo(arInterpts[1]))
|
||
{
|
||
arPts.append(arInterpts[1]);
|
||
}
|
||
else
|
||
{
|
||
arPts.append(arInterpts[0]);
|
||
}
|
||
AcGeVector3d vtS, vtE;
|
||
vtS = arPts[9] - arPts[26];
|
||
vtE = arPts[29] - arPts[26];
|
||
vtCor = vtS + vtE;
|
||
vtCor.normalize();
|
||
//30
|
||
arPts.append(arPts[26] + vtCor * circArc.radius());
|
||
}
|
||
else
|
||
{
|
||
GetIntersectWith(arPts[9], arPts[7], arPts[14], arPts[17], ptInter);
|
||
arPts[9] = ptInter;
|
||
arPts.append(ptInter);
|
||
arPts.append(ptInter);
|
||
}
|
||
AcGePoint3d pt;
|
||
//判断是否越界
|
||
pt = arPts[9] + vtEnd * 100;
|
||
GetIntersectWith(arPts[9], pt, arPts[12], arPts[13], ptInter);
|
||
if (!TAuxTools::isCodirectionalPt(arPts[14],ptInter,vtEndv))
|
||
{
|
||
GetIntersectWith(arPts[9], arPts[7], arPts[14], arPts[17], ptInter);
|
||
arPts[9] = ptInter;
|
||
arPts[29] = ptInter;
|
||
arPts[30] = ptInter;
|
||
}
|
||
|
||
//计算下圆弧的点
|
||
vtCor = arPts[25] - arPts[27];
|
||
vtCor.normalize();
|
||
ptInter = arPts[27] + vtCor * dRadRatioBr2;
|
||
//31
|
||
arPts.append(ptInter);
|
||
AcDbCircle circArc1(arPts[27],vtNor,dRadRatioBr2 + 2 * dBr2Width);
|
||
//定义求交直线
|
||
arInterpts.setLogicalLength(0);
|
||
AcDbLine line1(arPts[13], arPts[15]);
|
||
circArc1.intersectWith(&line1, AcDb::kExtendBoth, arInterpts);
|
||
if (arInterpts.length() == 2)
|
||
{
|
||
//32
|
||
if (arPts[15].distanceTo(arInterpts[0]) > arPts[15].distanceTo(arInterpts[1]))
|
||
{
|
||
arPts.append(arInterpts[1]);
|
||
}
|
||
else
|
||
{
|
||
arPts.append(arInterpts[0]);
|
||
}
|
||
AcGeVector3d vtS, vtE;
|
||
vtS = arPts[23] - arPts[27];
|
||
vtE = arPts[32] - arPts[27];
|
||
vtCor = vtS + vtE;
|
||
vtCor.normalize();
|
||
//33
|
||
arPts.append(arPts[27] + vtCor * circArc1.radius());
|
||
}
|
||
else
|
||
{
|
||
GetIntersectWith(arPts[13], arPts[15], arPts[20], arPts[23], ptInter);
|
||
arPts[23] = ptInter;
|
||
arPts.append(ptInter);
|
||
arPts.append(ptInter);
|
||
}
|
||
//判断是否越界
|
||
pt = arPts[23] + vtEnd * 100;
|
||
GetIntersectWith(arPts[23], pt, arPts[12], arPts[13], ptInter);
|
||
if (!TAuxTools::isCodirectionalPt(ptInter,arPts[13],vtEndv))
|
||
{
|
||
GetIntersectWith(arPts[13], arPts[15], arPts[20], arPts[23], ptInter);
|
||
arPts[23] = ptInter;
|
||
arPts[32] = ptInter;
|
||
arPts[33] = ptInter;
|
||
}
|
||
|
||
//重新计算标准点
|
||
if (bDefault)
|
||
{
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
double dPlusEnd = MayAsMUnit(50.0);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
double dLength;
|
||
|
||
//计算角点
|
||
AcGePoint3d ptCor1,ptCor2,ptCor3,ptCor4;
|
||
GetIntersectWith(arPts[1], arPts[3], arPts[8], arPts[11], ptCor1);
|
||
GetIntersectWith(arPts[2], arPts[5], arPts[19], arPts[21], ptCor2);
|
||
GetIntersectWith(arPts[13], arPts[15], arPts[20], arPts[23], ptCor3);
|
||
GetIntersectWith(arPts[7], arPts[9], arPts[14], arPts[17], ptCor4);
|
||
double dminSbr1 = dBr1Width;
|
||
if (dBr1Width > dSWidth)
|
||
{
|
||
dminSbr1 = dSWidth;
|
||
}
|
||
double dminSbr2 = dBr2Width;
|
||
if (dBr2Width > dSWidth)
|
||
{
|
||
dminSbr2 = dSWidth;
|
||
}
|
||
double dminEbr1 = dBr1Width;
|
||
if (dBr1Width > dEWidth)
|
||
{
|
||
dminEbr1 = dEWidth;
|
||
}
|
||
double dminEbr2 = dBr2Width;
|
||
if (dBr2Width > dEWidth)
|
||
{
|
||
dminEbr2 = dEWidth;
|
||
}
|
||
//start
|
||
AcGePoint3d ptDis = ptStart + vtStart * 10000;
|
||
double dis1 = ptDis.distanceTo(ptCor1);
|
||
double dis2 = ptDis.distanceTo(ptCor2);
|
||
if (dis1 < dis2)
|
||
{
|
||
dAngle = vtStart.angleTo(vtBr1);
|
||
dAngle *= 0.5;
|
||
dLength = (dRadRatio - 0.5) * dminSbr1 * 2 / tan(dAngle) + dPlusEdge;
|
||
|
||
arPts[0] = ptCor1 + vtStart * dLength;
|
||
arPts[0] = arPts[0] - vtStartv * dSWidth;
|
||
}
|
||
else
|
||
{
|
||
dAngle = vtStart.angleTo(vtBr2);
|
||
dAngle *= 0.5;
|
||
dLength = (dRadRatio - 0.5) * dminSbr2 * 2 / tan(dAngle) + dPlusEdge;
|
||
|
||
arPts[0] = ptCor2 + vtStart * dLength;
|
||
arPts[0] = arPts[0] + vtStartv * dSWidth;
|
||
}
|
||
//end
|
||
ptDis = arPts[12] + vtEnd * 10000;
|
||
dis1 = ptDis.distanceTo(ptCor4);
|
||
dis2 = ptDis.distanceTo(ptCor3);
|
||
if (dis1 < dis2)
|
||
{
|
||
dAngle = vtEnd.angleTo(vtBr1);
|
||
dAngle *= 0.5;
|
||
dLength = dPlusEnd + dPlusEdge;
|
||
|
||
arPts[2] = ptCor4 + vtEnd * dLength;
|
||
arPts[2] = arPts[2] + vtEndv * dEWidth;
|
||
}
|
||
else
|
||
{
|
||
dAngle = vtEnd.angleTo(vtBr2);
|
||
dAngle *= 0.5;
|
||
dLength = dPlusEnd + dPlusEdge;
|
||
|
||
arPts[2] = ptCor3 + vtEnd * dLength;
|
||
arPts[2] = arPts[2] - vtEndv * dEWidth;
|
||
}
|
||
|
||
if (eCrosstype == AecHvac::eArcuateIntubCross)
|
||
{
|
||
arPts[2] = arPts[2].orthoProject(planEnd);
|
||
}
|
||
|
||
//br1
|
||
ptDis = arPts[6] + vtBr1 * 10000;
|
||
dis1 = ptDis.distanceTo(ptCor1);
|
||
dis2 = ptDis.distanceTo(ptCor4);
|
||
if (dis1 < dis2)
|
||
{
|
||
dAngle = vtBr1.angleTo(vtStart);
|
||
dAngle *= 0.5;
|
||
dLength = (dRadRatio - 0.5) * dminSbr1 * 2 / tan(dAngle) + dPlusEdge;
|
||
|
||
arPts[4] = ptCor1 + vtBr1 * dLength;
|
||
arPts[4] = arPts[4] + vtBr1v * dBr1Width;
|
||
arPts[4] = arPts[4].orthoProject(planBr1);
|
||
}
|
||
else
|
||
{
|
||
dAngle = vtBr1.angleTo(vtEnd);
|
||
dAngle *= 0.5;
|
||
dLength = (dRadRatio - 0.5) * dminEbr1 * 2 / tan(dAngle) + dPlusEdge;
|
||
|
||
arPts[4] = ptCor4 + vtBr1 * dLength;
|
||
arPts[4] = arPts[4] - vtBr1v * dBr1Width;
|
||
arPts[4] = arPts[4].orthoProject(planBr1);
|
||
}
|
||
//br2
|
||
ptDis = arPts[18] + vtBr2 * 10000;
|
||
dis1 = ptDis.distanceTo(ptCor2);
|
||
dis2 = ptDis.distanceTo(ptCor3);
|
||
if (dis1 < dis2)
|
||
{
|
||
dAngle = vtBr2.angleTo(vtStart);
|
||
dAngle *= 0.5;
|
||
dLength = (dRadRatio - 0.5) * dminSbr2 * 2 / tan(dAngle) + dPlusEdge;
|
||
|
||
arPts[6] = ptCor2 + vtBr2 * dLength;
|
||
arPts[6] = arPts[6] - vtBr2v * dBr2Width;
|
||
arPts[6] = arPts[6].orthoProject(planBr2);
|
||
}
|
||
else
|
||
{
|
||
dAngle = vtBr2.angleTo(vtEnd);
|
||
dAngle *= 0.5;
|
||
dLength = (dRadRatio - 0.5) * dminEbr2 * 2 / tan(dAngle) + dPlusEdge;
|
||
|
||
arPts[6] = ptCor3 + vtBr2 * dLength;
|
||
arPts[6] = arPts[6] + vtBr2v * dBr2Width;
|
||
arPts[6] = arPts[6].orthoProject(planBr2);
|
||
}
|
||
}
|
||
|
||
if (!bDefault && eCrosstype == AecHvac::eArcuateIntubCross)
|
||
{
|
||
AcGePoint3d ptProj = AcGePoint3d::kOrigin;
|
||
ptProj = arPts[3];
|
||
arPts.setAt(3, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[28];
|
||
arPts.setAt(28, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[11];
|
||
arPts.setAt(11, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[8];
|
||
arPts.setAt(8, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[6];
|
||
arPts.setAt(6, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[7];
|
||
arPts.setAt(7, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[9];
|
||
arPts.setAt(9, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[30];
|
||
arPts.setAt(30, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[29];
|
||
arPts.setAt(29, ptProj.orthoProject(planBr1));
|
||
ptProj = arPts[10];
|
||
arPts.setAt(10, ptProj.orthoProject(planBr1));
|
||
|
||
ptProj = arPts[5];
|
||
arPts.setAt(5, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[31];
|
||
arPts.setAt(31, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[21];
|
||
arPts.setAt(21, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[19];
|
||
arPts.setAt(19, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[18];
|
||
arPts.setAt(18, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[20];
|
||
arPts.setAt(20, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[22];
|
||
arPts.setAt(22, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[23];
|
||
arPts.setAt(23, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[33];
|
||
arPts.setAt(33, ptProj.orthoProject(planBr2));
|
||
ptProj = arPts[32];
|
||
arPts.setAt(32, ptProj.orthoProject(planBr2));
|
||
}
|
||
|
||
return arPts.length() > 0;
|
||
}
|
||
|
||
BOOL ImpHvacCross::GetIntersectWith(AcGePoint3d &pt1,AcGePoint3d &pt2,AcGeVector3d &vt1,AcGeVector3d &vt2,AcGePoint3d &ptIntersect) const
|
||
{
|
||
AcGePoint3d ptTmp1 = pt1;
|
||
AcGePoint3d ptTmp2 = pt1 + vt1 * 1000;
|
||
AcGePoint3d ptTmp3 = pt2;
|
||
AcGePoint3d ptTmp4 = pt2 + vt2 * 1000;
|
||
ptTmp1.z = ptTmp2.z = ptTmp3.z = ptTmp4.z = 0;
|
||
AcDbLine line1(ptTmp1,ptTmp2),line2(ptTmp3,ptTmp4);
|
||
AcGePoint3dArray arrPtInsec;
|
||
BOOL bRes = FALSE;
|
||
if(Acad::eOk == line1.intersectWith(&line2, AcDb::kExtendBoth, arrPtInsec))
|
||
{
|
||
if(arrPtInsec.length() > 0)
|
||
{
|
||
ptIntersect = arrPtInsec[0];
|
||
bRes = TRUE;
|
||
}
|
||
}
|
||
ptIntersect.z = pt1.z;
|
||
return bRes;
|
||
}
|
||
|
||
BOOL ImpHvacCross::GetIntersectWith(AcGePoint3d &pt1,AcGePoint3d &pt2,AcGePoint3d &pt3,AcGePoint3d &pt4,AcGePoint3d &ptIntersect) const
|
||
{
|
||
AcGePoint3d ptTmp1 = pt1;
|
||
AcGePoint3d ptTmp2 = pt2;
|
||
AcGePoint3d ptTmp3 = pt3;
|
||
AcGePoint3d ptTmp4 = pt4;
|
||
ptTmp1.z = ptTmp2.z = ptTmp3.z = ptTmp4.z = 0;
|
||
AcDbLine line1(ptTmp1,ptTmp2),line2(ptTmp3,ptTmp4);
|
||
AcGePoint3dArray arrPtInsec;
|
||
BOOL bRes = FALSE;
|
||
if(Acad::eOk == line1.intersectWith(&line2, AcDb::kExtendBoth, arrPtInsec))
|
||
{
|
||
if(arrPtInsec.length() > 0)
|
||
{
|
||
ptIntersect = arrPtInsec[0];
|
||
bRes = TRUE;
|
||
}
|
||
}
|
||
ptIntersect.z = pt1.z;
|
||
return bRes;
|
||
}
|
||
|
||
void ImpHvacCross::GetPlusEdgePts(AcGePoint3dArray &arPts, AcGePoint3d &ptStart, AcGeVector3d &vtStart, AcGeVector3d &vtNor, double dSWidth) const
|
||
{
|
||
double dPlusEdge = MayAsMUnit(50);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
if (dPlusEdge < 1.e-3)
|
||
{
|
||
dPlusEdge = 0.01;
|
||
}
|
||
AcGeVector3d vtStartv = vtStart;
|
||
vtStartv.rotateBy(PI * 0.5, vtNor);
|
||
vtStart.normalize();
|
||
vtStartv.normalize();
|
||
arPts.append(ptStart);
|
||
AcGePoint3d ptpt,ptpt1;
|
||
ptpt = ptStart + vtStartv * dSWidth;
|
||
|
||
arPts.append(ptpt);
|
||
ptpt1 = ptStart - vtStartv * dSWidth;
|
||
arPts.append(ptpt1);
|
||
int nSize = arPts.length();
|
||
arPts.append(arPts[nSize - 2] - vtStart * dPlusEdge);
|
||
arPts.append(arPts[nSize - 3] - vtStart * dPlusEdge);
|
||
arPts.append(arPts[nSize - 1] - vtStart * dPlusEdge);
|
||
}
|
||
|
||
void ImpHvacCross::GetArcPoint(AcDbPolyline &polyLine, AcGePoint3dArray &ptArcArr) const
|
||
{
|
||
if (polyLine.numVerts() != 4)
|
||
return;
|
||
|
||
double dPara1(0.0), dPara2(0.0);
|
||
double dPar1, dPar2;
|
||
AcGePoint3d pt0, pt1, pt2, pt3, ptMid;
|
||
|
||
polyLine.getPointAt(0, pt0);
|
||
polyLine.getPointAt(1, pt1);
|
||
polyLine.getPointAt(2, pt2);
|
||
polyLine.getPointAt(3, pt3);
|
||
|
||
polyLine.getParamAtPoint(pt0, dPar1);
|
||
polyLine.getParamAtPoint(pt1, dPar2);
|
||
polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
|
||
ptArcArr.append(pt0);
|
||
ptArcArr.append(ptMid);
|
||
ptArcArr.append(pt1);
|
||
|
||
polyLine.getParamAtPoint(pt1, dPar1);
|
||
polyLine.getParamAtPoint(pt2, dPar2);
|
||
polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
|
||
ptArcArr.append(ptMid);
|
||
ptArcArr.append(pt2);
|
||
|
||
polyLine.getParamAtPoint(pt2, dPar1);
|
||
polyLine.getParamAtPoint(pt3, dPar2);
|
||
polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
|
||
ptArcArr.append(ptMid);
|
||
ptArcArr.append(pt3);
|
||
}
|
||
|
||
AcGePoint3d ImpHvacCross::GetCenterPt() const
|
||
{
|
||
AcGeVector3d vtStart;
|
||
AcGePoint3d ptStart;
|
||
double dBr1Width = MayAsMUnit(300.0), dBr2Width = MayAsMUnit(300.0), dPlusEdge = MayAsMUnit(50.0);
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBr1Width);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBr2Width);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
double dRadRatio = 1.0;
|
||
m_pXDataMap->GetAt(HCRS_RadRatio, dRadRatio);
|
||
|
||
dRadRatio *= max(dBr1Width,dBr2Width);
|
||
vtStart.normalize();
|
||
AecHvac::HvacCrossType eType = AecHvac::eOrthoCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eType);
|
||
if (eType == AecHvac::eOrthoCross || eType == AecHvac::eArcuateCross || eType == AecHvac::eArcuateIntubCross)
|
||
{
|
||
return ptStart - vtStart * (dRadRatio + dPlusEdge);
|
||
}
|
||
double dPlusSta = 100.0;
|
||
|
||
return ptStart - vtStart * (dPlusSta + dPlusEdge + max(dBr1Width,dBr2Width) * 0.5);
|
||
}
|
||
|
||
AcGePoint3d ImpHvacCross::GetPlusEdgeStartPt() const
|
||
{
|
||
AcGeVector3d vt;
|
||
AcGePoint3d pt;
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, pt);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vt);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
vt.normalize();
|
||
return pt - vt * dPlusEdge;
|
||
}
|
||
|
||
AcGePoint3d ImpHvacCross::GetPlusEdgeEndPt() const
|
||
{
|
||
AcGeVector3d vt;
|
||
AcGePoint3d pt;
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, pt);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vt);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
vt.normalize();
|
||
return pt - vt * dPlusEdge;
|
||
}
|
||
|
||
AcGePoint3d ImpHvacCross::GetPlusEdgeBra1Pt() const
|
||
{
|
||
AcGeVector3d vt;
|
||
AcGePoint3d pt;
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, pt);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vt);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
vt.normalize();
|
||
return pt - vt * dPlusEdge;
|
||
}
|
||
|
||
AcGePoint3d ImpHvacCross::GetPlusEdgeBra2Pt() const
|
||
{
|
||
AcGeVector3d vt;
|
||
AcGePoint3d pt;
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, pt);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vt);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
vt.normalize();
|
||
return pt - vt * dPlusEdge;
|
||
}
|
||
|
||
AcGePoint3d ImpHvacCross::GetFinalPt(AcGePoint3d ptStart,AcGePoint3d ptInter1,AcGePoint3d ptInter2,AcGePoint3d ptCor1,
|
||
AcGePoint3d ptCor2,AcGeVector3d vtStart,double dLength) const
|
||
{
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis,vtStartv;
|
||
vtNor = GetSectNormal();
|
||
vtStartv = vtStart;
|
||
vtStartv.rotateBy(PI * 0.5,vtNor);
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
double dPlusEnd = MayAsMUnit(50.0);
|
||
AcGePoint3d ptInter,ptRet;
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
double ddisPar = dPlusEnd + dPlusEdge;
|
||
AcGePoint3d ptDis = ptStart + vtStart * 10000;
|
||
double dis1 = ptDis.distanceTo(ptCor1);
|
||
double dis2 = ptDis.distanceTo(ptCor2);
|
||
double dWidthBr1, dWidthBr2;
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dWidthBr1);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dWidthBr2);
|
||
AecHvac::HvacCrossType eCrossType = AecHvac::eInsertCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eCrossType);
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
|
||
// 不用该分支了
|
||
if (dis1 < dis2)
|
||
{
|
||
GetIntersectWith(ptCor1, ptInter1, vtStartv, vtStart, ptInter);
|
||
if ((ptInter.distanceTo(ptInter1) + ddisPar) < dLength)
|
||
{
|
||
if (!(eCrossType == AecHvac::eInsertCross || eCrossType == AecHvac::eInsertIntubCross))
|
||
ptRet = ptInter1 + vtStart * dLength;
|
||
else
|
||
{
|
||
if(eCircle == eSectType)
|
||
ptRet = ptInter + vtStart * 50;
|
||
else
|
||
ptRet = ptInter1 + vtStart * (100.0 + dPlusEdge + dWidthBr1 * 0.5);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(eCrossType == AecHvac::eInsertCross || eCrossType == AecHvac::eInsertIntubCross))
|
||
ptRet = ptInter + vtStart * ddisPar;
|
||
else
|
||
ptRet = ptInter + vtStart * (100.0 + dPlusEdge);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
GetIntersectWith(ptCor2, ptInter2, vtStartv, vtStart,ptInter);
|
||
if ((ptInter.distanceTo(ptInter2) + ddisPar) < dLength)
|
||
{
|
||
if (!(eCrossType == AecHvac::eInsertCross || eCrossType == AecHvac::eInsertIntubCross))
|
||
ptRet = ptInter2 + vtStart * dLength;
|
||
else
|
||
{
|
||
if(eCircle == eSectType)
|
||
ptRet = ptInter + vtStart * 50;
|
||
else
|
||
ptRet = ptInter2 + vtStart * (100.0 + dPlusEdge + dWidthBr2 * 0.5);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(eCrossType == AecHvac::eInsertCross || eCrossType == AecHvac::eInsertIntubCross))
|
||
ptRet = ptInter + vtStart * ddisPar;
|
||
else
|
||
ptRet = ptInter + vtStart * (100.0 + dPlusEdge);
|
||
}
|
||
}
|
||
return ptRet;
|
||
}
|
||
|
||
AcGePoint3d ImpHvacCross::GetInterBrPt(AcGePoint3d ptStart,AcGePoint3d ptInter1,AcGePoint3d ptInter2,AcGePoint3d ptCor1,
|
||
AcGePoint3d ptCor2,AcGeVector3d vtStart,double dLength) const
|
||
{
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis,vtStartv;
|
||
vtNor = GetSectNormal();
|
||
vtStartv = vtStart;
|
||
vtStartv.rotateBy(PI * 0.5,vtNor);
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
double dPlusEnd = MayAsMUnit(50.0);
|
||
double dPlusBr = MayAsMUnit(150.0);
|
||
AcGePoint3d ptInter,ptRet;
|
||
|
||
double ddisPar = dPlusEnd + dPlusEdge;
|
||
AcGePoint3d ptDis = ptStart + vtStart * 10000;
|
||
double dis1 = ptDis.distanceTo(ptCor1);
|
||
double dis2 = ptDis.distanceTo(ptCor2);
|
||
double dWidthBr1, dWidthBr2;
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dWidthBr1);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dWidthBr2);
|
||
AecHvac::HvacCrossType eCrossType = AecHvac::eInsertCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eCrossType);
|
||
if (dis1 < dis2)
|
||
{
|
||
ptRet = (ptCor1 + vtStart * dPlusBr) + vtStartv * (dLength + dPlusEdge);
|
||
}
|
||
else
|
||
{
|
||
ptRet = (ptCor2 + vtStart * dPlusBr) - vtStartv * (dLength + dPlusEdge);
|
||
}
|
||
return ptRet;
|
||
}
|
||
|
||
AcGePoint3d ImpHvacCross::GetInterFinalPt(AcGePoint3d ptStart,AcGePoint3d ptInter1,AcGePoint3d ptInter2,AcGePoint3d ptCor1,
|
||
AcGePoint3d ptCor2,AcGeVector3d vtStart,double dLength) const
|
||
{
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis,vtStartv;
|
||
vtNor = GetSectNormal();
|
||
vtStartv = vtStart;
|
||
vtStartv.rotateBy(PI * 0.5,vtNor);
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
double dPlusEnd = MayAsMUnit(50.0);
|
||
AcGePoint3d ptInter,ptRet;
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
double ddisPar = dPlusEnd + dPlusEdge;
|
||
AcGePoint3d ptDis = ptStart + vtStart * 10000;
|
||
double dis1 = ptDis.distanceTo(ptCor1);
|
||
double dis2 = ptDis.distanceTo(ptCor2);
|
||
double dWidthBr1, dWidthBr2;
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dWidthBr1);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dWidthBr2);
|
||
AecHvac::HvacCrossType eCrossType = AecHvac::eInsertCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eCrossType);
|
||
if (dis1 < dis2)
|
||
{
|
||
GetIntersectWith(ptCor1, ptInter1, vtStartv, vtStart, ptInter);
|
||
if ((ptInter.distanceTo(ptInter1) + ddisPar) < dLength)
|
||
{
|
||
ptRet = ptInter1 + vtStart * (100.0 + dPlusEdge + dWidthBr1 * 0.5);
|
||
}
|
||
else
|
||
{
|
||
ptRet = ptInter + vtStart * (100.0 + dPlusEdge);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
GetIntersectWith(ptCor2, ptInter2, vtStartv, vtStart,ptInter);
|
||
if ((ptInter.distanceTo(ptInter2) + ddisPar) < dLength)
|
||
{
|
||
|
||
ptRet = ptInter2 + vtStart * (100.0 + dPlusEdge + dWidthBr2 * 0.5);
|
||
}
|
||
else
|
||
{
|
||
|
||
ptRet = ptInter + vtStart * (100.0 + dPlusEdge);
|
||
}
|
||
}
|
||
return ptRet;
|
||
}
|
||
|
||
AcGePoint3d ImpHvacCross::GetFinalPtEnd(AcGePoint3d ptStart,AcGePoint3d ptInter1,AcGePoint3d ptInter2,AcGePoint3d ptCor1,
|
||
AcGePoint3d ptCor2,AcGeVector3d vtStart, double dPlusEnd) const
|
||
{
|
||
AcGeVector3d vtNor = AcGeVector3d::kZAxis,vtStartv;
|
||
vtNor = GetSectNormal();
|
||
vtStartv = vtStart;
|
||
vtStartv.rotateBy(PI * 0.5,vtNor);
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
AcGePoint3d ptInter,ptRet;
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
double ddisPar = dPlusEnd + dPlusEdge;
|
||
AcGePoint3d ptDis = ptStart + vtStart * 10000;
|
||
double dis1 = ptDis.distanceTo(ptCor1);
|
||
double dis2 = ptDis.distanceTo(ptCor2);
|
||
if (dis1 < dis2)
|
||
{
|
||
GetIntersectWith(ptCor1, ptInter1, vtStartv, vtStart, ptInter);
|
||
ptRet = ptInter + vtStart * ddisPar;
|
||
}
|
||
else
|
||
{
|
||
GetIntersectWith(ptCor2, ptInter2, vtStartv, vtStart,ptInter);
|
||
ptRet = ptInter + vtStart * ddisPar;
|
||
}
|
||
return ptRet;
|
||
}
|
||
|
||
BOOL ImpHvacCross::GetInterfaceKeyPt(AcGePoint3dArray &ptUpArr, AcGePoint3dArray &ptDownArr) const
|
||
{
|
||
// 7━━━━━6
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// 0━━━━┛ ┃ ┗━━━━5
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// ━━━━━━━━━━━━━━━━
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// 1━━━━┓ ┃ ┏━━━━4
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// ┃ ┃ ┃
|
||
// 2━━━━━3
|
||
|
||
if (NULL == m_pXDataMap)
|
||
{
|
||
return FALSE;
|
||
}
|
||
ESection eSectTeye = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectTeye);
|
||
|
||
AcGePoint3d ptStart, ptEnd, ptBran1, ptBran2;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBran1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBran2);
|
||
|
||
AcGeVector3d vtNormal = normal();
|
||
AcGeVector3d vtStart, vtEnd, vtBran1, vtBran2;
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBran1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBran2);
|
||
AcGeVector3d vtStartSide = vtStart;
|
||
vtStartSide.rotateBy(PI * 0.5, vtNormal);
|
||
AcGeVector3d vtEndSide = vtEnd;
|
||
vtEndSide.rotateBy(PI * 0.5, vtNormal);
|
||
AcGeVector3d vtBranSide1 = vtBran1;
|
||
vtBranSide1.rotateBy(PI * 0.5, vtNormal);
|
||
AcGeVector3d vtBranSide2 = vtBran2;
|
||
vtBranSide2.rotateBy(PI * 0.5, vtNormal);
|
||
|
||
double dStrWidth = 0, dEndWidth = 0, dBranWidth1 = 0, dBranWidth2 = 0;
|
||
m_pXDataMap->GetAt(HCRS_StartWidth, dStrWidth);
|
||
m_pXDataMap->GetAt(HCRS_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HCRS_Branch1Width, dBranWidth1);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Width, dBranWidth2);
|
||
double dHalfStrWidth = dStrWidth * 0.5;
|
||
double dHalfEndWidth = dEndWidth * 0.5;
|
||
double dHalfBranWidth1 = dBranWidth1 * 0.5;
|
||
double dHalfBranWidth2 = dBranWidth2 * 0.5;
|
||
|
||
double dStrThick = 0, dEndThick = 0, dBranThick1 = 0, dBranThick2 = 0;
|
||
if(eRect != eSectTeye)
|
||
{
|
||
dStrThick = dStrWidth;
|
||
dEndThick = dEndWidth;
|
||
dBranThick1 = dBranWidth1;
|
||
dBranThick2 = dBranWidth2;
|
||
}
|
||
else
|
||
{
|
||
m_pXDataMap->GetAt(HCRS_Thick, dStrThick);
|
||
if(!m_pXDataMap->GetAt(HCRS_EndThick, dEndThick))
|
||
dEndThick = dStrThick;
|
||
m_pXDataMap->GetAt(HCRS_Branch1Thick, dBranThick1);
|
||
m_pXDataMap->GetAt(HCRS_Branch2Thick, dBranThick2);
|
||
}
|
||
|
||
double dHalfStrThick = dStrThick * 0.5;
|
||
double dHalfEndThick = dEndThick * 0.5;
|
||
double dHalfBranThick1 = dBranThick1 * 0.5;
|
||
double dHalfBranThick2 = dBranThick2 * 0.5;
|
||
|
||
AcGePoint3d ptUp, ptDown;
|
||
// pt0
|
||
ptUp = ptStart - vtStartSide * dHalfStrWidth;
|
||
ptUp = ptUp + vtNormal * dHalfStrThick;
|
||
ptUpArr.append(ptUp);
|
||
ptDown = ptUp - vtNormal * dStrThick;
|
||
ptDownArr.append(ptDown);
|
||
|
||
// pt1
|
||
ptUp = ptStart + vtStartSide * dHalfStrWidth;
|
||
ptUp = ptUp + vtNormal * dHalfStrThick;
|
||
ptUpArr.append(ptUp);
|
||
ptDown = ptUp - vtNormal * dStrThick;
|
||
ptDownArr.append(ptDown);
|
||
|
||
// pt2
|
||
ptUp = ptBran1 - vtBranSide1 * dHalfBranWidth1;
|
||
ptUp = ptUp + vtNormal * dHalfBranThick1;
|
||
ptUpArr.append(ptUp);
|
||
ptDown = ptUp - vtNormal * dBranThick1;
|
||
ptDownArr.append(ptDown);
|
||
|
||
// pt3
|
||
ptUp = ptBran1 + vtBranSide1 * dHalfBranWidth1;
|
||
ptUp = ptUp + vtNormal * dHalfBranThick1;
|
||
ptUpArr.append(ptUp);
|
||
ptDown = ptUp - vtNormal * dBranThick1;
|
||
ptDownArr.append(ptDown);
|
||
|
||
// pt4
|
||
ptUp = ptEnd - vtEndSide * dHalfEndWidth;
|
||
ptUp = ptUp + vtNormal * dHalfEndThick;
|
||
ptUpArr.append(ptUp);
|
||
ptDown = ptUp - vtNormal * dEndThick;
|
||
ptDownArr.append(ptDown);
|
||
|
||
// pt5
|
||
ptUp = ptEnd + vtEndSide * dHalfEndWidth;
|
||
ptUp = ptUp + vtNormal * dHalfEndThick;
|
||
ptUpArr.append(ptUp);
|
||
ptDown = ptUp - vtNormal * dEndThick;
|
||
ptDownArr.append(ptDown);
|
||
|
||
// pt6
|
||
ptUp = ptBran2 - vtBranSide2 * dHalfBranWidth2;
|
||
ptUp = ptUp + vtNormal * dHalfBranThick2;
|
||
ptUpArr.append(ptUp);
|
||
ptDown = ptUp - vtNormal * dBranThick2;
|
||
ptDownArr.append(ptDown);
|
||
|
||
// pt7
|
||
ptUp = ptBran2 + vtBranSide2 * dHalfBranWidth2;
|
||
ptUp = ptUp + vtNormal * dHalfBranThick2;
|
||
ptUpArr.append(ptUp);
|
||
ptDown = ptUp - vtNormal * dBranThick2;
|
||
ptDownArr.append(ptDown);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
double ImpHvacCross::InsertLength(double dEndWidth, double dBr1Width, double dBr2Width,
|
||
double dFlange, double dAngle, AecHvac::HvacCrossType eType) const
|
||
{
|
||
double dWidth = dBr1Width > dBr2Width ? dBr1Width : dBr2Width;
|
||
if (AecHvac::eInsertCross == eType)
|
||
{
|
||
// 承插标准长度算法
|
||
if ((int)dAngle == 30)
|
||
{
|
||
return dEndWidth + dWidth + 1.866 * (dFlange * 2.0 + 20);
|
||
}
|
||
if ((int)dAngle == 45)
|
||
{
|
||
return (dEndWidth + dWidth) * 0.65 + 1.21 * (dFlange * 2.0 + 20);
|
||
}
|
||
}
|
||
|
||
if (AecHvac::eInclineCross == eType)
|
||
{
|
||
// 斜接标准长度算法
|
||
double dTmp = (dWidth * cos(dAngle * PI / 180) + dEndWidth) * 0.5 * 1.4 / sin(dAngle * PI / 180);
|
||
|
||
int iTmp = (int)dTmp;
|
||
int iDivNum = iTmp / 50;
|
||
int iNum = iTmp % 50;
|
||
if (iNum != 0)
|
||
{
|
||
iDivNum++;
|
||
}
|
||
|
||
iTmp = iDivNum * 50;
|
||
dTmp = (double)iTmp;
|
||
dTmp += dFlange;
|
||
|
||
return dTmp;
|
||
}
|
||
return dWidth;
|
||
}
|
||
|
||
BOOL ImpHvacCross::GetInterfaceSizeData(int nIndex, AecInterface& inf) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
// 获取对象类型
|
||
AecHvac::HvacCrossType eType = AecHvac::eOrthoCross;
|
||
m_pXDataMap->GetAt(HCRS_Type, (int&)eType);
|
||
|
||
// 获取截面类型
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
|
||
|
||
// 获取接口截面、宽度、厚度数据key值
|
||
LPCTSTR pszWidthKey, pszThickKey;
|
||
switch (nIndex)
|
||
{
|
||
case 0:
|
||
pszWidthKey = ((eCircle == eSectType) ? HCRS_StartDiameter : HCRS_StartWidth);
|
||
pszThickKey = HCRS_Thick;
|
||
break;
|
||
case 1:
|
||
pszWidthKey = ((eCircle == eSectType) ? HCRS_EndDiameter : HCRS_EndWidth);
|
||
pszThickKey = HCRS_Thick;
|
||
break;
|
||
case 2:
|
||
pszWidthKey = ((eCircle == eSectType) ? HCRS_Branch1Diameter : HCRS_Branch1Width);
|
||
pszThickKey = ((AecHvac::eInsertCross == eType || AecHvac::eInsertIntubCross == eType) ? HCRS_Branch1Thick : HCRS_Thick);
|
||
break;
|
||
case 3:
|
||
pszWidthKey = ((eCircle == eSectType) ? HCRS_Branch2Diameter : HCRS_Branch2Width);
|
||
pszThickKey = ((AecHvac::eInsertCross == eType || AecHvac::eInsertIntubCross == eType) ? HCRS_Branch2Thick : HCRS_Thick);
|
||
break;
|
||
default:
|
||
return FALSE;
|
||
}
|
||
|
||
// 获取尺寸
|
||
double dWidth = 0.0, dThick = 0.0;
|
||
m_pXDataMap->GetAt(pszWidthKey, dWidth);
|
||
m_pXDataMap->GetAt(pszThickKey, dThick);
|
||
|
||
// 设置接口数据
|
||
inf.nSectType = eSectType;
|
||
inf.dSize1 = dWidth;
|
||
inf.dSize2 = dThick;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
bool ImpHvacCross::GetInterface(AcArray<AecInterface>& arInfs) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 获取四通各点位置
|
||
AcGePoint3d ptStart,ptEnd,ptBr1,ptBr2;
|
||
AcGeVector3d vtStart,vtEnd,vtBr1,vtBr2;
|
||
m_pXDataMap->GetAt(HCRS_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
||
m_pXDataMap->GetAt(HCRS_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint1, ptBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir1, vtBr1);
|
||
m_pXDataMap->GetAt(HCRS_BranchPoint2, ptBr2);
|
||
m_pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
||
|
||
AecInterface inf;
|
||
inf.idOwner = m_pOwnerEnt->objectId();
|
||
for (int nIndex = 0;nIndex <= 3;nIndex++)
|
||
{
|
||
switch(nIndex)
|
||
{
|
||
case 0:
|
||
{
|
||
// 没有管件连接
|
||
inf.vtDir = vtStart;
|
||
inf.ptPos = ptStart;
|
||
GetInterfaceSizeData(nIndex, inf);
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
// 没有管件连接
|
||
inf.vtDir = vtEnd;
|
||
inf.ptPos = ptEnd;
|
||
GetInterfaceSizeData(nIndex, inf);
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
// 没有管件连接
|
||
inf.vtDir = vtBr1;
|
||
inf.ptPos = ptBr1;
|
||
GetInterfaceSizeData(nIndex, inf);
|
||
break;
|
||
}
|
||
case 3:
|
||
{
|
||
// 没有管件连接
|
||
inf.vtDir = vtBr2;
|
||
inf.ptPos = ptBr2;
|
||
GetInterfaceSizeData(nIndex, inf);
|
||
break;
|
||
}
|
||
}
|
||
arInfs.append(inf);
|
||
}
|
||
return true;
|
||
} |