6249 lines
163 KiB
C++
6249 lines
163 KiB
C++
#include "stdafx.h"
|
||
#include "ImpHvacElbow.h"
|
||
#include "AecDbObjXDataMap.h"
|
||
#include "KTSetting.h"
|
||
#include "AecDbEntityBase.h"
|
||
|
||
#ifdef _DEBUG
|
||
#undef THIS_FILE
|
||
static char THIS_FILE[]=__FILE__;
|
||
#define new DEBUG_NEW
|
||
#endif
|
||
|
||
double MayAsMUnit(double dVal)
|
||
{
|
||
struct resbuf rb;
|
||
acedGetVar(_T("INSUNITS"), &rb);
|
||
if (rb.resval.rint == AcDb::kUnitsMeters)
|
||
{
|
||
dVal *= 0.001;
|
||
}
|
||
return dVal;
|
||
}
|
||
|
||
//导流片参数{DN，片数，x,x,x,间距}
|
||
const int nLeader[][15] = {{500, 4, 95, 120, 140, 165, 0},
|
||
{630, 4, 115, 145, 170, 200, 0},
|
||
{800, 6, 105, 125, 140, 160, 175, 195, 0},
|
||
{1000, 7, 115, 130, 150, 165, 180, 200, 215, 0},
|
||
{1250, 8, 125, 140, 155, 170, 190, 205, 220, 235, 0},
|
||
{1600, 10, 135, 150, 160, 175, 190, 205, 215, 230, 245, 255, 0},
|
||
{2000, 12, 145, 155, 170, 180, 195, 205, 215, 230, 240, 255, 265, 280, 0}};
|
||
|
||
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
|
||
extern AcGeVector3d GetUcsZvt();
|
||
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb = NULL,bool bClose = true);
|
||
|
||
double GetMinDiffAngle()
|
||
{
|
||
double dMinDiffAng = PI/12;
|
||
return dMinDiffAng;
|
||
}
|
||
|
||
ImpHvacElbow::ImpHvacElbow()
|
||
{
|
||
m_pXDataMap = NULL;
|
||
m_pOwnerEnt = NULL;
|
||
}
|
||
|
||
ImpHvacElbow::~ImpHvacElbow()
|
||
{
|
||
}
|
||
|
||
BOOL ImpHvacElbow::IsHorzAlignment() const
|
||
{
|
||
// 取得位置点
|
||
AcGePoint3d ptStart, ptCorner, ptEnd, ptCornerAssist;
|
||
m_pXDataMap->GetAt(HELB_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint, ptCorner);
|
||
if (!m_pXDataMap->GetAt(HELB_AssisCornerPoint, ptCornerAssist))
|
||
{
|
||
ptCornerAssist = ptCorner;
|
||
}
|
||
m_pXDataMap->GetAt(HELB_EndPoint, ptEnd);
|
||
|
||
// 获得法向量
|
||
AcGeVector3d vtNormal((ptStart - ptCorner).crossProduct(ptEnd - ptCornerAssist));
|
||
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
AcGeTol tolTmp;
|
||
tolTmp.setEqualPoint(1);
|
||
tolTmp.setEqualVector(/*1*/1E-3);//Lixlmodify
|
||
return vtNormal.isParallelTo(vtZAxis, tolTmp);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::IsVertAlignment() const
|
||
{
|
||
// 取得位置点
|
||
AcGePoint3d ptStart, ptCorner, ptEnd, ptCornerAssist;
|
||
m_pXDataMap->GetAt(HELB_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint, ptCorner);
|
||
if (!m_pXDataMap->GetAt(HELB_AssisCornerPoint, ptCornerAssist))
|
||
{
|
||
ptCornerAssist = ptCorner;
|
||
}
|
||
m_pXDataMap->GetAt(HELB_EndPoint, ptEnd);
|
||
|
||
// 获得法向量
|
||
AcGeVector3d vtNormal((ptStart - ptCorner).crossProduct(ptEnd - ptCornerAssist));
|
||
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
|
||
return vtNormal.isPerpendicularTo(vtZAxis);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::IsInclineAlignment() const
|
||
{
|
||
// 取得位置点
|
||
AcGePoint3d ptStart, ptCorner, ptEnd, ptCornerAssist;
|
||
m_pXDataMap->GetAt(HELB_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint, ptCorner);
|
||
if (!m_pXDataMap->GetAt(HELB_AssisCornerPoint, ptCornerAssist))
|
||
{
|
||
ptCornerAssist = ptCorner;
|
||
}
|
||
m_pXDataMap->GetAt(HELB_EndPoint, ptEnd);
|
||
|
||
// 获得法向量
|
||
AcGeVector3d vtNormal((ptStart - ptCorner).crossProduct(ptEnd - ptCornerAssist));
|
||
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
|
||
return !vtNormal.isPerpendicularTo(vtZAxis) && !vtNormal.isParallelTo(vtZAxis);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::IsSingleLine() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
BOOL bSingleLine = FALSE;
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine, (int&)bSingleLine);
|
||
|
||
return bSingleLine;
|
||
}
|
||
|
||
BOOL ImpHvacElbow::HasBaseLine() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
BOOL bHasBaseLine = FALSE;
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLine);
|
||
|
||
return bHasBaseLine;
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacElbow::Draw3d(AcGiDraw &mode) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eOk;
|
||
|
||
// 弯头类型
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
|
||
// 根据不同类型绘制不同弯头
|
||
switch (eElbowType)
|
||
{
|
||
case AecHvac::eAllArcuate: // 内外圆弧
|
||
DrawAllArcuate3d(mode);
|
||
break;
|
||
case AecHvac::eAllArcWrap: // 内外圆弧消声
|
||
DrawAllArcWrap3d(mode);
|
||
break;
|
||
case AecHvac::eAllArcInWrap: // 消声弯头
|
||
DrawAllArcInWrap3d(mode);
|
||
break;
|
||
case AecHvac::eSegmental: // 分段拟合
|
||
DrawSegmental3d(mode);
|
||
break;
|
||
case AecHvac::eIncline: // 内斜线
|
||
DrawIncline3d(mode);
|
||
break;
|
||
case AecHvac::eInclineWrap: // 内斜线消声
|
||
DrawInclineWrap3d(mode);
|
||
break;
|
||
case AecHvac::eInclineBoard: // 内斜线隔板消声
|
||
DrawInclineBoard3d(mode);
|
||
break;
|
||
case AecHvac::eInclineLead: // 内斜线导流
|
||
DrawInclineLead3d(mode);
|
||
break;
|
||
case AecHvac::eArcuate: // 内弧线
|
||
DrawArcuate3d(mode);
|
||
break;
|
||
case AecHvac::eArcuateWrap: // 内弧线消声
|
||
DrawArcuateWrap3d(mode);
|
||
break;
|
||
case AecHvac::eArcuateBoard: // 内弧线隔板消声
|
||
DrawArcuateBoard3d(mode);
|
||
break;
|
||
case AecHvac::eArcuateSieve: // 内弧线筛板消声
|
||
DrawArcuateSieve3d(mode);
|
||
break;
|
||
case AecHvac::eArcuateLead: // 内弧线导流
|
||
DrawArcuateLead3d(mode);
|
||
break;
|
||
case AecHvac::eAllOrtho: // 内外直角
|
||
DrawAllOrtho3d(mode);
|
||
break;
|
||
case AecHvac::eOrthoWrap: // 内外直角消声
|
||
DrawOrthoWrap3d(mode);
|
||
break;
|
||
case AecHvac::eOrthoLead: // 内外直角导流
|
||
DrawOrthoLead3d(mode);
|
||
break;
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDbObjectId ImpHvacElbow::layerId() const
|
||
{
|
||
if (m_pOwnerEnt != NULL)
|
||
{
|
||
m_pOwnerEnt->layerId();
|
||
}
|
||
return AcDbObjectId::kNull;
|
||
}
|
||
|
||
AcDbObjectId ImpHvacElbow::DashLayer() const
|
||
{
|
||
return m_idDashLayer;
|
||
}
|
||
|
||
AcDbObjectId ImpHvacElbow::CenterLayer() const
|
||
{
|
||
return m_idCenterLayer;
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacElbow::Draw2d(AcGiDraw &mode) const
|
||
{
|
||
if (m_pXDataMap == NULL || m_pOwnerEnt == NULL)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AecComplexCurve cplCurve;
|
||
MakeCurves(cplCurve);
|
||
|
||
AecComplexCurveDraw edage;
|
||
edage.SetEdage(cplCurve);
|
||
|
||
BOOL bWeight = FALSE;
|
||
|
||
AcDbObjectId idReal = m_idDoubleLayer;
|
||
AcDbObjectId idDash = DashLayer();
|
||
AcDbObjectId idCent = CenterLayer();
|
||
|
||
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);
|
||
|
||
//缓存
|
||
//AcDbVoidPtrArray arPtrs;
|
||
//edage.explode(arPtrs,idReal,idDash,idCent,NULL,TRUE);
|
||
//m_pOwnerEnt->Add2DBuffer(arPtrs);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeCurves(AecComplexCurve& cplCurve) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 弯头类型
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
int nIsSingleLine = 0;
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine, nIsSingleLine);
|
||
int nType = 0;
|
||
//单线形式直接return
|
||
if (1 == nIsSingleLine)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
// 根据不同类型构建外轮廓
|
||
switch (eElbowType)
|
||
{
|
||
case AecHvac::eAllArcuate: // 内外圆弧
|
||
return MakeAllArcuate2DCurves(cplCurve,nType);
|
||
case AecHvac::eAllArcWrap: // 内外圆弧消声
|
||
return MakeAllArcWrap2DCurves(cplCurve,nType);
|
||
case AecHvac::eAllArcInWrap: // 消声弯头
|
||
return MakeAllArcInWrap2DCurves(cplCurve,nType);
|
||
case AecHvac::eSegmental: // 分段拟合
|
||
return MakeSegmental2DCurves(cplCurve,nType);
|
||
case AecHvac::eIncline: // 内斜线
|
||
return MakeIncline2DCurves(cplCurve,nType);
|
||
case AecHvac::eInclineWrap: // 内斜线消声
|
||
return MakeInclineWrap2DCurves(cplCurve,nType);
|
||
case AecHvac::eInclineBoard: // 内斜线隔板消声
|
||
return MakeInclineBoard2DCurves(cplCurve,nType);
|
||
case AecHvac::eInclineLead: // 内斜线导流
|
||
return MakeInclineLead2DCurves(cplCurve,nType);
|
||
case AecHvac::eArcuate: // 内弧线
|
||
return MakeArcuate2DCurves(cplCurve,nType);
|
||
case AecHvac::eArcuateWrap: // 内弧线消声
|
||
return MakeArcuateWrap2DCurves(cplCurve,nType);
|
||
case AecHvac::eArcuateBoard: // 内弧线隔板消声
|
||
return MakeArcuateBoard2DCurves(cplCurve,nType);
|
||
case AecHvac::eArcuateSieve: // 内弧线筛板消声
|
||
return MakeArcuateSieve2DCurves(cplCurve,nType);
|
||
case AecHvac::eArcuateLead: // 内弧线导流
|
||
return MakeArcuateLead2DCurves(cplCurve,nType);
|
||
case AecHvac::eAllOrtho: // 内外直角
|
||
return MakeAllOrtho2DCurves(cplCurve,nType);
|
||
case AecHvac::eOrthoWrap: // 内外直角消声
|
||
return MakeOrthoWrap2DCurves(cplCurve,nType);
|
||
case AecHvac::eOrthoLead: // 内外直角导流
|
||
return MakeOrthoLead2DCurves(cplCurve,nType);
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL ImpHvacElbow::GetCurvesInSide(AecComplexCurve& compCurve) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 弯头类型
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
int nType = 1;
|
||
// 根据不同类型构建内部图形
|
||
switch (eElbowType)
|
||
{
|
||
case AecHvac::eAllArcuate: // 内外圆弧
|
||
return MakeAllArcuate2DCurves(compCurve,nType);
|
||
case AecHvac::eAllArcWrap: // 内外圆弧消声
|
||
return MakeAllArcWrap2DCurves(compCurve,nType);
|
||
case AecHvac::eSegmental: // 分段拟合
|
||
return MakeSegmental2DCurves(compCurve,nType);
|
||
case AecHvac::eIncline: // 内斜线
|
||
return MakeIncline2DCurves(compCurve,nType);
|
||
case AecHvac::eInclineWrap: // 内斜线消声
|
||
return MakeInclineWrap2DCurves(compCurve,nType);
|
||
case AecHvac::eInclineBoard: // 内斜线隔板消声
|
||
return MakeInclineBoard2DCurves(compCurve,nType);
|
||
case AecHvac::eInclineLead: // 内斜线导流
|
||
return MakeInclineLead2DCurves(compCurve,nType);
|
||
case AecHvac::eArcuate: // 内弧线
|
||
return MakeArcuate2DCurves(compCurve,nType);
|
||
case AecHvac::eArcuateWrap: // 内弧线消声
|
||
return MakeArcuateWrap2DCurves(compCurve,nType);
|
||
case AecHvac::eArcuateBoard: // 内弧线隔板消声
|
||
return MakeArcuateBoard2DCurves(compCurve,nType);
|
||
case AecHvac::eArcuateSieve: // 内弧线筛板消声
|
||
return MakeArcuateSieve2DCurves(compCurve,nType);
|
||
case AecHvac::eArcuateLead: // 内弧线导流
|
||
return MakeArcuateLead2DCurves(compCurve,nType);
|
||
case AecHvac::eAllOrtho: // 内外直角
|
||
return MakeAllOrtho2DCurves(compCurve,nType);
|
||
case AecHvac::eOrthoWrap: // 内外直角消声
|
||
return MakeOrthoWrap2DCurves(compCurve,nType);
|
||
case AecHvac::eOrthoLead: // 内外直角导流
|
||
return MakeOrthoLead2DCurves(compCurve,nType);
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacElbow::transformBy(const AcGeMatrix3d& xform)
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotApplicable;
|
||
|
||
// 取得位置点
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
m_pXDataMap->GetAt(HELB_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint, ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint, ptEnd);
|
||
|
||
// 变换位置
|
||
ptStart.transformBy(xform);
|
||
ptCorner.transformBy(xform);
|
||
ptEnd.transformBy(xform);
|
||
|
||
// 更新点
|
||
m_pXDataMap->SetAt(HELB_StartPoint, ptStart);
|
||
m_pXDataMap->SetAt(HELB_CornerPoint, ptCorner);
|
||
m_pXDataMap->SetAt(HELB_EndPoint, ptEnd);
|
||
|
||
AcGePoint3d ptCornerSub; //辅助拐点
|
||
if (m_pXDataMap->GetAt(HELB_AssisCornerPoint, ptCornerSub))
|
||
{
|
||
ptCornerSub.transformBy(xform);
|
||
m_pXDataMap->SetAt(HELB_AssisCornerPoint, ptCornerSub);
|
||
}
|
||
|
||
double dScale = xform.scale();
|
||
double dStaWidth(0.0), dEndWidth(0.), dThick(0.0);
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dStaWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HELB_Thick, dThick);
|
||
|
||
dStaWidth *= dScale;
|
||
dEndWidth *= dScale;
|
||
dThick *= dScale;
|
||
m_pXDataMap->SetAt(HELB_StartWidth, dStaWidth);
|
||
m_pXDataMap->SetAt(HELB_EndWidth, dEndWidth);
|
||
m_pXDataMap->SetAt(HELB_Thick, dThick);
|
||
|
||
double dThickEnd = 0.0; //弯头尾部厚度
|
||
if (m_pXDataMap->GetAt(HELB_EndThick, dThickEnd))
|
||
{
|
||
dThickEnd *= dScale;
|
||
m_pXDataMap->SetAt(HELB_EndThick, dThickEnd);
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AecEqui::Position ImpHvacElbow::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::eCommand0;
|
||
break;
|
||
case 3:
|
||
ePos = AecEqui::eCommand1;
|
||
break;
|
||
case 4:
|
||
ePos = AecEqui::eCommand2;
|
||
break;
|
||
}
|
||
return ePos;
|
||
}
|
||
|
||
void ImpHvacElbow::DrawAllArcuate3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
int nSectType = 0;
|
||
m_pXDataMap->GetAt(HVAC_SectType,nSectType);
|
||
switch(nSectType)
|
||
{
|
||
case eRect:// 矩形
|
||
{
|
||
DrawAllArcuate3dRec(mode);
|
||
break;
|
||
}
|
||
case eCircle:// 圆形
|
||
{
|
||
DrawAllArcuate3dCir(mode);
|
||
break;
|
||
}
|
||
case eOblate: // 扁圆形
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//圆形3D
|
||
void ImpHvacElbow::DrawAllArcuate3dCir(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dDiameter = MayAsMUnit(300.0);
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
double dThick = MayAsMUnit(50.0);
|
||
double dStaWidth = MayAsMUnit(150.0);
|
||
double dEndWidth = MayAsMUnit(150.0);
|
||
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine;
|
||
int nSectType = 2;
|
||
m_pXDataMap->GetAt(HVAC_SectType,nSectType);
|
||
m_pXDataMap->GetAt(HELB_Diameter,dStaWidth);
|
||
|
||
//BEGIN==========================================
|
||
if (!m_pXDataMap->GetAt(HELB_EndDiameter, dEndWidth))
|
||
{
|
||
dEndWidth = dStaWidth;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
|
||
double dMaxWidth = dStaWidth > dEndWidth ? dStaWidth : dEndWidth;
|
||
|
||
if ((ptStart.distanceTo(ptCorner) - MayAsMUnit(50.0)) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
int nWrapType = 0;
|
||
m_pXDataMap->GetAt(HELB_Type,nWrapType);
|
||
double dWrap = 50;
|
||
if (2 == nWrapType)
|
||
{
|
||
if (dDiameter <= MayAsMUnit(100))
|
||
{
|
||
dWrap = dDiameter * 0.1;
|
||
}
|
||
dDiameter += dWrap * 2;
|
||
}
|
||
|
||
//以拐点为参照的矢量
|
||
AcGeVector3d vtStart = ptStart - ptCorner;
|
||
AcGeVector3d vtEnd = ptEnd - ptCorner;
|
||
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
|
||
//求得中心线起点和终点
|
||
double dRadius = ptCorner.distanceTo(ptStart) -dPlusEdge;
|
||
AcGePoint3d ptStartArc = ptCorner + vtStart * dRadius;
|
||
AcGePoint3d ptEndArc = ptCorner + vtEnd * dRadius;
|
||
|
||
//求得平面法向量和中心线圆心
|
||
AcGeVector3d vtGNormal = this->normal();
|
||
vtGNormal.normalize();
|
||
|
||
AcGePoint3d ptGeCen;
|
||
AcGeVector3d vtStartTmp = vtStart;
|
||
AcGeVector3d vtEndTmp = vtEnd;
|
||
vtStartTmp.rotateBy(PI * 0.5,vtGNormal);
|
||
vtEndTmp.rotateBy(PI * 0.5,vtGNormal);
|
||
AcGeLine3d lineStart(ptStartArc, vtStartTmp);
|
||
AcGeLine3d lineEnd(ptEndArc, vtEndTmp);
|
||
Adesk::Boolean bRet = lineStart.intersectWith(lineEnd, ptGeCen);
|
||
if(!bRet) // 中心线圆心计算失败
|
||
{
|
||
return;
|
||
}
|
||
|
||
//求得中心线圆弧半径
|
||
dRadius = ptGeCen.distanceTo(ptStartArc);
|
||
|
||
//以中心线圆心为参照的矢量
|
||
AcGeVector3d vtGStart = ptStartArc - ptGeCen;
|
||
AcGeVector3d vtGEnd = ptEndArc - ptGeCen;
|
||
vtGStart.normalize();
|
||
vtGEnd.normalize();
|
||
AcDbCircle entCircle(ptGeCen, vtGNormal, dRadius);
|
||
|
||
//弯头的角度
|
||
double dAngle = vtGStart.angleTo(vtGEnd);
|
||
|
||
if (dAngle < 10e-9)
|
||
return;
|
||
|
||
//最小分角
|
||
double dMinDiffAng = GetMinDiffAngle();
|
||
|
||
//弧形截面数
|
||
int nRows = int(dAngle / dMinDiffAng);
|
||
// add by zh 2013-7-29 处理角度<最小分角的情况
|
||
if (nRows == 0)
|
||
nRows = 1;
|
||
//
|
||
dMinDiffAng = dAngle / nRows;
|
||
|
||
//各截面中的关键点数
|
||
int nColumns = int(2 * PI / dMinDiffAng);
|
||
|
||
//关键节点数组
|
||
AcGePoint3dArray arptKey;
|
||
|
||
//直线段（开始处前端）
|
||
AcGePoint3d pt = ptStart + vtGStart * dStaWidth / 2;
|
||
|
||
for(int i = 0; i < nColumns; i++)
|
||
{
|
||
arptKey.append(pt);
|
||
pt.rotateBy(dMinDiffAng, vtStart, ptStart);
|
||
}
|
||
pt = ptStart + vtGStart * dStaWidth / 2;
|
||
arptKey.append(pt);
|
||
|
||
//弧线段
|
||
AcDbEllipse entEll;
|
||
AcGePoint3d ptTemp;
|
||
AcGeVector3d vtRLong;
|
||
double dRLong = 0.0;
|
||
double dRShort = 0.0;
|
||
double dRatio = 0.0;
|
||
if(fabs(dAngle - PI/2) < 1e-6)
|
||
{
|
||
dRLong = dRadius + (dStaWidth > dEndWidth ? dStaWidth : dEndWidth) / 2;
|
||
dRShort = dRadius + (dStaWidth < dEndWidth ? dStaWidth : dEndWidth) / 2;
|
||
dRatio = dRShort / dRLong;
|
||
vtRLong = (dStaWidth > dEndWidth ? vtGStart * dRLong : vtGEnd * dRLong);
|
||
}
|
||
else
|
||
{
|
||
double dA = 0.0;
|
||
double dB = 0.0;
|
||
if(dStaWidth >= dEndWidth)
|
||
{
|
||
dA = dRadius + dStaWidth/2;
|
||
dRLong = dA;
|
||
vtRLong = vtGStart * dRLong;
|
||
double dEndToGOri = dRadius + dEndWidth / 2;
|
||
double dXEnd = fabs(dEndToGOri * sin(dAngle));
|
||
double dYEnd = fabs(dEndToGOri * cos(dAngle));
|
||
dB = dA * dXEnd / sqrt(dA * dA - dYEnd * dYEnd);
|
||
dRShort = dB;
|
||
dRatio = dRShort / dRLong;
|
||
}
|
||
else
|
||
{
|
||
dB = dRadius + dStaWidth/2;
|
||
dRShort = dB;
|
||
double dEndToGOri = dRadius + dEndWidth / 2;
|
||
double dXEnd = fabs(dEndToGOri * sin(dAngle));
|
||
double dYEnd = fabs(dEndToGOri * cos(dAngle));
|
||
dA = dB * dXEnd / sqrt(dB * dB - dYEnd * dYEnd);
|
||
dRLong = dA;
|
||
AcGeVector3d vtBuf = vtGStart;
|
||
vtRLong = vtBuf.rotateBy(-PI/2, vtGNormal) * dRLong;
|
||
dRatio = dRShort/dRLong;
|
||
}
|
||
}
|
||
|
||
//构建椭圆轨迹
|
||
entEll.set(ptGeCen, vtGNormal, vtRLong, dRatio);
|
||
|
||
double dStepC = -1.0;
|
||
double dStepE = -1.0;
|
||
|
||
entCircle.getParamAtPoint(ptStartArc, dStepC);
|
||
double dTemp = 0;
|
||
AcGePoint3d ptGArc;
|
||
entCircle.getStartParam(dTemp);
|
||
entCircle.getPointAtParam(dTemp, ptGArc);
|
||
|
||
AcGeVector3d vt = ptGArc - ptGeCen;
|
||
|
||
double dAngleCtoE = vt.angleTo(vtRLong, vtGNormal);
|
||
dStepE = dStepC - dAngleCtoE;
|
||
|
||
int nTemp = nRows;
|
||
AcGeVector3d vtNormal;
|
||
AcGeVector3d vtTest;
|
||
double dRet = 0.0;
|
||
for(; nTemp > 0; dStepC -= dMinDiffAng, dStepE -= dMinDiffAng, nTemp--)
|
||
{
|
||
if(fabs(dStepE - 0) < 1e-6)
|
||
{
|
||
dStepE += 2*PI;
|
||
}
|
||
if(fabs(dStepC - 0) < 1e-6)
|
||
{
|
||
dStepC += 2*PI;
|
||
}
|
||
entEll.getPointAtParam(dStepE, pt);
|
||
entCircle.getPointAtParam(dStepC, ptTemp);
|
||
entCircle.getFirstDeriv(ptTemp, vtNormal);
|
||
|
||
for(int i = 0; i < nColumns; i++)
|
||
{
|
||
arptKey.append(pt);
|
||
pt.rotateBy(dMinDiffAng, vtNormal, ptTemp);
|
||
}
|
||
|
||
entEll.getPointAtParam(dStepE, pt);
|
||
arptKey.append(pt);
|
||
}
|
||
|
||
//直线段（结束处前端和后端）
|
||
pt = ptEndArc + vtGEnd * dEndWidth / 2;
|
||
|
||
for(int m = 0; m < nColumns; m++)
|
||
{
|
||
arptKey.append(pt);
|
||
pt.rotateBy(dMinDiffAng, -vtEnd, ptEnd);
|
||
}
|
||
|
||
pt = ptEndArc + vtGEnd * dEndWidth / 2;
|
||
arptKey.append(pt);
|
||
|
||
pt = ptEnd + vtGEnd * dEndWidth / 2;
|
||
|
||
for(int n = 0; n < nColumns; n++)
|
||
{
|
||
arptKey.append(pt);
|
||
pt.rotateBy(dMinDiffAng, -vtEnd, ptEnd);
|
||
}
|
||
pt = ptEnd + vtGEnd * dEndWidth / 2;
|
||
arptKey.append(pt);
|
||
|
||
//绘制三维图形
|
||
DrawMesh(mode,nRows + 3, nColumns + 1, arptKey.asArrayPtr());
|
||
}
|
||
|
||
//方形3D
|
||
void ImpHvacElbow::DrawAllArcuate3dRec(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dDiameter = MayAsMUnit(300.0);
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
|
||
//========================================
|
||
double dStartThick = MayAsMUnit(50.0);
|
||
double dEndThick = MayAsMUnit(50.0);
|
||
|
||
double dStaWidth = MayAsMUnit(150.0);
|
||
double dEndWidth = MayAsMUnit(150.0);
|
||
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
AcGePoint3d ptCorStart, ptCorEnd;
|
||
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine;
|
||
|
||
m_pXDataMap->GetAt(HELB_Thick,dStartThick);
|
||
BOOL bRet = m_pXDataMap->GetAt(HELB_EndThick, dEndThick);
|
||
if (!bRet)
|
||
{
|
||
dEndThick = dStartThick;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_StartWidth,dStaWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth,dEndWidth);
|
||
//m_pXDataMap->GetAt(HVAC_PlusEdge,dPlusEdge);
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorStart);
|
||
if (!m_pXDataMap->GetAt(HELB_AssisCornerPoint, ptCorEnd))
|
||
{
|
||
ptCorEnd = ptCorStart;
|
||
}
|
||
|
||
double dMaxWidth = dStaWidth > dEndWidth ? dStaWidth : dEndWidth;
|
||
|
||
if ((ptStart.distanceTo(ptCorStart) - MayAsMUnit(50.0)) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
|
||
int nWrapType = 0;
|
||
m_pXDataMap->GetAt(HELB_Type,nWrapType);
|
||
|
||
AcGeVector3d vtCorStartCom = ptCorStart.asVector();
|
||
AcGeVector3d vtCorEndCom = ptCorEnd.asVector();
|
||
AcGeVector3d vtCornerCom = (vtCorStartCom + vtCorEndCom) / 2;
|
||
ptCorner = AcGePoint3d::kOrigin + vtCornerCom;
|
||
|
||
AcGeVector3d vtStart = ptStart - ptCorStart;
|
||
AcGeVector3d vtEnd = ptEnd - ptCorEnd;
|
||
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
|
||
//求得中心线起点和终点
|
||
double dRadius = ptCorStart.distanceTo(ptStart) - dPlusEdge;
|
||
AcGePoint3d ptStartArc = ptCorStart + vtStart * dRadius;
|
||
AcGePoint3d ptEndArc = ptCorEnd + vtEnd * dRadius;
|
||
|
||
//求得平面法向量和中心线圆心
|
||
AcGeVector3d vtStartTmp = ptStartArc - ptCorner;
|
||
AcGeVector3d vtEndTmp = ptEndArc - ptCorner;
|
||
AcGeVector3d vtGNormal = vtStartTmp.crossProduct(vtEndTmp);
|
||
vtGNormal.normalize();
|
||
|
||
AcGePoint3d ptGeCen;
|
||
|
||
vtStartTmp.rotateBy(PI * 0.5, vtGNormal);
|
||
vtEndTmp.rotateBy(PI * 0.5, vtGNormal);
|
||
AcGeLine3d lineStart(ptStartArc, vtStartTmp);
|
||
AcGeLine3d lineEnd(ptEndArc, vtEndTmp);
|
||
|
||
if(!lineStart.intersectWith(lineEnd, ptGeCen)) // 中心线圆心计算失败
|
||
{
|
||
return;
|
||
}
|
||
|
||
//求得中心线圆弧半径
|
||
dRadius = ptGeCen.distanceTo(ptStartArc);
|
||
|
||
//弯头剖面内坐标向量
|
||
AcGeVector3d vtNormal = vtStart.crossProduct(vtEnd);
|
||
AcGeVector3d vtGStart = vtStart.rotateBy(-PI / 2, vtNormal);
|
||
AcGeVector3d vtGEnd = vtEnd.rotateBy(PI / 2, vtNormal);
|
||
vtGStart.normalize();
|
||
vtGEnd.normalize();
|
||
|
||
AcDbCircle entCircle(ptGeCen, vtGNormal, dRadius);
|
||
|
||
//弯头的角度
|
||
double dAngle = vtGStart.angleTo(vtGEnd);
|
||
|
||
//最小分角
|
||
double dMinDiffAng = GetMinDiffAngle();
|
||
|
||
int nRows = (int)(PI * 2 / dMinDiffAng);
|
||
|
||
AcGeVector3d vtCor = ptCorner - ptGeCen;
|
||
vtCor.normalize();
|
||
|
||
//求得中心线圆弧上点
|
||
AcGePoint3d ptOnArc = ptGeCen + vtCor * dRadius;
|
||
|
||
//关键节点数组
|
||
AcGePoint3dArray arptKey; //存储网格使用
|
||
AcGePoint3dArray arptArcHead; //存储边线弧形起点
|
||
AcGePoint3dArray arptArcTail; //存储边线弧形尾点
|
||
AcGePoint3dArray arptArcCor; //存储边线弧形中点
|
||
AcGePoint3dArray arptArcCenter; //存储边线弧形圆心
|
||
AcGeVector3dArray arvtArcNormal; //存储边线弧形平面法向量
|
||
|
||
AcGeVector3d vtGNormalTmp = vtGEnd.crossProduct(vtGStart); //弯头剖面法向量
|
||
vtGNormalTmp.normalize();
|
||
|
||
AcGePoint3d ptTemp[5];
|
||
|
||
//边线头端生成
|
||
ptTemp[0] = ptStartArc + vtGStart * (dStaWidth / 2) + vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[1] = ptStartArc + vtGStart * (dStaWidth / 2) - vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[2] = ptStartArc - vtGStart * (dStaWidth / 2) - vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[3] = ptStartArc - vtGStart * (dStaWidth / 2) + vtGNormalTmp * (dStartThick / 2);
|
||
for(int i = 0; i < 4; i++)
|
||
{
|
||
arptArcHead.append(ptTemp[i]);
|
||
}
|
||
|
||
//边线中段生成
|
||
ptTemp[0] = ptOnArc + vtCor * ((dStaWidth + dEndWidth) / 4) + vtGNormalTmp * ((dStartThick + dEndThick) / 4);
|
||
ptTemp[1] = ptOnArc + vtCor * ((dStaWidth + dEndWidth) / 4) - vtGNormalTmp * ((dStartThick + dEndThick) / 4);
|
||
ptTemp[2] = ptOnArc - vtCor * ((dStaWidth + dEndWidth) / 4) - vtGNormalTmp * ((dStartThick + dEndThick) / 4);
|
||
ptTemp[3] = ptOnArc - vtCor * ((dStaWidth + dEndWidth) / 4) + vtGNormalTmp * ((dStartThick + dEndThick) / 4);
|
||
|
||
for(int l = 0; l < 4; l++)
|
||
{
|
||
arptArcCor.append(ptTemp[l]);
|
||
}
|
||
|
||
//边线尾端生成
|
||
ptTemp[0] = ptEndArc + vtGEnd * (dEndWidth / 2) + vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[1] = ptEndArc + vtGEnd * (dEndWidth / 2) - vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[2] = ptEndArc - vtGEnd * (dEndWidth / 2) - vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[3] = ptEndArc - vtGEnd * (dEndWidth / 2) + vtGNormalTmp * (dEndThick / 2);
|
||
|
||
for(int m = 0; m < 4; m++)
|
||
{
|
||
arptArcTail.append(ptTemp[m]);
|
||
}
|
||
|
||
//边线弧形圆心和平面法向量生成
|
||
for(int n = 0; n < 4; n++)
|
||
{
|
||
AcGeCircArc3d arcTemp(arptArcHead.at(n), arptArcCor.at(n), arptArcTail.at(n));
|
||
arptArcCenter.append(arcTemp.center());
|
||
arvtArcNormal.append(arcTemp.normal());
|
||
}
|
||
|
||
//弯头头部生成
|
||
ptTemp[0] = ptStart + vtGStart * (dStaWidth / 2) + vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[1] = ptStart + vtGStart * (dStaWidth / 2) - vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[2] = ptStart - vtGStart * (dStaWidth / 2) - vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[3] = ptStart - vtGStart * (dStaWidth / 2) + vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[4] = ptStart + vtGStart * (dStaWidth / 2) + vtGNormalTmp * (dStartThick / 2);
|
||
|
||
for(int k = 0; k < 5; k++)
|
||
{
|
||
arptKey.append(ptTemp[k]);
|
||
}
|
||
|
||
ptTemp[0] = ptStartArc + vtGStart * (dStaWidth / 2) + vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[1] = ptStartArc + vtGStart * (dStaWidth / 2) - vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[2] = ptStartArc - vtGStart * (dStaWidth / 2) - vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[3] = ptStartArc - vtGStart * (dStaWidth / 2) + vtGNormalTmp * (dStartThick / 2);
|
||
ptTemp[4] = ptStartArc + vtGStart * (dStaWidth / 2) + vtGNormalTmp * (dStartThick / 2);
|
||
for(int c = 0; c < 5; c++)
|
||
{
|
||
arptKey.append(ptTemp[c]);
|
||
}
|
||
|
||
//弯头弧线段生成
|
||
for(int d = 1; d < nRows; d++)
|
||
{
|
||
for(int j = 0; j < 5; j++)
|
||
{
|
||
AcGePoint3d ptHeadTemp = arptArcHead.at(j%4);
|
||
AcGePoint3d ptTailTmp = arptArcTail.at(j%4);
|
||
AcGeVector3d vtNormalTemp = arvtArcNormal.at(j%4);
|
||
AcGePoint3d ptCenterTemp = arptArcCenter.at(j%4);
|
||
AcGeVector3d vtTest = ptTailTmp - ptCenterTemp;
|
||
AcGeVector3d vtStandard = ptHeadTemp - ptCenterTemp;
|
||
double dAngleTest = vtStandard.angleTo(vtTest, vtNormalTemp);
|
||
double dRoAngle = dMinDiffAng * d;
|
||
ptTemp[j] = ptHeadTemp.rotateBy(dRoAngle, vtNormalTemp, ptCenterTemp);
|
||
if(fabs(dRoAngle/dAngleTest - 1) < 1e-10 || dRoAngle > dAngleTest)
|
||
ptTemp[j] = ptTailTmp;
|
||
arptKey.append(ptTemp[j]);
|
||
}
|
||
}
|
||
|
||
//弯头尾部生成
|
||
ptTemp[0] = ptEndArc + vtGEnd * (dEndWidth / 2) + vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[1] = ptEndArc + vtGEnd * (dEndWidth / 2) - vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[2] = ptEndArc - vtGEnd * (dEndWidth / 2) - vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[3] = ptEndArc - vtGEnd * (dEndWidth / 2) + vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[4] = ptEndArc + vtGEnd * (dEndWidth / 2) + vtGNormalTmp * (dEndThick / 2);
|
||
|
||
for(int b = 0; b < 5; b++)
|
||
{
|
||
arptKey.append(ptTemp[b]);
|
||
}
|
||
|
||
ptTemp[0] = ptEnd + vtGEnd * (dEndWidth / 2) + vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[1] = ptEnd + vtGEnd * (dEndWidth / 2) - vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[2] = ptEnd - vtGEnd * (dEndWidth / 2) - vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[3] = ptEnd - vtGEnd * (dEndWidth / 2) + vtGNormalTmp * (dEndThick / 2);
|
||
ptTemp[4] = ptEnd + vtGEnd * (dEndWidth / 2) + vtGNormalTmp * (dEndThick / 2);
|
||
|
||
for(int a = 0; a < 5; a++)
|
||
{
|
||
arptKey.append(ptTemp[a]);
|
||
}
|
||
|
||
//添加关键点进行绘图
|
||
DrawMesh(mode, nRows + 3, 5, arptKey.asArrayPtr());
|
||
//======================================================================================
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeAllArcuate2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
if (IsHorzAlignment())
|
||
{
|
||
DrawAllArcuate2DHor(cplCurve,nType);
|
||
}
|
||
else if(IsVertAlignment())
|
||
{
|
||
DrawAllArcuate2DVer(cplCurve,nType);
|
||
}
|
||
else if (IsInclineAlignment())
|
||
{
|
||
DrawAllArcuate2DInc(cplCurve,nType);
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
// 绘制倾斜弯头2D线Lixl
|
||
BOOL ImpHvacElbow::DrawAllArcuate2DInc(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
double dDiameter = MayAsMUnit(300),dStartWidth = MayAsMUnit(300),dEndWidth = MayAsMUnit(100),dPlusEdge = MayAsMUnit(50.0);
|
||
int nWrapType = 1;
|
||
int nSectType = 2;
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
m_pXDataMap->GetAt(HVAC_SectType,nSectType);
|
||
m_pXDataMap->GetAt(HELB_Diameter,dDiameter);
|
||
m_pXDataMap->GetAt(HELB_StartWidth,dStartWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth,dEndWidth);
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HELB_Type,nWrapType);
|
||
|
||
double dMaxWidth = dStartWidth > dEndWidth ? dStartWidth : dEndWidth;
|
||
if ((ptStart.distanceTo(ptCorner) - dPlusEdge) - dMaxWidth / 2 < -1e-6)
|
||
dPlusEdge = 0.1;
|
||
|
||
switch(nSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
{
|
||
ptCorner.z = ptEnd.z = ptStart.z;
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
return GetAllArcuateCplCurveHor(cplCurve,nType,ptStart,
|
||
ptCorner,ptEnd,dPlusEdge,dStartWidth,dEndWidth,nWrapType);
|
||
break;
|
||
}
|
||
case eCircle: // 圆形
|
||
{
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
return GetAllArcuateCplCurveInc(cplCurve,nType,ptStart,
|
||
ptCorner,ptEnd,dPlusEdge,dStartWidth,dEndWidth,nWrapType);
|
||
break;
|
||
}
|
||
case eOblate: // 扁圆形
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL ImpHvacElbow::DrawAllArcuate2DHor(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
double dThick = MayAsMUnit(100.0),dDiameter = MayAsMUnit(300),dStartWidth = MayAsMUnit(300),dEndWidth = MayAsMUnit(100),dPlusEdge = MayAsMUnit(50.0);
|
||
int nWrapType = 1;
|
||
int nSectType = 2;
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine = 1;
|
||
int nSingleLine = 0;
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
m_pXDataMap->GetAt(HVAC_SectType,nSectType);
|
||
m_pXDataMap->GetAt(HELB_Diameter,dDiameter);
|
||
m_pXDataMap->GetAt(HELB_StartWidth,dStartWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth,dEndWidth);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge,dPlusEdge);
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine,nSingleLine);
|
||
//得到弯头类型，如果是内外消声弯头将多绘制两条弧线
|
||
m_pXDataMap->GetAt(HELB_Type,nWrapType);
|
||
|
||
ptCorner.z = ptEnd.z = ptStart.z;
|
||
|
||
double dMaxWidth = dStartWidth > dEndWidth ? dStartWidth : dEndWidth;
|
||
|
||
if ((ptStart.distanceTo(ptCorner) - MayAsMUnit(50.0)) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
switch(nSectType)
|
||
{
|
||
case eRect:// 矩形
|
||
{
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
return GetAllArcuateCplCurveHor(cplCurve,nType,ptStart,ptCorner,ptEnd,dPlusEdge,dStartWidth,dEndWidth,nWrapType);
|
||
break;
|
||
}
|
||
case eCircle:// 圆形
|
||
{
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
return GetAllArcuateCplCurveHor(cplCurve,nType,ptStart,ptCorner,ptEnd,dPlusEdge,dStartWidth,dEndWidth,nWrapType);
|
||
break;
|
||
}
|
||
case eOblate: // 扁圆形
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
//2d立管
|
||
BOOL ImpHvacElbow::DrawAllArcuate2DVer(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
double dThick = MayAsMUnit(100.0),dDiameter = MayAsMUnit(300),dStartWidth = MayAsMUnit(300),dEndWidth = MayAsMUnit(100),dPlusEdge = MayAsMUnit(50.0);
|
||
int nSectType = 2;
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine = 1;
|
||
int nSingleLine = 0;
|
||
AcGePoint3d ptStart, ptCorner, ptEnd, ptCornerAssist;
|
||
m_pXDataMap->GetAt(HVAC_SectType,nSectType);
|
||
m_pXDataMap->GetAt(HELB_Diameter, dDiameter);
|
||
m_pXDataMap->GetAt(HELB_Thick, dThick);
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth, dEndWidth);
|
||
////m_pXDataMap->GetAt(HVAC_PlusEdge,dPlusEdge);
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
if (!m_pXDataMap->GetAt(HELB_AssisCornerPoint, ptCornerAssist))
|
||
{
|
||
ptCornerAssist = ptCorner;
|
||
}
|
||
|
||
bool bIsCenterOffset = false;
|
||
if (ptCorner.distanceTo(ptCornerAssist) < 1e-3)
|
||
{
|
||
bIsCenterOffset = false;
|
||
}
|
||
else
|
||
{
|
||
bIsCenterOffset = true;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine,nSingleLine);
|
||
|
||
double dDiameterEnd = MayAsMUnit(300);
|
||
if (!m_pXDataMap->GetAt(HELB_EndDiameter, dDiameterEnd))
|
||
{
|
||
dDiameterEnd = dDiameter;
|
||
}
|
||
|
||
double dEndThick = dThick;
|
||
m_pXDataMap->GetAt(HELB_EndThick, dEndThick);
|
||
|
||
int nWrapType = 0;
|
||
m_pXDataMap->GetAt(HELB_Type,nWrapType);
|
||
double dWrap = MayAsMUnit(50);
|
||
|
||
switch(nSectType)
|
||
{
|
||
case eRect:// 矩形
|
||
{
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
dThick *= 0.5;
|
||
dEndThick *= 0.5;
|
||
|
||
if (bIsCenterOffset)
|
||
{
|
||
return GetAllArcuateCplCurveVerRecForOffset(cplCurve, nType);
|
||
}
|
||
else
|
||
{
|
||
return GetAllArcuateCplCurveVerRec(cplCurve,nType,ptStart,ptCorner,ptEnd,dPlusEdge,dStartWidth,dEndWidth,dThick, dEndThick);
|
||
}
|
||
break;
|
||
}
|
||
case eCircle:// 圆形
|
||
{
|
||
dDiameter *= 0.5;
|
||
|
||
dDiameterEnd *= 0.5;
|
||
return GetAllArcuateCplCurveVerCir(cplCurve,nType,ptStart,ptCorner,ptEnd,dPlusEdge,dDiameter,dDiameterEnd);
|
||
|
||
break;
|
||
}
|
||
case eOblate: // 扁圆形
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
double ImpHvacElbow::GetEdgeLineWidth() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dWidth(0.0);
|
||
m_pXDataMap->GetAt(HVAC_EdgeWidth, dWidth);
|
||
|
||
return dWidth;
|
||
}
|
||
|
||
double ImpHvacElbow::GetCentLineWidth() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dWidth(0.0);
|
||
m_pXDataMap->GetAt(HVAC_CentWidth, dWidth);
|
||
|
||
return dWidth;
|
||
}
|
||
|
||
double ImpHvacElbow::GetEndLineWidth() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dWidth(0.0);
|
||
m_pXDataMap->GetAt(HVAC_EndWidth, dWidth);
|
||
|
||
return dWidth;
|
||
}
|
||
|
||
int GetEllipseFromCircle( AcGePoint3d ptCenter, double dDia, AcGeVector3d vtOrigNormal,
|
||
AcGeVector3d vtNewNormal, AcDbPolyline &polyLine, AcGeVector3d vtGet)
|
||
{
|
||
vtOrigNormal.normalize();
|
||
vtNewNormal.normalize();
|
||
|
||
double dRadius = dDia * 0.5;
|
||
AcGePlane planStd; // 椭圆投影所在标准面
|
||
planStd.set(ptCenter, vtNewNormal);
|
||
AcGePoint3d ptPrj = AcGePoint3d::kOrigin.orthoProject(planStd);
|
||
planStd.set(ptPrj, vtNewNormal);
|
||
double dEle = ptPrj.asVector().length();
|
||
if (!ptPrj.asVector().isCodirectionalTo(planStd.normal()))
|
||
{
|
||
dEle *= -1.0;
|
||
}
|
||
if (vtNewNormal.isParallelTo(vtOrigNormal)) // 平行,还是圆
|
||
{
|
||
AcGePoint3d ptStart, ptEnd;
|
||
if (vtGet.length() < 1e-6) // 整个圆
|
||
{
|
||
AcGeVector3d vtPerl = vtOrigNormal.perpVector();
|
||
|
||
ptStart = ptCenter + dRadius * vtPerl;
|
||
ptEnd = ptCenter - dRadius * vtPerl;
|
||
polyLine.addVertexAt(0, ptStart.convert2d(planStd), 1.0);
|
||
polyLine.addVertexAt(1, ptEnd.convert2d(planStd), 1.0);
|
||
polyLine.setClosed(Adesk::kTrue);
|
||
}
|
||
else // 半个圆
|
||
{
|
||
AcGeVector3d vtPerl = vtGet.orthoProject(vtNewNormal);
|
||
vtPerl.rotateBy(-PI / 2, vtNewNormal);
|
||
vtPerl.normalize();
|
||
|
||
ptStart = ptCenter + dRadius * vtPerl;
|
||
ptEnd = ptCenter - dRadius * vtPerl;
|
||
polyLine.addVertexAt(0, ptStart.convert2d(planStd), 1);
|
||
polyLine.addVertexAt(1, ptEnd.convert2d(planStd), 0);
|
||
}
|
||
|
||
polyLine.setElevation(dEle);
|
||
polyLine.setNormal(vtNewNormal);
|
||
return 0;
|
||
}
|
||
else if (vtNewNormal.isPerpendicularTo(vtOrigNormal)) // 垂直情况， 为直线
|
||
{
|
||
AcGeVector3d vtCrossPerl = vtOrigNormal.crossProduct(vtNewNormal);
|
||
AcGePoint3d ptStart, ptEnd;
|
||
ptStart = ptCenter + dRadius * vtCrossPerl;
|
||
ptEnd = ptCenter - dRadius * vtCrossPerl;
|
||
polyLine.addVertexAt(0, ptStart.convert2d(planStd));
|
||
polyLine.addVertexAt(1, ptEnd.convert2d(planStd));
|
||
polyLine.setElevation(dEle);
|
||
polyLine.setNormal(vtNewNormal);
|
||
return 1;
|
||
}
|
||
else // 普通投影为椭圆情况
|
||
{
|
||
// 长/短轴向量
|
||
AcGeVector3d vtLong = vtOrigNormal.crossProduct(vtNewNormal);
|
||
vtLong.normalize();
|
||
AcGeVector3d vtShort = vtLong;
|
||
vtShort.rotateBy(PI * 0.5, vtOrigNormal);
|
||
|
||
AcGeVector3d vtPerp = vtOrigNormal.crossProduct(vtNewNormal);
|
||
vtPerp.normalize();
|
||
double dMinAngle = GetMinDiffAngle();
|
||
// dMinAngle *= 0.5;
|
||
int nPart = (int)(PI / dMinAngle) +1;
|
||
dMinAngle = PI / nPart;
|
||
|
||
AcGePoint3d ptNow;
|
||
AcGePoint3dArray arptsEdge;
|
||
if (vtGet.length() < 1e-6)
|
||
{
|
||
ptNow = ptCenter + vtPerp * dDia * 0.5;
|
||
for(int i = 0; i <= nPart*2; i++)
|
||
{
|
||
polyLine.addVertexAt(i, ptNow.convert2d(planStd));
|
||
ptNow.rotateBy(dMinAngle, vtOrigNormal, ptCenter);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
vtGet = vtGet.orthoProject(vtNewNormal);
|
||
if (vtGet.angleTo(vtShort) < PI*0.5) // C 端部分
|
||
{
|
||
ptNow = ptCenter + vtPerp * dDia * 0.5;
|
||
for(int i = 0; i <= nPart; i++)
|
||
{
|
||
polyLine.addVertexAt(i, ptNow.convert2d(planStd));
|
||
ptNow.rotateBy(dMinAngle, vtOrigNormal, ptCenter);
|
||
}
|
||
}
|
||
else // D 端部分
|
||
{
|
||
ptNow = ptCenter - vtPerp * dDia * 0.5;
|
||
for(int i = 0; i <= nPart; i++)
|
||
{
|
||
polyLine.addVertexAt(i, ptNow.convert2d(planStd));
|
||
ptNow.rotateBy(dMinAngle, vtOrigNormal, ptCenter);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
polyLine.setElevation(dEle);
|
||
polyLine.setNormal(vtNewNormal);
|
||
return 2;
|
||
}
|
||
|
||
void GetArcPoint(AcDbPolyline &polyLine, AcGePoint3dArray &ptArcArr)
|
||
{
|
||
double dBugle(0.0);
|
||
polyLine.getBulgeAt(0, dBugle);
|
||
if (EQUAL_ZERO(dBugle - 1.0))// Polyline线是半个圆,或者圆
|
||
{
|
||
double dPar1, dPar2;
|
||
AcGePoint3d pt0, pt1, pt2, pt3, ptMid;
|
||
|
||
polyLine.getPointAt(0, pt0);
|
||
polyLine.getPointAt(1, pt1);
|
||
polyLine.getPointAt(2, pt2);
|
||
polyLine.getPointAt(3, pt3);
|
||
|
||
polyLine.getParamAtPoint(pt0, dPar1);
|
||
polyLine.getParamAtPoint(pt1, dPar2);
|
||
polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
|
||
ptArcArr.append(pt0);
|
||
ptArcArr.append(ptMid);
|
||
ptArcArr.append(pt1);
|
||
|
||
polyLine.getParamAtPoint(pt1, dPar1);
|
||
polyLine.getParamAtPoint(pt2, dPar2);
|
||
polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
|
||
ptArcArr.append(ptMid);
|
||
ptArcArr.append(pt2);
|
||
|
||
polyLine.getParamAtPoint(pt2, dPar1);
|
||
polyLine.getParamAtPoint(pt3, dPar2);
|
||
polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
|
||
ptArcArr.append(ptMid);
|
||
ptArcArr.append(pt3);
|
||
|
||
if (polyLine.isClosed())
|
||
{
|
||
polyLine.getParamAtPoint(pt3, dPar1);
|
||
polyLine.getEndParam(dPar2);
|
||
polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
|
||
ptArcArr.append(ptMid);
|
||
ptArcArr.append(pt0);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
AcGePoint3d pt1;
|
||
for(int i = 0; i < polyLine.numVerts(); i++)
|
||
{
|
||
polyLine.getPointAt(i, pt1);
|
||
ptArcArr.append(pt1);
|
||
}
|
||
}
|
||
}
|
||
|
||
int GetEllipsePtsFromCircle(AcGePoint3dArray& arPtsOnCurve, AcGePoint3d ptCenter, double dDia, AcGeVector3d vtOrigNormal,
|
||
AcGeVector3d vtNewNormal, AcDbPolyline &polyLine, AcGeVector3d vtGet/* = AcGeVector3d::kIdentity*/)
|
||
{
|
||
int iRes = GetEllipseFromCircle(ptCenter, dDia, vtOrigNormal, vtNewNormal, polyLine, vtGet);
|
||
if (iRes != -1)
|
||
{
|
||
AcGePoint3d ptTemp, ptTemp1, ptTemp2;
|
||
double dPam1, dPam2;
|
||
AcGeVector3d vtDir;
|
||
AcGePlane plan;
|
||
switch (iRes)
|
||
{
|
||
default:
|
||
case 2:// 投影为椭圆
|
||
GetArcPoint(polyLine, arPtsOnCurve);
|
||
break;
|
||
case 1:// 投影为直线
|
||
polyLine.getPointAt(0, ptTemp);
|
||
arPtsOnCurve.append(ptTemp);
|
||
polyLine.getPointAt(1, ptTemp);
|
||
arPtsOnCurve.append(ptTemp);
|
||
arPtsOnCurve.append(ptTemp);
|
||
break;
|
||
case 0:// 投影为圆
|
||
if (polyLine.isClosed())// 整个圆
|
||
{
|
||
polyLine.getPointAt(0, ptTemp1);
|
||
polyLine.getPointAt(1, ptTemp2);
|
||
polyLine.getParamAtPoint(ptTemp1, dPam1);
|
||
polyLine.getParamAtPoint(ptTemp2, dPam2);
|
||
polyLine.getPointAtParam((dPam1+dPam2)*0.5, ptTemp);
|
||
arPtsOnCurve.append(ptTemp1);
|
||
arPtsOnCurve.append(ptTemp);
|
||
arPtsOnCurve.append(ptTemp2);
|
||
|
||
vtDir = ptTemp1 - ptTemp2;
|
||
plan.set(MidPoint(ptTemp1, ptTemp2), vtDir.rotateBy(PI * 0.5, vtNewNormal));
|
||
ptTemp.mirror(plan);
|
||
arPtsOnCurve.append(ptTemp);
|
||
arPtsOnCurve.append(ptTemp1);
|
||
}
|
||
else// 半个圆
|
||
{
|
||
polyLine.getPointAt(0, ptTemp1);
|
||
polyLine.getPointAt(1, ptTemp2);
|
||
polyLine.getParamAtPoint(ptTemp1, dPam1);
|
||
polyLine.getParamAtPoint(ptTemp2, dPam2);
|
||
polyLine.getPointAtParam((dPam1+dPam2)*0.5, ptTemp);
|
||
arPtsOnCurve.append(ptTemp1);
|
||
arPtsOnCurve.append(ptTemp);
|
||
arPtsOnCurve.append(ptTemp2);
|
||
}
|
||
|
||
break;
|
||
}
|
||
}
|
||
return iRes;
|
||
}
|
||
|
||
// Lixl 得到圆形截面的弯头两个外轮廓线上的点
|
||
BOOL ImpHvacElbow::GetPrjPts(AcGePoint3dArray &arPtsU, AcGePoint3dArray &arPtsD) const
|
||
{
|
||
// 每个分节面的圆上取三个点,放在此数组,用于确定分节圆,之后向平面投影得到投影点
|
||
AcGePoint3dArray arPtsOnCir;
|
||
double dDiameter = MayAsMUnit(300.0);
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
double dStaWidth = MayAsMUnit(150.0);
|
||
double dEndWidth = MayAsMUnit(150.0);
|
||
int nSectType = 2;
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_SectType,nSectType);
|
||
m_pXDataMap->GetAt(HELB_Diameter,dStaWidth);
|
||
if (!m_pXDataMap->GetAt(HELB_EndDiameter, dEndWidth))
|
||
dEndWidth = dStaWidth;
|
||
|
||
double dMaxWidth = dStaWidth > dEndWidth ? dStaWidth : dEndWidth;
|
||
if ((ptStart.distanceTo(ptCorner) - 50.0) - dMaxWidth / 2 < -1e-6)
|
||
dPlusEdge = 0.1;
|
||
|
||
int nWrapType = 0;
|
||
m_pXDataMap->GetAt(HELB_Type,nWrapType);
|
||
double dWrap = MayAsMUnit(50);
|
||
if (2 == nWrapType)
|
||
{
|
||
if (dDiameter <= MayAsMUnit(100))
|
||
dWrap = dDiameter * 0.1;
|
||
dDiameter += dWrap * 2;
|
||
}
|
||
|
||
//以拐点为参照的矢量
|
||
AcGeVector3d vtStart = ptStart - ptCorner;
|
||
AcGeVector3d vtEnd = ptEnd - ptCorner;
|
||
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
|
||
//求得中心线起点和终点
|
||
double dRadius = ptCorner.distanceTo(ptStart) -dPlusEdge;
|
||
AcGePoint3d ptStartArc = ptCorner + vtStart * dRadius;
|
||
AcGePoint3d ptEndArc = ptCorner + vtEnd * dRadius;
|
||
|
||
//求得平面法向量和中心线圆心
|
||
AcGeVector3d vtGNormal = this->normal();
|
||
vtGNormal.normalize();
|
||
|
||
AcGePoint3d ptGeCen;
|
||
AcGeVector3d vtStartTmp = vtStart;
|
||
AcGeVector3d vtEndTmp = vtEnd;
|
||
vtStartTmp.rotateBy(PI * 0.5,vtGNormal);
|
||
vtEndTmp.rotateBy(PI * 0.5,vtGNormal);
|
||
AcGeLine3d lineStart(ptStartArc, vtStartTmp);
|
||
AcGeLine3d lineEnd(ptEndArc, vtEndTmp);
|
||
Adesk::Boolean bRet = lineStart.intersectWith(lineEnd, ptGeCen);
|
||
if(!bRet) // 中心线圆心计算失败
|
||
return FALSE;
|
||
|
||
//求得中心线圆弧半径
|
||
dRadius = ptGeCen.distanceTo(ptStartArc);
|
||
|
||
//以中心线圆心为参照的矢量
|
||
AcGeVector3d vtGStart = ptStartArc - ptGeCen;
|
||
AcGeVector3d vtGEnd = ptEndArc - ptGeCen;
|
||
vtGStart.normalize();
|
||
vtGEnd.normalize();
|
||
AcDbCircle entCircle(ptGeCen, vtGNormal, dRadius);
|
||
|
||
//弯头的角度
|
||
double dAngle = vtGStart.angleTo(vtGEnd);
|
||
|
||
//最小分角
|
||
double dMinDiffAng = GetMinDiffAngle();
|
||
dMinDiffAng *= 0.5;
|
||
//弧形截面数,如果设置的虾米节数量,使用虾米节数量
|
||
int nRows = int(dAngle / dMinDiffAng);
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
if (AecHvac::eSegmental == eElbowType)
|
||
m_pXDataMap->GetAt(HELB_Segments, nRows);
|
||
dMinDiffAng = dAngle / nRows;
|
||
|
||
//各截面中的关键点数
|
||
int nColumns = int(2 * PI / dMinDiffAng);
|
||
|
||
//关键节点数组
|
||
AcGePoint3dArray arptKey;
|
||
|
||
//直线段（开始处前端）
|
||
AcGePoint3d pt = ptStart + vtGStart * dStaWidth / 2;
|
||
|
||
int i = 0;
|
||
for(i = 0; i < nColumns; i++)
|
||
{
|
||
arptKey.append(pt);
|
||
pt.rotateBy(dMinDiffAng, vtStart, ptStart);
|
||
}
|
||
pt = ptStart + vtGStart * dStaWidth / 2;
|
||
arptKey.append(pt);
|
||
|
||
//弧线段
|
||
AcDbEllipse entEll;
|
||
AcGePoint3d ptTemp;
|
||
AcGeVector3d vtRLong;
|
||
double dRLong = 0.0;
|
||
double dRShort = 0.0;
|
||
double dRatio = 0.0;
|
||
if(fabs(dAngle - PI/2) < 1e-6)
|
||
{
|
||
dRLong = dRadius + (dStaWidth > dEndWidth ? dStaWidth : dEndWidth) / 2;
|
||
dRShort = dRadius + (dStaWidth < dEndWidth ? dStaWidth : dEndWidth) / 2;
|
||
dRatio = dRShort / dRLong;
|
||
vtRLong = (dStaWidth > dEndWidth ? vtGStart * dRLong : vtGEnd * dRLong);
|
||
}
|
||
else
|
||
{
|
||
double dA = 0.0;
|
||
double dB = 0.0;
|
||
if(dStaWidth >= dEndWidth)
|
||
{
|
||
dA = dRadius + dStaWidth/2;
|
||
dRLong = dA;
|
||
vtRLong = vtGStart * dRLong;
|
||
double dEndToGOri = dRadius + dEndWidth / 2;
|
||
double dXEnd = fabs(dEndToGOri * sin(dAngle));
|
||
double dYEnd = fabs(dEndToGOri * cos(dAngle));
|
||
dB = dA * dXEnd / sqrt(dA * dA - dYEnd * dYEnd);
|
||
dRShort = dB;
|
||
dRatio = dRShort / dRLong;
|
||
}
|
||
else
|
||
{
|
||
dB = dRadius + dStaWidth/2;
|
||
dRShort = dB;
|
||
double dEndToGOri = dRadius + dEndWidth / 2;
|
||
double dXEnd = fabs(dEndToGOri * sin(dAngle));
|
||
double dYEnd = fabs(dEndToGOri * cos(dAngle));
|
||
dA = dB * dXEnd / sqrt(dB * dB - dYEnd * dYEnd);
|
||
dRLong = dA;
|
||
AcGeVector3d vtBuf = vtGStart;
|
||
vtRLong = vtBuf.rotateBy(-PI/2, vtGNormal) * dRLong;
|
||
dRatio = dRShort/dRLong;
|
||
}
|
||
}
|
||
|
||
//构建椭圆轨迹
|
||
entEll.set(ptGeCen, vtGNormal, vtRLong, dRatio);
|
||
|
||
double dStepC = -1.0;
|
||
double dStepE = -1.0;
|
||
|
||
entCircle.getParamAtPoint(ptStartArc, dStepC);
|
||
double dTemp = 0;
|
||
AcGePoint3d ptGArc;
|
||
entCircle.getStartParam(dTemp);
|
||
entCircle.getPointAtParam(dTemp, ptGArc);
|
||
|
||
AcGeVector3d vt = ptGArc - ptGeCen;
|
||
|
||
double dAngleCtoE = vt.angleTo(vtRLong, vtGNormal);
|
||
dStepE = dStepC - dAngleCtoE;
|
||
|
||
int nTemp = nRows;
|
||
AcGeVector3d vtNormal;
|
||
AcGeVector3d vtTest;
|
||
double dRet = 0.0;
|
||
for(; nTemp > 0; dStepC -= dMinDiffAng, dStepE -= dMinDiffAng, nTemp--)
|
||
{
|
||
if(fabs(dStepE - 0) < 1e-6)
|
||
{
|
||
dStepE += 2*PI;
|
||
}
|
||
if(fabs(dStepC - 0) < 1e-6)
|
||
{
|
||
dStepC += 2*PI;
|
||
}
|
||
entEll.getPointAtParam(dStepE, pt);
|
||
entCircle.getPointAtParam(dStepC, ptTemp);
|
||
entCircle.getFirstDeriv(ptTemp, vtNormal);
|
||
|
||
for(int i = 0; i < nColumns; i++)
|
||
{
|
||
arptKey.append(pt);
|
||
pt.rotateBy(dMinDiffAng, vtNormal, ptTemp);
|
||
}
|
||
|
||
entEll.getPointAtParam(dStepE, pt);
|
||
arptKey.append(pt);
|
||
}
|
||
|
||
//直线段（结束处前端和后端）
|
||
pt = ptEndArc + vtGEnd * dEndWidth / 2;
|
||
|
||
for(int m = 0; m < nColumns; m++)
|
||
{
|
||
arptKey.append(pt);
|
||
pt.rotateBy(dMinDiffAng, -vtEnd, ptEnd);
|
||
}
|
||
|
||
pt = ptEndArc + vtGEnd * dEndWidth / 2;
|
||
arptKey.append(pt);
|
||
|
||
pt = ptEnd + vtGEnd * dEndWidth / 2;
|
||
|
||
for(int n = 0; n < nColumns; n++)
|
||
{
|
||
arptKey.append(pt);
|
||
pt.rotateBy(dMinDiffAng, -vtEnd, ptEnd);
|
||
}
|
||
pt = ptEnd + vtGEnd * dEndWidth / 2;
|
||
arptKey.append(pt);
|
||
|
||
nTemp = arptKey.length();
|
||
arPtsOnCir.setLogicalLength(0);
|
||
for (int j = 0; j <= nTemp-3;)
|
||
{
|
||
arPtsOnCir.append(arptKey[j]);
|
||
arPtsOnCir.append(arptKey[j+1]);
|
||
arPtsOnCir.append(arptKey[j+2]);
|
||
j = j + (nColumns + 1);
|
||
}
|
||
|
||
AcGePlane plan(AcGePoint3d::kOrigin, GetUcsZvt());
|
||
|
||
AcGeCircArc3d cir; // 分节圆
|
||
|
||
AcGeVector3d vt1, vt2, vtcirNor;
|
||
AcDbPolyline *pLine = new AcDbPolyline;
|
||
if (NULL == pLine)
|
||
return FALSE;
|
||
int iRes = -1;
|
||
AcGePoint3d ptU, ptD;
|
||
for (i = 0; i < arPtsOnCir.length(); )// 几个圆
|
||
{
|
||
cir.set(arPtsOnCir[i], arPtsOnCir[i+1], arPtsOnCir[i+2]);
|
||
|
||
pt = cir.center();
|
||
|
||
vt1 = arPtsOnCir[i+1] - pt;
|
||
vt2 = arPtsOnCir[i+2] - pt;
|
||
vtcirNor = vt1.crossProduct(vt2); // 分节圆法向
|
||
vtTest = vtcirNor;
|
||
plan.set(pt, GetUcsZvt());
|
||
dTemp = vtcirNor.angleOnPlane(plan);
|
||
if (dTemp < PI)
|
||
vtTest.negate();
|
||
|
||
iRes = GetEllipseFromCircle(pt, cir.radius() * 2, vtcirNor, GetUcsZvt(), *pLine, vtcirNor);
|
||
ptGeCen = ptGeCen.orthoProject(plan);
|
||
if (2 == iRes || iRes == 1 || iRes == 0)
|
||
{
|
||
pLine->getPointAt(0, ptU);
|
||
nTemp = pLine->numVerts();
|
||
pLine->getPointAt(nTemp-1, ptD);
|
||
|
||
if (ptU.distanceTo(ptGeCen) >= ptD.distanceTo(ptGeCen))
|
||
{
|
||
arPtsU.append(ptU);
|
||
arPtsD.append(ptD);
|
||
}
|
||
else
|
||
{
|
||
arPtsU.append(ptD);
|
||
arPtsD.append(ptU);
|
||
}
|
||
pLine->reset(Adesk::kFalse, nTemp);
|
||
i = i+3;// 每3个点确定一个面
|
||
}
|
||
}
|
||
if (NULL != pLine)
|
||
delete pLine;
|
||
|
||
// 当分节面密集的时候,容易错误
|
||
for (i = 0; i < arPtsD.length(); i++)
|
||
{
|
||
arPtsD[i].z = ptCorner.z;
|
||
arPtsU[i].z = ptCorner.z;
|
||
}
|
||
// if (eElbowType != AecHvac::eSegmental)
|
||
// {
|
||
AcGeLineSeg3d line1, line2;
|
||
AcGePoint3d ptInter;
|
||
for(i = 0; i < arPtsD.length()-1; i++)
|
||
{
|
||
// 前面的线段
|
||
line1.set(arPtsD[i], arPtsD[i+1]);
|
||
for (int j = i+1; j < arPtsD.length()-1; j++)
|
||
{
|
||
line2.set(arPtsD[j], arPtsD[j+1]);
|
||
if (Adesk::kTrue == line1.intersectWith(line2, ptInter))
|
||
{
|
||
if (!ptInter.isEqualTo(arPtsD[j]))
|
||
{
|
||
// 前一个线段和后线段相交
|
||
for (int n = i+1; n<=j ; n++)
|
||
{
|
||
arPtsD[n] = ptInter;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// }
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL ImpHvacElbow::GetAllArcuateCplCurveInc(AecComplexCurve& cplCurve,int &nType,AcGePoint3d& ptStart, AcGePoint3d& ptCorner,
|
||
AcGePoint3d& ptEnd,double& dPlusEdge,double& dDiameterS,double& dDiameterE,
|
||
int& nWrapType) const
|
||
{
|
||
if (nType != 0 && nType != 1)
|
||
{
|
||
return FALSE;
|
||
}
|
||
AcGeVector3d vtStr,vtEnd,vtCor,vtNor = AcGeVector3d::kZAxis, vtZAxis, vtX;
|
||
AcGePoint3d ptGeCen,ptStartU,ptStartD,ptCornerU,ptEndU,ptEndD,ptCornerD, ptOrgStart;
|
||
AcGePoint3d ptStartX,ptStartXU,ptStartXD,ptEndX,ptEndXU,ptEndXD,ptCorOnArc;
|
||
AcGePlane stdPlan(ptCorner, GetUcsZvt());
|
||
AcGePoint3dArray arPtsCen, arPtsU, arPtsD;
|
||
ptStartX = ptStart;
|
||
ptEndX = ptEnd;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtNor = vtStr.crossProduct(vtEnd);
|
||
//ptStart，ptEnd都改变了，去掉了直边段
|
||
ptStart = ptStart - vtStr * dPlusEdge;
|
||
ptEnd = ptEnd - vtEnd * dPlusEdge;
|
||
|
||
// 计算弯头截面的弧线(端线)
|
||
AcGePoint3dArray arPtS, arPtE;
|
||
vtZAxis = GetUcsZvt();
|
||
AcDbPolyline *pLine = new AcDbPolyline;
|
||
if (NULL == pLine)
|
||
return FALSE;
|
||
// 方向要从端点指向拐点
|
||
vtStr = - vtStr;
|
||
vtEnd = - vtEnd;
|
||
if (ptStartX.z > ptCorner.z)
|
||
;
|
||
else
|
||
vtStr = -vtStr;
|
||
int iRes = GetEllipsePtsFromCircle(arPtS, ptStartX, dDiameterS * 2, vtStr, vtZAxis, *pLine, vtStr); //Lixl add 2011-11-23
|
||
pLine->reset(Adesk::kFalse, iRes);
|
||
|
||
if (ptEndX.z > ptCorner.z)
|
||
;
|
||
else
|
||
vtEnd = -vtEnd;
|
||
iRes = GetEllipsePtsFromCircle(arPtE, ptEndX, dDiameterE * 2, vtEnd, vtZAxis, *pLine, vtEnd); //Lixl add 2011-11-23
|
||
if (NULL != pLine)
|
||
delete pLine;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
// 计算两外轮廓线的端点
|
||
ptStartX = ptStartX.orthoProject(stdPlan);
|
||
ptEndX = ptEndX.orthoProject(stdPlan);
|
||
vtStr = vtStr.orthoProject(vtZAxis);
|
||
vtEnd = vtEnd.orthoProject(vtZAxis);
|
||
vtStr.rotateBy(PI * 0.5, vtZAxis);
|
||
vtEnd.rotateBy(PI * 0.5, vtZAxis);
|
||
if (!GetIntersectWith(ptStartX, ptEndX, vtStr, vtEnd, ptGeCen))
|
||
return FALSE;
|
||
vtStr = ptStartX - ptGeCen;
|
||
vtEnd = ptEndX - ptGeCen;
|
||
ptStartXU = ptGeCen + vtStr.normalize() * dDiameterS;
|
||
ptStartXD = ptGeCen - vtStr.normalize() * dDiameterS;
|
||
ptEndXU = ptGeCen + vtEnd.normalize() * dDiameterE;
|
||
ptEndXD = ptGeCen - vtEnd.normalize() * dDiameterE;
|
||
|
||
// 计算两条外轮廓线
|
||
if (!GetPrjPts(arPtsU, arPtsD))
|
||
return FALSE;
|
||
|
||
int i = 0;
|
||
for (i = 0; i < arPtsU.length(); i++)
|
||
{
|
||
arPtsU[i] = arPtsU[i].orthoProject(stdPlan);
|
||
arPtsD[i] = arPtsD[i].orthoProject(stdPlan);
|
||
|
||
Midpoint(arPtsU[i], arPtsD[i], ptCorOnArc);
|
||
arPtsCen.append(ptCorOnArc);
|
||
}
|
||
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
//外轮廓
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
AcDbObjectId idEndLayer(NULL),idSideLayer(NULL),idBaseLayer(NULL);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
|
||
|
||
if (IsInclineAlignment())
|
||
nWrapType = AecHvac::eAllArcuate;
|
||
|
||
//消声
|
||
if(AecHvac::eAllArcWrap == nWrapType)
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
AcGePoint3d ptWrapStrU,ptWrapStrD,ptWrapEndU,ptWrapEndD;
|
||
AcGePoint3d ptWrapStrXU,ptWrapStrXD,ptWrapEndXU,ptWrapEndXD;
|
||
AcGePoint3d ptWrapCorU,ptWrapCorD;
|
||
|
||
double dWrap = MayAsMUnit(50);
|
||
|
||
ptWrapStrU = ptStartU + vtStr * dWrap;
|
||
ptWrapStrD = ptStartD - vtStr * dWrap;
|
||
ptWrapStrXU = ptStartXU + vtStr * dWrap;
|
||
ptWrapStrXD = ptStartXD - vtStr * dWrap;
|
||
ptWrapEndU = ptEndU + vtEnd * dWrap;
|
||
ptWrapEndD = ptEndD - vtEnd * dWrap;
|
||
ptWrapEndXU = ptEndXU + vtEnd * dWrap;
|
||
ptWrapEndXD = ptEndXD - vtEnd * dWrap;
|
||
|
||
el.gsMark = 0;
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idEndLayer;
|
||
el.ptGe[0] = ptWrapStrXU;
|
||
el.ptGe[1] = ptWrapStrXD;
|
||
el.ptGe[2] = ptWrapStrXD;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptWrapEndXU;
|
||
el.ptGe[1] = ptWrapEndXD;
|
||
el.ptGe[2] = ptWrapEndXD;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptWrapStrD;
|
||
el.ptGe[1] = ptWrapCorD;
|
||
el.ptGe[2] = ptWrapEndD;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptWrapStrU;
|
||
el.ptGe[1] = ptWrapCorU;
|
||
el.ptGe[2] = ptWrapEndU;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptWrapStrXU;
|
||
el.ptGe[1] = ptWrapStrU;
|
||
el.ptGe[2] = ptWrapStrU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndU;
|
||
el.ptGe[1] = ptWrapEndXU;
|
||
el.ptGe[2] = ptWrapEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapStrXD;
|
||
el.ptGe[1] = ptWrapStrD;
|
||
el.ptGe[2] = ptWrapStrD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndD;
|
||
el.ptGe[1] = ptWrapEndXD;
|
||
el.ptGe[2] = ptWrapEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
if (!IsSingleLine())
|
||
{
|
||
//消声内弧
|
||
el.idSubLay = layerId();
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptStartU;
|
||
el.ptGe[2] = ptStartU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptEndU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptStart;
|
||
el.ptGe[2] = ptStart;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStart;
|
||
el.ptGe[1] = ptCorOnArc;
|
||
el.ptGe[2] = ptEnd;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEnd;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
//内外圆弧
|
||
else
|
||
{
|
||
if (0 == nType)
|
||
{
|
||
el.idSubLay = idSideLayer;
|
||
el.gsMark = 0;
|
||
el.dWidth = dEdgeWidth;
|
||
// 弯头外圆弧曲线
|
||
for (i = 0; i <= arPtsU.length()-2; i++)
|
||
{
|
||
el.ptGe[0] = arPtsU[i];
|
||
el.ptGe[1] = arPtsU[i+1];
|
||
el.ptGe[2] = arPtsU[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
// 弯头内圆弧曲线
|
||
for (i = 0; i <= arPtsD.length()-2; i++)
|
||
{
|
||
el.ptGe[0] = arPtsD[i];
|
||
el.ptGe[1] = arPtsD[i+1];
|
||
el.ptGe[2] = arPtsD[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
// 画端线
|
||
el.idSubLay = idEndLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
|
||
for (i = 0; i < arPtS.length()-1; i++)//Lixl add 2011-11-23
|
||
{
|
||
el.ptGe[0] = arPtS[i];
|
||
el.ptGe[1] = arPtS[i+1];
|
||
el.ptGe[2] = arPtS[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
for (i = 0; i < arPtE.length()-1; i++)//Lixl add 2011-11-23
|
||
{
|
||
el.ptGe[0] = arPtE[i];
|
||
el.ptGe[1] = arPtE[i+1];
|
||
el.ptGe[2] = arPtE[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
//中心线
|
||
else if (1 == nType)
|
||
{
|
||
if (HasBaseLine() || IsSingleLine())
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
|
||
for (i = 0; i <= arPtsCen.length()-2; i++)
|
||
{
|
||
// if (i > 1 && i%2 == 0)
|
||
// {
|
||
el.ptGe[0] = arPtsCen[i];
|
||
el.ptGe[1] = arPtsCen[i+1];
|
||
el.ptGe[2] = arPtsCen[i+1];
|
||
cplCurve.append(el);
|
||
// }
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
/////////////////////////////////////
|
||
// su
|
||
// sxu ─ ──────╮
|
||
// sx ─ ─────╮│
|
||
// sxd ─ ────╮││
|
||
// sd │││
|
||
// │││
|
||
// ed e eu
|
||
// │││
|
||
// exd ex exu
|
||
//////////////////////////////////////
|
||
BOOL ImpHvacElbow::GetAllArcuateCplCurveHor(AecComplexCurve& cplCurve,int &nType,
|
||
AcGePoint3d& ptStart, AcGePoint3d& ptCorner,
|
||
AcGePoint3d& ptEnd,double& dPlusEdge,
|
||
double& dDiameterS,double& dDiameterE,
|
||
int& nWrapType) const
|
||
{
|
||
if (nType != 0 && nType != 1)
|
||
{
|
||
return FALSE;
|
||
}
|
||
AcGeVector3d vtStr,vtEnd,vtCor,vtNor = AcGeVector3d::kZAxis;
|
||
AcGePoint3d ptGeCen,ptStartU,ptStartD,ptCornerU,ptEndU,ptEndD,ptCornerD;
|
||
AcGePoint3d ptStartX,ptStartXU,ptStartXD,ptEndX,ptEndXU,ptEndXD,ptCorOnArc;
|
||
ptStartX = ptStart;
|
||
ptEndX = ptEnd;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtNor = vtStr.crossProduct(vtEnd);
|
||
|
||
//ptStart，ptEnd都改变了，去掉了直边段
|
||
ptStart = ptStart - vtStr * dPlusEdge;
|
||
ptEnd = ptEnd - vtEnd * dPlusEdge;
|
||
|
||
vtStr.rotateBy(PI * 0.5,vtNor);
|
||
vtEnd.rotateBy(PI * 0.5,vtNor);
|
||
|
||
//求出圆心ptGeCen
|
||
if(!GetIntersectWith(ptStart,ptEnd,vtStr,vtEnd,ptGeCen))
|
||
return FALSE;
|
||
|
||
vtStr = ptStart - ptGeCen;
|
||
vtEnd = ptEnd - ptGeCen;
|
||
vtCor = ptCorner - ptGeCen;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtCor.normalize();
|
||
|
||
ptStartU = ptStart + vtStr * dDiameterS;
|
||
ptStartD = ptStart - vtStr * dDiameterS;
|
||
ptEndU = ptEnd + vtEnd * dDiameterE;
|
||
ptEndD = ptEnd - vtEnd * dDiameterE;
|
||
//曲率半径
|
||
double dRadRatio = ptStart.distanceTo(ptGeCen);
|
||
|
||
ptCorOnArc = ptGeCen + vtCor * dRadRatio;
|
||
ptCornerU = ptGeCen + vtCor * (dRadRatio + dDiameterS * 0.5 + dDiameterE * 0.5);
|
||
ptCornerD = ptGeCen + vtCor * (dRadRatio - dDiameterS * 0.5 - dDiameterE * 0.5);
|
||
|
||
//计算直边段的端点
|
||
AcGeVector3d vtStrT = ptStart - ptCorner;
|
||
AcGeVector3d vtEndT = ptEnd - ptCorner;
|
||
vtStrT.normalize();
|
||
vtEndT.normalize();
|
||
ptStartXU = ptStartU + vtStrT * dPlusEdge;
|
||
ptStartXD = ptStartD + vtStrT * dPlusEdge;
|
||
ptEndXU = ptEndU + vtEndT * dPlusEdge;
|
||
ptEndXD = ptEndD + vtEndT * dPlusEdge;
|
||
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
//外轮廓
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
AcDbObjectId idEndLayer(NULL),idSideLayer(NULL),idBaseLayer(NULL);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
|
||
|
||
if(AecHvac::eAllArcWrap == nWrapType)
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
AcGePoint3d ptWrapStrU,ptWrapStrD,ptWrapEndU,ptWrapEndD;
|
||
AcGePoint3d ptWrapStrXU,ptWrapStrXD,ptWrapEndXU,ptWrapEndXD;
|
||
AcGePoint3d ptWrapCorU,ptWrapCorD;
|
||
|
||
double dWrap = MayAsMUnit(50);
|
||
|
||
ptWrapStrU = ptStartU + vtStr * dWrap;
|
||
ptWrapStrD = ptStartD - vtStr * dWrap;
|
||
ptWrapStrXU = ptStartXU + vtStr * dWrap;
|
||
ptWrapStrXD = ptStartXD - vtStr * dWrap;
|
||
ptWrapEndU = ptEndU + vtEnd * dWrap;
|
||
ptWrapEndD = ptEndD - vtEnd * dWrap;
|
||
ptWrapEndXU = ptEndXU + vtEnd * dWrap;
|
||
ptWrapEndXD = ptEndXD - vtEnd * dWrap;
|
||
|
||
ptWrapCorU = ptGeCen + vtCor * (dRadRatio + dDiameterS * 0.5 + dDiameterE * 0.5 + dWrap);
|
||
ptWrapCorD = ptGeCen + vtCor * (dRadRatio - dDiameterS * 0.5 - dDiameterE * 0.5 - dWrap);
|
||
|
||
el.gsMark = 0;
|
||
//el.dWidth = dEdgeWidth;
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idEndLayer;
|
||
el.ptGe[0] = ptWrapStrXU;
|
||
el.ptGe[1] = ptWrapStrXD;
|
||
el.ptGe[2] = ptWrapStrXD;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptWrapEndXU;
|
||
el.ptGe[1] = ptWrapEndXD;
|
||
el.ptGe[2] = ptWrapEndXD;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptWrapStrD;
|
||
el.ptGe[1] = ptWrapCorD;
|
||
el.ptGe[2] = ptWrapEndD;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptWrapStrU;
|
||
el.ptGe[1] = ptWrapCorU;
|
||
el.ptGe[2] = ptWrapEndU;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptWrapStrXU;
|
||
el.ptGe[1] = ptWrapStrU;
|
||
el.ptGe[2] = ptWrapStrU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndU;
|
||
el.ptGe[1] = ptWrapEndXU;
|
||
el.ptGe[2] = ptWrapEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapStrXD;
|
||
el.ptGe[1] = ptWrapStrD;
|
||
el.ptGe[2] = ptWrapStrD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndD;
|
||
el.ptGe[1] = ptWrapEndXD;
|
||
el.ptGe[2] = ptWrapEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
|
||
if (!IsSingleLine())
|
||
{
|
||
//消声内弧
|
||
el.idSubLay = layerId();
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptStartU;
|
||
el.ptGe[2] = ptStartU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptEndU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptStart;
|
||
el.ptGe[2] = ptStart;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStart;
|
||
el.ptGe[1] = ptCorOnArc;
|
||
el.ptGe[2] = ptEnd;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEnd;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
//内外圆弧
|
||
else
|
||
{
|
||
if (0 == nType)
|
||
{
|
||
el.idSubLay = idSideLayer;
|
||
el.gsMark = 0;
|
||
el.dWidth = dEdgeWidth;
|
||
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptStartU;
|
||
el.ptGe[2] = ptStartU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptEndU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
|
||
el.idSubLay = idEndLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptEndXU;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//中心线
|
||
else if (1 == nType)
|
||
{
|
||
if (HasBaseLine() || IsSingleLine())
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptStart;
|
||
el.ptGe[2] = ptStart;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStart;
|
||
el.ptGe[1] = ptCorOnArc;
|
||
el.ptGe[2] = ptEnd;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEnd;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
// 消声弯头
|
||
if(AecHvac::eAllArcInWrap == nWrapType)
|
||
{
|
||
// 计算内衬位置 宽度的1/10
|
||
double dWidth = 0;
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dWidth);
|
||
double dLiningS = dWidth * 0.1;
|
||
m_pXDataMap->GetAt(HELB_EndWidth, dWidth);
|
||
double dLiningE = dWidth * 0.1;
|
||
double dLiningM = (dLiningS + dLiningE) / 2;
|
||
|
||
////////////////////////////////////////
|
||
// 2
|
||
// 1 ─ ──────╮3
|
||
// │
|
||
// 0 ─ ────╮ │
|
||
// 9 8 │ │
|
||
// │ │
|
||
// 7 4
|
||
// │ │
|
||
// 6 5
|
||
////////////////////////////////////////
|
||
|
||
// 计算关键点
|
||
AcGePoint3d ptL1 = ptStartXU - vtStr * dLiningS;
|
||
AcGePoint3d ptL2 = ptStartU - vtStr * dLiningS;
|
||
AcGePoint3d ptL3 = ptCornerU - vtCor * dLiningM;
|
||
AcGePoint3d ptL4 = ptEndU - vtEnd * dLiningE;
|
||
AcGePoint3d ptL5 = ptEndXU - vtEnd * dLiningE;
|
||
AcGePoint3d ptL6 = ptEndXD + vtEnd * dLiningE;
|
||
AcGePoint3d ptL7 = ptEndD + vtEnd * dLiningE;
|
||
AcGePoint3d ptL8 = ptCornerD + vtCor * dLiningM;
|
||
AcGePoint3d ptL9 = ptStartD + vtStr * dLiningS;
|
||
AcGePoint3d ptL0 = ptStartXD + vtStr * dLiningS;
|
||
|
||
el.idSubLay = idEndLayer;
|
||
el.idSubLty = KTSetting::InitLineStyle(_T("DASHED"));
|
||
|
||
el.ptGe[0] = ptL1;
|
||
el.ptGe[1] = ptL2;
|
||
el.ptGe[2] = ptL2;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptL2;
|
||
el.ptGe[1] = ptL3;
|
||
el.ptGe[2] = ptL4;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptL4;
|
||
el.ptGe[1] = ptL5;
|
||
el.ptGe[2] = ptL5;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptL0;
|
||
el.ptGe[1] = ptL9;
|
||
el.ptGe[2] = ptL9;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptL9;
|
||
el.ptGe[1] = ptL8;
|
||
el.ptGe[2] = ptL7;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptL7;
|
||
el.ptGe[1] = ptL6;
|
||
el.ptGe[2] = ptL6;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
////////////////////////////////////
|
||
// su
|
||
// sxu ─ ──────╮
|
||
// sx ─ ─────╮│
|
||
// sxd ─ ────╮││
|
||
// sd │││
|
||
// │││
|
||
// ed e eu
|
||
// │││
|
||
// exd ex exu
|
||
////////////////////////////////////
|
||
BOOL ImpHvacElbow::GetPtsSegmentalHor(AcGePoint3dArray& pts) const
|
||
{
|
||
double dDiameter = MayAsMUnit(300),dPlusEdge = MayAsMUnit(50.0);
|
||
int nSectType = 2;
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine = 1;
|
||
int nSingleLine = 0;
|
||
int nSegments = 5;
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
|
||
//BEGIN======================================================
|
||
double dDiameterStart = MayAsMUnit(400.0);
|
||
double dDiameterEnd = MayAsMUnit(400.0);
|
||
|
||
m_pXDataMap->GetAt(HELB_Segments, nSegments);
|
||
m_pXDataMap->GetAt(HVAC_SectType,nSectType);
|
||
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dDiameterStart);
|
||
if (!m_pXDataMap->GetAt(HELB_EndWidth, dDiameterEnd))
|
||
{
|
||
dDiameterEnd = dDiameterStart;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine,nSingleLine);
|
||
//dPlusEdge = 50.0;
|
||
if (nSegments < 2)
|
||
nSegments = 2;
|
||
//dDiameter *= 0.5;
|
||
|
||
double dMaxWidth = dDiameterStart > dDiameterEnd ? dDiameterStart : dDiameterEnd;
|
||
if ((ptStart.distanceTo(ptCorner) - MayAsMUnit(50.0)) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
dDiameterStart *= 0.5;
|
||
dDiameterEnd *= 0.5;
|
||
|
||
AcGeVector3d vtStr,vtEnd,vtCor,vtNor = AcGeVector3d::kZAxis;
|
||
AcGePoint3d ptGeCen,ptStartU,ptStartD,ptCornerU,ptEndU,ptEndD,ptCornerD;
|
||
AcGePoint3d ptStartX,ptStartXU,ptStartXD,ptEndX,ptEndXU,ptEndXD,ptCorOnArc;
|
||
ptStartX = ptStart;
|
||
ptEndX = ptEnd;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtNor = vtStr.crossProduct(vtEnd);
|
||
|
||
//ptStart，ptEnd都改变了，去掉了直边段
|
||
ptStart = ptStart - vtStr * dPlusEdge;
|
||
ptEnd = ptEnd - vtEnd * dPlusEdge;
|
||
|
||
vtStr.rotateBy(PI * 0.5,vtNor);
|
||
vtEnd.rotateBy(PI * 0.5,vtNor);
|
||
|
||
//求出圆心ptGeCen
|
||
if(!GetIntersectWith(ptStart,ptEnd,vtStr,vtEnd,ptGeCen))
|
||
return FALSE;
|
||
|
||
vtStr = ptStart - ptGeCen;
|
||
vtEnd = ptEnd - ptGeCen;
|
||
vtCor = ptCorner - ptGeCen;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtCor.normalize();
|
||
|
||
ptStartU = ptStart + vtStr * dDiameterStart;
|
||
ptStartD = ptStart - vtStr * dDiameterStart;
|
||
ptEndU = ptEnd + vtEnd * dDiameterEnd;
|
||
ptEndD = ptEnd - vtEnd * dDiameterEnd;
|
||
|
||
//计算半径偏移量
|
||
double dDiameterOffset = dDiameterEnd - dDiameterStart;
|
||
|
||
ptCorOnArc = ptGeCen + vtCor * ptStart.distanceTo(ptGeCen);
|
||
|
||
//计算直边段的端点
|
||
AcGeVector3d vtStrT = ptStart - ptCorner;
|
||
AcGeVector3d vtEndT = ptEnd - ptCorner;
|
||
vtStrT.normalize();
|
||
vtEndT.normalize();
|
||
ptStartXU = ptStartU + vtStrT * dPlusEdge;
|
||
ptStartXD = ptStartD + vtStrT * dPlusEdge;
|
||
ptEndXU = ptEndU + vtEndT * dPlusEdge;
|
||
ptEndXD = ptEndD + vtEndT * dPlusEdge;
|
||
|
||
double dAngle = fabs(vtEnd.angleTo(vtStr,vtNor));
|
||
|
||
if (dAngle > PI)
|
||
{
|
||
dAngle = 2 * PI - dAngle;
|
||
}
|
||
|
||
double dSegAngle = dAngle / nSegments;
|
||
|
||
pts.append(ptStartXU);
|
||
AcGePoint3d pt;
|
||
pt = ptStartU;
|
||
pts.append(pt);
|
||
|
||
pt = ptStart;
|
||
|
||
int j(0);
|
||
int nOffsetRatioj(1);
|
||
for (j = 0, nOffsetRatioj = 1; j < nSegments - 1; j++, nOffsetRatioj += 1)
|
||
{
|
||
pt.rotateBy(dSegAngle,-vtNor,ptGeCen);
|
||
|
||
//BEGIN==========================================================================================
|
||
AcGePoint3d ptBuffer; //临时存放计算得到的点值
|
||
AcGeVector3d vtTemp = pt - ptGeCen;
|
||
vtTemp.normalize();
|
||
ptBuffer = pt + vtTemp * (dDiameterOffset * nOffsetRatioj / nSegments + dDiameterStart);
|
||
pts.append(ptBuffer);
|
||
}
|
||
|
||
pts.append(ptEndU);
|
||
|
||
pts.append(ptEndXU);
|
||
|
||
//下圆弧的点
|
||
pts.append(ptStartXD);
|
||
pt = ptStartD;
|
||
pts.append(pt);
|
||
|
||
pt = ptStart;
|
||
int i(0);
|
||
int nOffsetRatioi(1);
|
||
for (i = 0, nOffsetRatioi = 1; i < nSegments - 1; i++, nOffsetRatioi += 1)
|
||
{
|
||
pt.rotateBy(dSegAngle,-vtNor,ptGeCen);
|
||
|
||
AcGePoint3d ptBuffer; //临时存放计算得到的点值
|
||
AcGeVector3d vtTemp = pt - ptGeCen;
|
||
vtTemp.normalize();
|
||
ptBuffer = pt - vtTemp * (dDiameterOffset * nOffsetRatioi / nSegments + dDiameterStart);
|
||
pts.append(ptBuffer);
|
||
}
|
||
|
||
pts.append(ptEndD);
|
||
|
||
pts.append(ptEndXD);
|
||
|
||
//中心线的5个点
|
||
pts.append(ptStartX);
|
||
pts.append(ptStart);
|
||
pts.append(ptCorOnArc);
|
||
pts.append(ptEnd);
|
||
pts.append(ptEndX);
|
||
return pts.length() > 0;
|
||
}
|
||
|
||
////////////////////////////////////
|
||
// su
|
||
// sxu ─ ──────╮
|
||
// sx ─ ─────╮│
|
||
// sxd ─ \ ││
|
||
// sd \ ││
|
||
// \ ││
|
||
// \ ed e eu
|
||
// │││
|
||
// exd ex exu
|
||
/////////////////////////////////////
|
||
|
||
BOOL ImpHvacElbow::GetInclineCplCurveHor(AecComplexCurve& cplCurve,int &nType,AcGePoint3d& ptStart, AcGePoint3d& ptCorner,AcGePoint3d& ptEnd,double& dPlusEdge,double& dDiameterS,double& dDiameterE) const
|
||
{
|
||
if (nType != 0 && nType != 1)
|
||
{
|
||
return FALSE;
|
||
}
|
||
AcGeVector3d vtStr,vtEnd,vtCor,vtNor = AcGeVector3d::kZAxis;
|
||
AcGePoint3d ptGeCen,ptStartU,ptStartD,ptCornerU,ptEndU,ptEndD,ptCornerD;
|
||
AcGePoint3d ptStartX,ptStartXU,ptStartXD,ptEndX,ptEndXU,ptEndXD,ptCorOnArc;
|
||
//保证Star点永远在End前面，否则管线反向绘制隔板弯头会有问题
|
||
if (ptStart.x > ptEnd.x)
|
||
{
|
||
AcGePoint3d ptTemp(ptStart);
|
||
ptStart = ptEnd;
|
||
ptEnd = ptTemp;
|
||
|
||
//=========================================================
|
||
double dTemp = dDiameterS;
|
||
dDiameterS = dDiameterE;
|
||
dDiameterE =dTemp;
|
||
}
|
||
ptStartX = ptStart;
|
||
ptEndX = ptEnd;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtNor = vtStr.crossProduct(vtEnd);
|
||
|
||
//ptStart，ptEnd都改变了，去掉了直边段
|
||
ptStart = ptStart - vtStr * dPlusEdge;
|
||
ptEnd = ptEnd - vtEnd * dPlusEdge;
|
||
|
||
vtStr.rotateBy(PI * 0.5,vtNor);
|
||
vtEnd.rotateBy(PI * 0.5,vtNor);
|
||
|
||
//求出圆心ptGeCen
|
||
if(!GetIntersectWith(ptStart,ptEnd,vtStr,vtEnd,ptGeCen))
|
||
return FALSE;
|
||
|
||
vtStr = ptStart - ptGeCen;
|
||
vtEnd = ptEnd - ptGeCen;
|
||
vtCor = ptCorner - ptGeCen;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtCor.normalize();
|
||
|
||
ptStartU = ptStart + vtStr * dDiameterS;
|
||
ptStartD = ptStart - vtStr * dDiameterS;
|
||
ptEndU = ptEnd + vtEnd * dDiameterE;
|
||
ptEndD = ptEnd - vtEnd * dDiameterE;
|
||
|
||
//计算直边段的端点
|
||
ptStartXU = ptStartX + vtStr * dDiameterS;
|
||
ptStartXD = ptStartX - vtStr * dDiameterS;
|
||
ptEndXU = ptEndX + vtEnd * dDiameterE;
|
||
ptEndXD = ptEndX - vtEnd * dDiameterE;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
ptCornerU = (ptCorner - vtStr * dDiameterE) - vtEnd * dDiameterS;
|
||
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL), idEndLayer(NULL);
|
||
// //m_pXDataMap->GetAt(HVAC_BaseLayer, idBaseLayer);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
// 弯头类型
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eIncline;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
|
||
// 根据类型，是否绘制消声线
|
||
switch (eElbowType)
|
||
{
|
||
case AecHvac::eIncline: // 内斜线
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
//el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndD;
|
||
el.ptGe[1] = ptStartD;
|
||
el.ptGe[2] = ptStartD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptEndXU;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptStartXD;
|
||
el.ptGe[1] = ptStartXU;
|
||
el.ptGe[2] = ptStartXU;
|
||
cplCurve.append(el);
|
||
}
|
||
//中心线
|
||
else if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptCorner;
|
||
el.ptGe[2] = ptCorner;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCorner;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
break;
|
||
}
|
||
case AecHvac::eInclineWrap: // 内斜线消声
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
AcGePoint3d ptWrapStrU,ptWrapStrD,ptWrapEndU,ptWrapEndD;
|
||
AcGePoint3d ptWrapStrXU,ptWrapStrXD,ptWrapEndXU,ptWrapEndXD;
|
||
AcGePoint3d ptWrapCorU,ptWrapCorD;
|
||
|
||
double dWrap = MayAsMUnit(50);
|
||
double dMaxWidth = dDiameterS > dDiameterE ? dDiameterS : dDiameterE;
|
||
|
||
if ((ptStart.distanceTo(ptCorner) - MayAsMUnit(50.0)) - dMaxWidth < -1e-6)
|
||
{
|
||
dWrap = 0.1;
|
||
}
|
||
|
||
vtStr = ptStart - ptGeCen;
|
||
vtEnd = ptEnd - ptGeCen;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
ptWrapStrU = ptStartU + vtStr * dWrap;
|
||
ptWrapStrXU = ptStartXU + vtStr * dWrap;
|
||
ptWrapStrXD = ptStartXD - vtStr * dWrap;
|
||
ptWrapEndU = ptEndU + vtEnd * dWrap;
|
||
ptWrapEndXU = ptEndXU + vtEnd * dWrap;
|
||
ptWrapEndXD = ptEndXD - vtEnd * dWrap;
|
||
|
||
//消声斜线与外轮廓的垂直距离是50.
|
||
double dWrapX = dWrap * tan(PI / 8);
|
||
ptWrapStrD = ptWrapStrXD + vtEnd * (dWrap - dWrapX);
|
||
ptWrapEndD = ptWrapEndXD + vtStr * (dWrap - dWrapX);
|
||
|
||
ptWrapCorU = (ptCorner + vtEnd * (dDiameterE + dWrap) + vtStr * (dDiameterS + dWrap));
|
||
|
||
//el.idSubLay = idSideLayer;
|
||
//el.dWidth = dEdgeWidth;
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptWrapStrXU;
|
||
el.ptGe[1] = ptWrapStrXD;
|
||
el.ptGe[2] = ptWrapStrXD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndXU;
|
||
el.ptGe[1] = ptWrapEndXD;
|
||
el.ptGe[2] = ptWrapEndXD;
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = ptWrapStrXU;
|
||
el.ptGe[1] = ptWrapCorU;
|
||
el.ptGe[2] = ptWrapCorU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapCorU;
|
||
el.ptGe[1] = ptWrapEndXU;
|
||
el.ptGe[2] = ptWrapEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndXD;
|
||
el.ptGe[1] = ptWrapEndD;
|
||
el.ptGe[2] = ptWrapEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndD;
|
||
el.ptGe[1] = ptWrapStrD;
|
||
el.ptGe[2] = ptWrapStrD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapStrD;
|
||
el.ptGe[1] = ptWrapStrXD;
|
||
el.ptGe[2] = ptWrapStrXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptCorner;
|
||
el.ptGe[2] = ptCorner;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCorner;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
if (!IsSingleLine())
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.idSubLay = layerId();
|
||
//添加两条消声线
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartXD;
|
||
el.ptGe[1] = ptStartD;
|
||
el.ptGe[2] = ptStartD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndD;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case AecHvac::eInclineBoard: // 内斜线隔板消声
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
//el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndD;
|
||
el.ptGe[1] = ptStartD;
|
||
el.ptGe[2] = ptStartD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartXD;
|
||
el.ptGe[1] = ptStartXU;
|
||
el.ptGe[2] = ptStartXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXU;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
//添加两条消声线
|
||
AcGePoint3d ptWrapStrS,ptWrapStrE,ptWrapEndS,ptWrapEndE;
|
||
vtStr = ptStart - ptGeCen;
|
||
vtEnd = ptEnd - ptGeCen;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
ptWrapStrS = ptStartX + vtStr * dDiameterS / 3.0;
|
||
ptWrapStrE = ptWrapStrS + vtEnd * dDiameterS * 1.4;
|
||
ptWrapEndS = ptEndXU + vtStr * dDiameterS / 1.5;
|
||
ptWrapEndE = ptWrapEndS - vtEnd * dDiameterE * 1.4;
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptCorner;
|
||
el.ptGe[2] = ptCorner;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCorner;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
if (!IsSingleLine())
|
||
{
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = ptWrapStrS;
|
||
el.ptGe[1] = ptWrapStrE;
|
||
el.ptGe[2] = ptWrapStrE;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndS;
|
||
el.ptGe[1] = ptWrapEndE;
|
||
el.ptGe[2] = ptWrapEndE;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case AecHvac::eInclineLead: // 内斜线导流
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
//el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndD;
|
||
el.ptGe[1] = ptStartD;
|
||
el.ptGe[2] = ptStartD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartXD;
|
||
el.ptGe[1] = ptStartXU;
|
||
el.ptGe[2] = ptStartXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXU;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
//添加导流线
|
||
AcGePoint3dArray arptLeaders;
|
||
AcGePoint3d ptWrap,ptWrapU,ptWrapD;
|
||
int nSize = sizeof(nLeader) / sizeof(nLeader[0]);
|
||
//取出第一个大于Dn的行数
|
||
for (int i = 0; i < nSize; i++)
|
||
{
|
||
if (nLeader[i][0] > dDiameterS * 2)
|
||
break;
|
||
}
|
||
//判断DN的最小差值
|
||
if (i > 0)
|
||
{
|
||
if (fabs((nLeader[i][0] - dDiameterS * 2)) > fabs((nLeader[i - 1][0] - dDiameterS * 2)))
|
||
{
|
||
i--;
|
||
}
|
||
}
|
||
ptWrap = ptGeCen + vtCor * (ptGeCen.distanceTo(ptStartD) + nLeader[i][2]);
|
||
ptWrapU = ptWrapD = ptWrap;
|
||
ptWrapU.rotateBy(PI / 10,vtNor,ptGeCen);
|
||
ptWrapD.rotateBy(PI / 10,-vtNor,ptGeCen);
|
||
if (!IsSingleLine() && dDiameterS > MayAsMUnit(249.0))
|
||
{
|
||
//添加第一导流线
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = ptWrapU;
|
||
el.ptGe[1] = ptWrap;
|
||
el.ptGe[2] = ptWrapD;
|
||
cplCurve.append(el);
|
||
//根据数组的第二列，来添加多条导流线
|
||
int nCount = nLeader[i][1];
|
||
for (int j = 0; j < nCount - 1; j++)
|
||
{
|
||
ptWrapU += vtCor * nLeader[i][j + 3];
|
||
ptWrap += vtCor * nLeader[i][j + 3];
|
||
ptWrapD += vtCor * nLeader[i][j + 3];
|
||
el.ptGe[0] = ptWrapU;
|
||
el.ptGe[1] = ptWrap;
|
||
el.ptGe[2] = ptWrapD;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptCorner;
|
||
el.ptGe[2] = ptCorner;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCorner;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
/////////////////////////////////////
|
||
// su corU
|
||
// sxu ─ ──────╮
|
||
// sx ─s─────╮│
|
||
// sxd ─ ────╮││
|
||
// sd corD│││
|
||
// │││
|
||
// ed e eu
|
||
// │││
|
||
// exd ex exu
|
||
/////////////////////////////////////
|
||
|
||
BOOL ImpHvacElbow::GetArcuateCplCurveHor(AecComplexCurve& cplCurve,int &nType,AcGePoint3d& ptStart, AcGePoint3d& ptCorner,AcGePoint3d& ptEnd,double& dPlusEdge,double& dDiameterS,double& dDiameterE) const
|
||
{
|
||
if (nType != 0 && nType != 1)
|
||
{
|
||
return FALSE;
|
||
}
|
||
AcGeVector3d vtStr,vtEnd,vtCor,vtNor = AcGeVector3d::kZAxis;
|
||
AcGePoint3d ptGeCen,ptStartU,ptStartD,ptCornerU,ptEndU,ptEndD,ptCornerD;
|
||
AcGePoint3d ptStartX,ptStartXU,ptStartXD,ptEndX,ptEndXU,ptEndXD,ptCorOnArc;
|
||
//保证Star点永远在End前面，否则管线反向绘制隔板弯头会有问题
|
||
if (ptStart.x > ptEnd.x)
|
||
{
|
||
AcGePoint3d ptTemp(ptStart);
|
||
ptStart = ptEnd;
|
||
ptEnd = ptTemp;
|
||
|
||
//=========================================================
|
||
double dTemp = dDiameterS;
|
||
dDiameterS = dDiameterE;
|
||
dDiameterE =dTemp;
|
||
}
|
||
ptStartX = ptStart;
|
||
ptEndX = ptEnd;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtNor = vtStr.crossProduct(vtEnd);
|
||
|
||
//ptStart，ptEnd都改变了，去掉了直边段
|
||
ptStart = ptStart - vtStr * dPlusEdge;
|
||
ptEnd = ptEnd - vtEnd * dPlusEdge;
|
||
|
||
vtStr.rotateBy(PI * 0.5,vtNor);
|
||
vtEnd.rotateBy(PI * 0.5,vtNor);
|
||
|
||
//求出圆心ptGeCen
|
||
if(!GetIntersectWith(ptStart,ptEnd,vtStr,vtEnd,ptGeCen))
|
||
return FALSE;
|
||
|
||
vtStr = ptStart - ptGeCen;
|
||
vtEnd = ptEnd - ptGeCen;
|
||
vtCor = ptCorner - ptGeCen;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtCor.normalize();
|
||
|
||
ptStartU = ptStart + vtStr * dDiameterS;
|
||
ptStartD = ptStart - vtStr * dDiameterS;
|
||
ptEndU = ptEnd + vtEnd * dDiameterE;
|
||
ptEndD = ptEnd - vtEnd * dDiameterE;
|
||
|
||
//计算直边段的端点
|
||
ptStartXU = ptStartX + vtStr * dDiameterS;
|
||
ptStartXD = ptStartX - vtStr * dDiameterS;
|
||
ptEndXU = ptEndX + vtEnd * dDiameterE;
|
||
ptEndXD = ptEndX - vtEnd * dDiameterE;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
|
||
ptCornerU = (ptCorner - vtStr * dDiameterE) - vtEnd * dDiameterS;
|
||
ptCorOnArc = ptGeCen + vtCor * (ptStart.distanceTo(ptGeCen));
|
||
ptCornerD = ptCorOnArc - vtCor * (dDiameterS + dDiameterE) * 0.5;
|
||
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
// //m_pXDataMap->GetAt(HVAC_BaseLayer, idBaseLayer);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
|
||
// 弯头类型
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eArcuate;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
// 根据类型，是否绘制消声线
|
||
switch (eElbowType)
|
||
{
|
||
case AecHvac::eArcuate: // 内弧线
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
//el.idSubLay = idSideLayer;
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptStartD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartXD;
|
||
el.ptGe[1] = ptStartXU;
|
||
el.ptGe[2] = ptStartXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXU;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//中心线
|
||
else if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptStart;
|
||
el.ptGe[2] = ptStart;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStart;
|
||
el.ptGe[1] = ptCorOnArc;
|
||
el.ptGe[2] = ptEnd;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEnd;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
break;
|
||
}
|
||
case AecHvac::eArcuateWrap: // 消声
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
AcGePoint3d ptWrapStrU,ptWrapStrD,ptWrapEndU,ptWrapEndD;
|
||
AcGePoint3d ptWrapStrXU,ptWrapStrXD,ptWrapEndXU,ptWrapEndXD;
|
||
AcGePoint3d ptWrapCorU,ptWrapCorD;
|
||
|
||
double dWrap = MayAsMUnit(50);
|
||
double dMaxWidth = dDiameterS > dDiameterE ? dDiameterS : dDiameterE;
|
||
|
||
if ((ptStart.distanceTo(ptCorner) - dWrap) - dMaxWidth < -1e-6)
|
||
{
|
||
dWrap = 0.1;
|
||
}
|
||
|
||
vtStr = ptStart - ptGeCen;
|
||
vtEnd = ptEnd - ptGeCen;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
ptWrapStrXU = ptStartXU + vtStr * dWrap;
|
||
ptWrapStrXD = ptStartXD - vtStr * dWrap;
|
||
ptWrapEndXU = ptEndXU + vtEnd * dWrap;
|
||
ptWrapEndXD = ptEndXD - vtEnd * dWrap;
|
||
|
||
ptWrapStrD = ptStart - vtStr * (dDiameterS + dWrap);
|
||
ptWrapEndD = ptEnd - vtEnd * (dDiameterE + dWrap);
|
||
|
||
ptWrapCorU = (ptCorner + vtEnd * (dDiameterE + dWrap) + vtStr * (dDiameterS + dWrap));
|
||
// = ptGeCen + vtCor * (ptWrapStrD.distanceTo(ptGeCen)); //ptWrapStrD
|
||
ptWrapCorD = ptGeCen + vtCor * (ptStart.distanceTo(ptGeCen) - dDiameterS * 0.5 - dDiameterE * 0.5 - dWrap);
|
||
|
||
//el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptWrapEndXU;
|
||
el.ptGe[1] = ptWrapEndXD;
|
||
el.ptGe[2] = ptWrapEndXD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapStrXU;
|
||
el.ptGe[1] = ptWrapStrXD;
|
||
el.ptGe[2] = ptWrapStrXD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapStrXU;
|
||
el.ptGe[1] = ptWrapCorU;
|
||
el.ptGe[2] = ptWrapCorU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapCorU;
|
||
el.ptGe[1] = ptWrapEndXU;
|
||
el.ptGe[2] = ptWrapEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndXD;
|
||
el.ptGe[1] = ptWrapEndD;
|
||
el.ptGe[2] = ptWrapEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndD;
|
||
el.ptGe[1] = ptWrapCorD;
|
||
el.ptGe[2] = ptWrapStrD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapStrD;
|
||
el.ptGe[1] = ptWrapStrXD;
|
||
el.ptGe[2] = ptWrapStrXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
//添加两条消声线
|
||
if (!IsSingleLine())
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.idSubLay = layerId();
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptStartD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptStart;
|
||
el.ptGe[2] = ptStart;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStart;
|
||
el.ptGe[1] = ptCorOnArc;
|
||
el.ptGe[2] = ptEnd;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEnd;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case AecHvac::eArcuateBoard: // 隔板消声
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
//el.idSubLay = idSideLayer;
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptStartD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptEndXU;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartXD;
|
||
el.ptGe[1] = ptStartXU;
|
||
el.ptGe[2] = ptStartXU;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
//添加两条隔板线
|
||
AcGePoint3d ptWrapStrS,ptWrapStrE,ptWrapEndS,ptWrapEndE;
|
||
vtStr = ptStart - ptGeCen;
|
||
vtEnd = ptEnd - ptGeCen;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
ptWrapStrS = ptStartX + vtStr * dDiameterS / 3.0;
|
||
ptWrapStrE = ptWrapStrS + vtEnd * dDiameterS * 1.4;
|
||
ptWrapEndS = ptEndXU + vtStr * dDiameterS / 1.5;
|
||
ptWrapEndE = ptWrapEndS - vtEnd * dDiameterE * 1.4;
|
||
|
||
if (!IsSingleLine())
|
||
{
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptWrapStrS;
|
||
el.ptGe[1] = ptWrapStrE;
|
||
el.ptGe[2] = ptWrapStrE;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndS;
|
||
el.ptGe[1] = ptWrapEndE;
|
||
el.ptGe[2] = ptWrapEndE;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptStart;
|
||
el.ptGe[2] = ptStart;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStart;
|
||
el.ptGe[1] = ptCorOnArc;
|
||
el.ptGe[2] = ptEnd;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEnd;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case AecHvac::eArcuateSieve: // 筛板消声
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
//el.idSubLay = idSideLayer;
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptStartD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartXD;
|
||
el.ptGe[1] = ptStartXU;
|
||
el.ptGe[2] = ptStartXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXU;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
//添加两条筛板线
|
||
AcGePoint3d ptWrap1S,ptWrap1E,ptWrap2S,ptWrap2E;
|
||
//旋转9度
|
||
AcGeCircArc3d cirArc(ptStartD,ptCornerD,ptEndD);
|
||
AcGePoint3d ptGeCenD = cirArc.center();
|
||
ptWrap1S = ptCornerD;
|
||
ptWrap2S = ptCornerD;
|
||
ptWrap1S.rotateBy(PI * 0.02,vtNor,ptGeCenD);
|
||
ptWrap2S.rotateBy(PI * 0.02,-vtNor,ptGeCenD);
|
||
//求交
|
||
AcGeVector3d vtWrapCor = ptCornerD - ptCornerU;
|
||
GetIntersectWith(ptStartXU,ptWrap1S,vtStr,vtWrapCor,ptWrap1E);
|
||
GetIntersectWith(ptEndXU,ptWrap2S,vtEnd,vtWrapCor,ptWrap2E);
|
||
|
||
if (!IsSingleLine())
|
||
{
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = ptWrap1S;
|
||
el.ptGe[1] = ptWrap1E;
|
||
el.ptGe[2] = ptWrap1E;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrap2S;
|
||
el.ptGe[1] = ptWrap2E;
|
||
el.ptGe[2] = ptWrap2E;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptStart;
|
||
el.ptGe[2] = ptStart;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStart;
|
||
el.ptGe[1] = ptCorOnArc;
|
||
el.ptGe[2] = ptEnd;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEnd;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case AecHvac::eArcuateLead: // 导流
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
//el.idSubLay = idSideLayer;
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptStartD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartXD;
|
||
el.ptGe[1] = ptStartXU;
|
||
el.ptGe[2] = ptStartXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXU;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
//添加导流线
|
||
AcGePoint3dArray arptLeaders;
|
||
AcGePoint3d ptWrap,ptWrapU,ptWrapD;
|
||
int nSize = sizeof(nLeader) / sizeof(nLeader[0]);
|
||
//取出第一个大于Dn的行数
|
||
for (int i = 0; i < nSize; i++)
|
||
{
|
||
if (nLeader[i][0] > dDiameterS * 2)
|
||
break;
|
||
}
|
||
//判断DN的最小差值
|
||
if (i > 0)
|
||
{
|
||
if (fabs((nLeader[i][0] - dDiameterS * 2)) > fabs((nLeader[i - 1][0] - dDiameterS * 2)))
|
||
{
|
||
i--;
|
||
}
|
||
}
|
||
ptWrap = ptGeCen + vtCor * (ptGeCen.distanceTo(ptStartD) + nLeader[i][2]);
|
||
ptWrapU = ptWrapD = ptWrap;
|
||
ptWrapU.rotateBy(PI / 10,vtNor,ptGeCen);
|
||
ptWrapD.rotateBy(PI / 10,-vtNor,ptGeCen);
|
||
if (!IsSingleLine() && dDiameterS > MayAsMUnit(249.0))
|
||
{
|
||
//添加第一导流线
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptWrapU;
|
||
el.ptGe[1] = ptWrap;
|
||
el.ptGe[2] = ptWrapD;
|
||
cplCurve.append(el);
|
||
//根据数组的第二列，来添加多条导流线
|
||
int nCount = nLeader[i][1];
|
||
for (int j = 0; j < nCount - 1; j++)
|
||
{
|
||
ptWrapU += vtCor * nLeader[i][j + 3];
|
||
ptWrap += vtCor * nLeader[i][j + 3];
|
||
ptWrapD += vtCor * nLeader[i][j + 3];
|
||
el.ptGe[0] = ptWrapU;
|
||
el.ptGe[1] = ptWrap;
|
||
el.ptGe[2] = ptWrapD;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptStart;
|
||
el.ptGe[2] = ptStart;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStart;
|
||
el.ptGe[1] = ptCorOnArc;
|
||
el.ptGe[2] = ptEnd;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEnd;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
//////////////////////////////////////
|
||
// su corU
|
||
// sxu ─ ──────╮
|
||
// sx ─s─────╮│
|
||
// sxd ─ ────╮││
|
||
// sd corD│││
|
||
// │││
|
||
// ed e eu
|
||
// │││
|
||
// exd ex exu
|
||
/////////////////////////////////////
|
||
|
||
BOOL ImpHvacElbow::GetAllOrthoCplCurveHor(AecComplexCurve& cplCurve,int &nType,AcGePoint3d& ptStart, AcGePoint3d& ptCorner,AcGePoint3d& ptEnd,double& dPlusEdge,double& dDiameterS,double& dDiameterE) const
|
||
{
|
||
if (nType != 0 && nType != 1)
|
||
{
|
||
return FALSE;
|
||
}
|
||
AcGeVector3d vtStr,vtEnd,vtCor,vtNor = AcGeVector3d::kZAxis;
|
||
AcGePoint3d ptGeCen,ptStartU,ptStartD,ptCornerU,ptEndU,ptEndD,ptCornerD;
|
||
AcGePoint3d ptStartX,ptStartXU,ptStartXD,ptEndX,ptEndXU,ptEndXD,ptCorOnArc;
|
||
ptStartX = ptStart;
|
||
ptEndX = ptEnd;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtNor = vtStr.crossProduct(vtEnd);
|
||
|
||
//ptStart，ptEnd都改变了，去掉了直边段
|
||
ptStart = ptStart - vtStr * dPlusEdge;
|
||
ptEnd = ptEnd - vtEnd * dPlusEdge;
|
||
|
||
vtStr.rotateBy(PI * 0.5,vtNor);
|
||
vtEnd.rotateBy(PI * 0.5,vtNor);
|
||
|
||
//求出圆心ptGeCen
|
||
if(!GetIntersectWith(ptStart,ptEnd,vtStr,vtEnd,ptGeCen))
|
||
return FALSE;
|
||
|
||
vtStr = ptStart - ptGeCen;
|
||
vtEnd = ptEnd - ptGeCen;
|
||
vtCor = ptCorner - ptGeCen;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtCor.normalize();
|
||
|
||
ptStartU = ptStart + vtStr * dDiameterS;
|
||
ptStartD = ptStart - vtStr * dDiameterS;
|
||
ptEndU = ptEnd + vtEnd * dDiameterE;
|
||
ptEndD = ptEnd - vtEnd * dDiameterE;
|
||
|
||
//计算直边段的端点
|
||
ptStartXU = ptStartX + vtStr * dDiameterS;
|
||
ptStartXD = ptStartX - vtStr * dDiameterS;
|
||
ptEndXU = ptEndX + vtEnd * dDiameterE;
|
||
ptEndXD = ptEndX - vtEnd * dDiameterE;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
ptCornerU = (ptCorner - vtStr * dDiameterE) - vtEnd * dDiameterS;
|
||
ptCornerD = (ptCorner + vtStr * dDiameterE) + vtEnd * dDiameterS;
|
||
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
//m_pXDataMap->GetAt(HVAC_BaseLayer, idBaseLayer);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
|
||
// 弯头类型
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eAllOrtho;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
// 根据类型，是否绘制消声线
|
||
switch (eElbowType)
|
||
{
|
||
case AecHvac::eAllOrtho: // 内外直角
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
//el.idSubLay = idSideLayer;
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptCornerD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartXD;
|
||
el.ptGe[1] = ptStartXU;
|
||
el.ptGe[2] = ptStartXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXU;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//中心线
|
||
else if (1 == nType && (HasBaseLine() || IsSingleLine()))
|
||
{
|
||
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptCorner;
|
||
el.ptGe[2] = ptCorner;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCorner;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
break;
|
||
}
|
||
case AecHvac::eOrthoWrap: // 直角消声
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
AcGePoint3d ptWrapStrU,ptWrapStrD,ptWrapEndU,ptWrapEndD;
|
||
AcGePoint3d ptWrapStrXU,ptWrapStrXD,ptWrapEndXU,ptWrapEndXD;
|
||
AcGePoint3d ptWrapCorU,ptWrapCorD;
|
||
|
||
double dWrap = MayAsMUnit(50);
|
||
double dMaxWidth = dDiameterS > dDiameterE ? dDiameterS : dDiameterE;
|
||
|
||
if ((ptStart.distanceTo(ptCorner) - dWrap) - dMaxWidth < -1e-6)
|
||
{
|
||
dWrap = 0.1;
|
||
}
|
||
|
||
vtStr = ptStart - ptGeCen;
|
||
vtEnd = ptEnd - ptGeCen;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
ptWrapStrXU = ptStartXU + vtStr * dWrap;
|
||
ptWrapStrXD = ptStartXD - vtStr * dWrap;
|
||
ptWrapEndXU = ptEndXU + vtEnd * dWrap;
|
||
ptWrapEndXD = ptEndXD - vtEnd * dWrap;
|
||
|
||
ptWrapCorU = (ptCorner + vtEnd * (dDiameterE + dWrap) + vtStr * (dDiameterS + dWrap));
|
||
ptWrapCorD = (ptCorner - vtEnd * (dDiameterE + dWrap) - vtStr * (dDiameterS + dWrap));
|
||
|
||
//el.idSubLay = idSideLayer;
|
||
//el.dWidth = dEdgeWidth;
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptWrapStrXD;
|
||
el.ptGe[1] = ptWrapStrXU;
|
||
el.ptGe[2] = ptWrapStrXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndXU;
|
||
el.ptGe[1] = ptWrapEndXD;
|
||
el.ptGe[2] = ptWrapEndXD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapStrXU;
|
||
el.ptGe[1] = ptWrapCorU;
|
||
el.ptGe[2] = ptWrapCorU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapCorU;
|
||
el.ptGe[1] = ptWrapEndXU;
|
||
el.ptGe[2] = ptWrapEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapEndXD;
|
||
el.ptGe[1] = ptWrapCorD;
|
||
el.ptGe[2] = ptWrapCorD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptWrapCorD;
|
||
el.ptGe[1] = ptWrapStrXD;
|
||
el.ptGe[2] = ptWrapStrXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
//添加两条消声线
|
||
if (!IsSingleLine())
|
||
{
|
||
el.idSubLay = layerId();
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptCornerD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptCorner;
|
||
el.ptGe[2] = ptCorner;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCorner;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case AecHvac::eOrthoLead: // 直角导流
|
||
{
|
||
//外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartXU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerU;
|
||
el.ptGe[1] = ptEndXU;
|
||
el.ptGe[2] = ptEndXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptCornerD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerD;
|
||
el.ptGe[1] = ptStartXD;
|
||
el.ptGe[2] = ptStartXD;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartXD;
|
||
el.ptGe[1] = ptStartXU;
|
||
el.ptGe[2] = ptStartXU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndXU;
|
||
el.ptGe[1] = ptEndXD;
|
||
el.ptGe[2] = ptEndXD;
|
||
cplCurve.append(el);
|
||
}
|
||
//内部线
|
||
else if (1 == nType)
|
||
{
|
||
//添加导流线
|
||
AcGePoint3dArray arptLeaders;
|
||
AcGePoint3d ptWrap,ptWrapU,ptWrapD;
|
||
int nSize = sizeof(nLeader) / sizeof(nLeader[0]);
|
||
//取出第一个大于Dn的行数
|
||
for (int i = 0; i < nSize; i++)
|
||
{
|
||
if (nLeader[i][0] > dDiameterS * 2)
|
||
break;
|
||
}
|
||
//判断DN的最小差值
|
||
if (i > 0)
|
||
{
|
||
if (fabs((nLeader[i][0] - dDiameterS * 2)) > fabs((nLeader[i - 1][0] - dDiameterS * 2)))
|
||
{
|
||
i--;
|
||
}
|
||
}
|
||
ptWrap = ptGeCen + vtCor * (ptGeCen.distanceTo(ptStartD) + nLeader[i][2]);
|
||
ptWrapU = ptWrapD = ptWrap;
|
||
ptWrapU.rotateBy(PI / 10,vtNor,ptGeCen);
|
||
ptWrapD.rotateBy(PI / 10,-vtNor,ptGeCen);
|
||
if (!IsSingleLine() && dDiameterS > MayAsMUnit(249.0))
|
||
{
|
||
//添加第一导流线
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = ptWrapU;
|
||
el.ptGe[1] = ptWrap;
|
||
el.ptGe[2] = ptWrapD;
|
||
cplCurve.append(el);
|
||
//根据数组的第二列，来添加多条导流线
|
||
int nCount = nLeader[i][1];
|
||
for (int j = 0; j < nCount - 1; j++)
|
||
{
|
||
ptWrapU += vtCor * nLeader[i][j + 3];
|
||
ptWrap += vtCor * nLeader[i][j + 3];
|
||
ptWrapD += vtCor * nLeader[i][j + 3];
|
||
el.ptGe[0] = ptWrapU;
|
||
el.ptGe[1] = ptWrap;
|
||
el.ptGe[2] = ptWrapD;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
|
||
//中心线
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.gsMark = -1;
|
||
el.idSubLay = idBaseLayer;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptCorner;
|
||
el.ptGe[2] = ptCorner;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCorner;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
BOOL ImpHvacElbow::GetAllArcuateCplCurveVerRec(AecComplexCurve& cplCurve,int &nType,AcGePoint3d& ptStart, AcGePoint3d& ptCorner,AcGePoint3d& ptEnd,double& dPlusEdge,double& dDiameterS,double& dDiameterE,double& dThick, double& dEndThick) const
|
||
{
|
||
if (nType != 0 && nType != 1)
|
||
{
|
||
return FALSE;
|
||
}
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eIncline;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
|
||
AcGeVector3d vtStr,vtEnd,vcCor,vtNor = AcGeVector3d::kZAxis;
|
||
AcGePoint3d ptGeCen,ptStartU,ptStartD,ptCornerU,ptEndU,ptEndD,ptCornerD,ptStartX,ptEndX;
|
||
|
||
ptStartX = ptStart;
|
||
ptEndX = ptEnd;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
AcGeVector3d vtOrigEnd = vtEnd;
|
||
vtNor = vtStr.crossProduct(vtEnd);
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtNor.normalize();
|
||
|
||
vtEnd.rotateBy(PI / 2, vtNor);
|
||
vtEnd.normalize();
|
||
//处理弯头开始点和末点互换
|
||
if (!vtStr.isPerpendicularTo(AcGeVector3d::kZAxis))
|
||
{
|
||
ptStartX = ptEnd;
|
||
ptEndX = ptStart;
|
||
vtEnd = ptCorner - ptEndX;
|
||
vtEnd.rotateBy(PI / 2, vtNor);
|
||
vtEnd.normalize();
|
||
|
||
//BEGIN===========================================
|
||
double dTemp = dThick;
|
||
dThick = dEndThick;
|
||
dEndThick = dTemp;
|
||
|
||
dTemp = dDiameterE;
|
||
dDiameterE = dDiameterS;
|
||
dDiameterS = dTemp;
|
||
}
|
||
|
||
ptEndX.z = ptStartX.z;// = (ptStart.z + ptEnd.z) * 0.5;
|
||
|
||
ptStartU = ptStartX + vtNor * dThick;
|
||
ptStartD = ptStartX - vtNor * dThick;
|
||
|
||
if (eElbowType != AecHvac::eAllArcuate && eElbowType != AecHvac::eAllArcWrap
|
||
&& eElbowType != AecHvac::eAllArcInWrap)
|
||
{
|
||
ptEndU = ptEndX + vtNor * (dEndThick + dThick) * 0.5;
|
||
ptEndD = ptEndX - vtNor * (dEndThick + dThick) * 0.5;
|
||
}
|
||
else
|
||
{
|
||
ptEndU = ptEndX + vtNor * dEndThick;
|
||
ptEndD = ptEndX - vtNor * dEndThick;
|
||
}
|
||
|
||
ptCornerU = ptEndU + vtEnd * dDiameterE;
|
||
ptCornerD = ptEndD + vtEnd * dDiameterE;
|
||
|
||
ptEndU = ptEndU - vtEnd * dDiameterE;
|
||
ptEndD = ptEndD - vtEnd * dDiameterE;
|
||
|
||
ptCornerU.z = ptStartX.z;
|
||
ptCornerD.z = ptStartX.z;
|
||
ptEndU.z = ptStartX.z;
|
||
ptEndD.z = ptStartX.z;
|
||
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
//m_pXDataMap->GetAt(HVAC_BaseLayer, idBaseLayer);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
//el.idSubLay = idSideLayer;
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartU;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptCornerD;
|
||
el.ptGe[2] = ptCornerD;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptCornerD;
|
||
el.ptGe[1] = ptCornerU;
|
||
el.ptGe[2] = ptCornerU;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartU;
|
||
el.ptGe[1] = ptStartD;
|
||
el.ptGe[2] = ptStartD;
|
||
cplCurve.append(el);
|
||
}
|
||
if (1 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
AcGePoint3d ptMid = MidPoint(ptStart,ptEnd);
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.idSubLay = idBaseLayer;
|
||
el.gsMark = -1;
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
int nDrawMode(0); // 是否填充线
|
||
m_pXDataMap->GetAt(HELB_VertDrawStyle, nDrawMode);
|
||
if (1 == nDrawMode)
|
||
{
|
||
AcGeVector3d vtUcsz = GetUcsZvt();
|
||
BOOL bStartToDown = vtStr.isCodirectionalTo(-vtUcsz);
|
||
BOOL bEndToDown = vtOrigEnd.isCodirectionalTo(-vtUcsz);
|
||
if (bStartToDown || bEndToDown) // 只有向下翻的弯头才绘制
|
||
{
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
|
||
//BEGIN===============================================================
|
||
double dWidth(0.0);
|
||
double dWidthEnd = 0.0;
|
||
|
||
if (bStartToDown)
|
||
{
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth, dWidthEnd);
|
||
}
|
||
else
|
||
{
|
||
m_pXDataMap->GetAt(HELB_EndWidth, dWidth);
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dWidthEnd);
|
||
}
|
||
|
||
dWidth = dWidth > dWidthEnd ? dWidth : dWidthEnd;
|
||
|
||
AcGePoint3dArray ptUpArr;
|
||
AcGePoint3dArray ptDownArr;
|
||
|
||
AcGeVector3d vtOff = (ptStartU - ptCornerU).normalize();
|
||
ptUpArr.append(ptCornerU + vtOff * dWidth * 7.0/100.0); // 按照6.0比例
|
||
ptUpArr.append(ptCornerU + vtOff * dWidth * 17.0/100.0);
|
||
ptUpArr.append(ptCornerU + vtOff * dWidth * 32.0/100.0);
|
||
ptUpArr.append(ptCornerU + vtOff * dWidth * 47.0/100.0);
|
||
ptUpArr.append(ptCornerU + vtOff * dWidth * 68.0/100.0);
|
||
|
||
vtOff = (ptStartD - ptCornerD).normalize();
|
||
ptDownArr.append(ptCornerD + vtOff * dWidth * 7.0/100.0); // 按照6.0比例
|
||
ptDownArr.append(ptCornerD + vtOff * dWidth * 17.0/100.0);
|
||
ptDownArr.append(ptCornerD + vtOff * dWidth * 32.0/100.0);
|
||
ptDownArr.append(ptCornerD + vtOff * dWidth * 47.0/100.0);
|
||
ptDownArr.append(ptCornerD + vtOff * dWidth * 68.0/100.0);
|
||
|
||
int i(0);
|
||
//AcGePoint3d ptTemp;
|
||
for (i = 0; i < ptUpArr.length(); i++)
|
||
{
|
||
//ptTemp = ptUpArr[i] + vtPerl * dThick;
|
||
el.ptGe[0] = ptUpArr[i];
|
||
el.ptGe[1] = ptDownArr[i];
|
||
el.ptGe[2] = ptDownArr[i];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL ImpHvacElbow::GetAllArcuateCplCurveVerRecForOffset(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
AcGePoint3d ptStart, ptCorner, ptCornerAssist, ptEnd;
|
||
m_pXDataMap->GetAt(HELB_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HELB_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint, ptCorner);
|
||
m_pXDataMap->GetAt(HELB_AssisCornerPoint, ptCornerAssist);
|
||
|
||
double dThickStart = 0.0, dThickEnd = 0.0, dWidth = 0.0;
|
||
m_pXDataMap->GetAt(HELB_Thick, dThickStart);
|
||
m_pXDataMap->GetAt(HELB_EndThick, dThickEnd);
|
||
dThickStart *= 0.5;
|
||
dThickEnd *= 0.5;
|
||
|
||
AcGeVector3d vtStart = ptStart - ptCorner;
|
||
vtStart.normalize();
|
||
AcGeVector3d vtEnd = ptEnd - ptCornerAssist;
|
||
vtStart.normalize();
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
AcGePlane planeStd;
|
||
AcGeVector3d vtHorOffset;
|
||
if (vtStart.isPerpendicularTo(vtZAxis))
|
||
{
|
||
planeStd.set(ptStart, vtZAxis);
|
||
ptEnd = ptEnd.orthoProject(planeStd);
|
||
m_pXDataMap->GetAt(HELB_EndWidth, dWidth);
|
||
dWidth *= 0.5;
|
||
vtHorOffset = ptCorner - ptStart;
|
||
vtHorOffset.normalize();
|
||
|
||
AcGePoint3d ptTemp = ptStart;
|
||
ptStart = ptEnd;
|
||
ptEnd = ptTemp;
|
||
|
||
double dTemp = dThickStart;
|
||
dThickStart = dThickEnd;
|
||
dThickEnd = dTemp;
|
||
}
|
||
else
|
||
{
|
||
planeStd.set(ptEnd, vtZAxis);
|
||
ptStart = ptStart.orthoProject(planeStd);
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dWidth);
|
||
dWidth *= 0.5;
|
||
vtHorOffset = ptCornerAssist - ptEnd;
|
||
vtHorOffset.normalize();
|
||
}
|
||
|
||
AcGeVector3d vtNormalElbow = vtStart.crossProduct(vtEnd);
|
||
vtNormalElbow.normalize();
|
||
|
||
AcGePoint3d ptStartUpL = ptStart + vtNormalElbow * dThickStart + vtHorOffset * dWidth;
|
||
AcGePoint3d ptStartUpR = ptStart + vtNormalElbow * dThickStart - vtHorOffset * dWidth;
|
||
AcGePoint3d ptStartDownL = ptStart - vtNormalElbow * dThickStart + vtHorOffset * dWidth;
|
||
AcGePoint3d ptStartDownR = ptStart - vtNormalElbow * dThickStart - vtHorOffset * dWidth;
|
||
AcGePoint3d ptEndUp = ptEnd + vtNormalElbow * dThickEnd;
|
||
AcGePoint3d ptEndDown = ptEnd - vtNormalElbow * dThickEnd;
|
||
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartUpL;
|
||
el.ptGe[1] = ptStartUpR;
|
||
el.ptGe[2] = ptStartUpR;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartUpR;
|
||
el.ptGe[1] = ptEndUp;
|
||
el.ptGe[2] = ptEndUp;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndUp;
|
||
el.ptGe[1] = ptEndDown;
|
||
el.ptGe[2] = ptEndDown;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptEndDown;
|
||
el.ptGe[1] = ptStartDownR;
|
||
el.ptGe[2] = ptStartDownR;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartDownR;
|
||
el.ptGe[1] = ptStartDownL;
|
||
el.ptGe[2] = ptStartDownL;
|
||
cplCurve.append(el);
|
||
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
el.ptGe[0] = ptStartDownL;
|
||
el.ptGe[1] = ptStartUpL;
|
||
el.ptGe[2] = ptStartUpL;
|
||
cplCurve.append(el);
|
||
}
|
||
if (1 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
AcGePoint3d ptMid = MidPoint(ptStart,ptEnd);
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.idSubLay = idBaseLayer;
|
||
el.gsMark = -1;
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStart;
|
||
el.ptGe[1] = ptEnd;
|
||
el.ptGe[2] = ptEnd;
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL ImpHvacElbow::GetAllArcuateCplCurveVerCir(AecComplexCurve& cplCurve,int &nType,AcGePoint3d& ptStart, AcGePoint3d& ptCorner,AcGePoint3d& ptEnd,double& dPlusEdge,double& dDiameterS,double& dDiameterE) const
|
||
{
|
||
if (nType != 0 && nType != 1)
|
||
{
|
||
return FALSE;
|
||
}
|
||
AcGeVector3d vtStr,vtEnd,vtDir,vtNor = AcGeVector3d::kZAxis, vtTemp;
|
||
AcGePoint3d ptStartU,ptStartD,ptCornerU,ptEndU,ptEndD,ptCornerD,ptStartArc,ptEndArc;
|
||
AcGePoint3d ptStartX,ptStartXU,ptStartXD,ptEndX,ptEndXU,ptEndXD,ptCorOnArc;
|
||
AcGePoint3d ptOrgStart, ptOrgEnd;
|
||
ptOrgStart = ptStart;
|
||
ptOrgEnd = ptEnd;
|
||
ptStartX = ptStart;
|
||
ptEndX = ptEnd;
|
||
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtNor = vtStr.crossProduct(vtEnd);
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtNor.normalize();
|
||
ptStart -= vtStr * dPlusEdge;
|
||
ptEnd -= vtEnd * dPlusEdge;
|
||
// double dAngle = vtStr.angleTo(vtEnd,vtNor);
|
||
AcGeVector3d vtZAxis(GetUcsZvt());
|
||
|
||
ptEndX.z = ptStartX.z;
|
||
|
||
ptStartU = ptStartX + vtNor * dDiameterS;
|
||
ptStartD = ptStartX - vtNor * dDiameterS;
|
||
|
||
ptEndU = ptEndX + vtNor * dDiameterE;
|
||
ptEndD = ptEndX - vtNor * dDiameterE;
|
||
|
||
ptStartArc = ptStartX - vtEnd * dDiameterS;
|
||
|
||
ptEndArc = ptEndX - vtStr * dDiameterE;
|
||
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
int nHasBaseLine = 1;
|
||
//m_pXDataMap->GetAt(HVAC_BaseLayer, idBaseLayer);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine, nHasBaseLine);
|
||
|
||
AcDbObjectId idReal = layerId();
|
||
AcDbObjectId idDash = DashLayer();
|
||
AcDbObjectId idCent = CenterLayer();
|
||
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
|
||
AcGePoint3dArray pts;
|
||
AcDbPolyline pPolyLine1, pPolyLine2;
|
||
int nRet = -1;
|
||
if (nType == 0)
|
||
{
|
||
vtDir = ptCorner - ptOrgStart;
|
||
if (vtDir.isParallelTo(vtZAxis))
|
||
// vtTemp = -vtStr.crossProduct(vtNor);// Lixl modify 2011-12-16
|
||
vtTemp = -vtEnd;
|
||
else
|
||
vtTemp = -vtDir;
|
||
nRet = GetEllipsePtsFromCircle(pts, ptOrgStart, dDiameterS*2.0, -vtDir, vtZAxis, pPolyLine1, vtTemp);
|
||
if (-1 != nRet)
|
||
{
|
||
if (1 == nRet)
|
||
{
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
}
|
||
else
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.idSubLay = AcDbObjectId::kNull;
|
||
}
|
||
|
||
if (0 == nRet && pts.length() == 3)// 半圆 Lixl add 2011-11-23
|
||
{
|
||
el.ptGe[0] = pts[0];
|
||
el.ptGe[1] = pts[1];
|
||
el.ptGe[2] = pts[2];
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
for (int i = 0; i < pts.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = pts[i];
|
||
el.ptGe[1] = pts[i+1];
|
||
el.ptGe[2] = pts[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
// 终点端线
|
||
vtDir = ptCorner - ptOrgEnd;
|
||
if (vtDir.isParallelTo(vtZAxis))
|
||
// vtTemp = -vtEnd.crossProduct(vtNor);// Lixl modify 2011-12-16
|
||
vtTemp = -vtStr;
|
||
else
|
||
vtTemp = -vtDir;
|
||
pts.setLogicalLength(0);
|
||
nRet = GetEllipsePtsFromCircle(pts, ptOrgEnd, dDiameterE*2, -vtDir, vtZAxis, pPolyLine2, vtTemp);
|
||
if (-1 != nRet)
|
||
{
|
||
if (1 == nRet)
|
||
{
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
}
|
||
else
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.idSubLay = AcDbObjectId::kNull;
|
||
}
|
||
if (0 == nRet && pts.length() == 3)// 半圆Lixl add 2011-11-23
|
||
{
|
||
el.ptGe[0] = pts[0];
|
||
el.ptGe[1] = pts[1];
|
||
el.ptGe[2] = pts[2];
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
for (int i = 0; i < pts.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = pts[i];
|
||
el.ptGe[1] = pts[i+1];
|
||
el.ptGe[2] = pts[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
el.idSubLay = idReal;
|
||
el.dWidth = dEdgeWidth;
|
||
el.ptGe[0] = ptStartU;
|
||
el.ptGe[1] = ptEndU;
|
||
el.ptGe[2] = ptEndU;
|
||
cplCurve.append(el);
|
||
|
||
el.ptGe[0] = ptStartD;
|
||
el.ptGe[1] = ptEndD;
|
||
el.ptGe[2] = ptEndD;
|
||
cplCurve.append(el);
|
||
}
|
||
else if (nType == 1)
|
||
{
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.idSubLay = idBaseLayer;
|
||
el.gsMark = -1;
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = ptStartX;
|
||
el.ptGe[1] = ptEndX;
|
||
el.ptGe[2] = ptEndX;
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
el.idSubLay = idReal;
|
||
el.dWidth = dEdgeWidth;
|
||
|
||
if (vtStr.angleTo(vtZAxis) < PI*0.25 || vtEnd.angleTo(vtZAxis) < PI*0.25)
|
||
{
|
||
ptStartArc = ptStartX + vtEnd * dDiameterS;
|
||
|
||
//BEGIN=====================================================
|
||
//ptEndArc = ptEndX + vtStr * dDiameterS;
|
||
ptEndArc = ptEndX + vtStr * dDiameterE;
|
||
|
||
el.gsMark = 0;
|
||
if (ptOrgStart.z > ptCorner.z)// 看看是否需要画内部半圆Lixl
|
||
{
|
||
vtDir = ptCorner - ptOrgStart;
|
||
if (vtDir.isParallelTo(vtZAxis))
|
||
vtTemp = vtStr.crossProduct(vtNor);
|
||
else
|
||
vtTemp = vtDir;
|
||
nRet = GetEllipsePtsFromCircle(pts, ptOrgStart, dDiameterS*2.0, vtDir, vtZAxis, pPolyLine1, vtTemp);
|
||
if (-1 != nRet)
|
||
{
|
||
if (1 == nRet)
|
||
{
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
}
|
||
else
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.idSubLay = AcDbObjectId::kNull;
|
||
}
|
||
if (0 == nRet && pts.length() == 3)// 半圆Lixl add 2011-11-23
|
||
{
|
||
el.ptGe[0] = pts[0];
|
||
el.ptGe[1] = pts[1];
|
||
el.ptGe[2] = pts[2];
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
for (int i = 0; i < pts.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = pts[i];
|
||
el.ptGe[1] = pts[i+1];
|
||
el.ptGe[2] = pts[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (ptOrgEnd.z > ptCorner.z)
|
||
{
|
||
vtDir = ptCorner - ptOrgEnd;
|
||
if (vtDir.isParallelTo(vtZAxis))
|
||
vtTemp = vtEnd.crossProduct(vtNor);
|
||
else
|
||
vtTemp = vtDir;
|
||
pts.setLogicalLength(0);
|
||
nRet = GetEllipsePtsFromCircle(pts, ptOrgEnd, dDiameterE*2, vtDir, vtZAxis, pPolyLine2, vtTemp);
|
||
if (-1 != nRet)
|
||
{
|
||
if (1 == nRet)
|
||
{
|
||
el.dWidth = dEndLineWidth;
|
||
el.idSubLay = idSideLayer;
|
||
}
|
||
else
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
el.idSubLay = AcDbObjectId::kNull;
|
||
}
|
||
if (0 == nRet && pts.length() == 3)// 半圆Lixl add 2011-11-23
|
||
{
|
||
el.ptGe[0] = pts[0];
|
||
el.ptGe[1] = pts[1];
|
||
el.ptGe[2] = pts[2];
|
||
cplCurve.append(el);
|
||
}
|
||
else
|
||
{
|
||
for (int i = 0; i < pts.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = pts[i];
|
||
el.ptGe[1] = pts[i+1];
|
||
el.ptGe[2] = pts[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
el.gsMark = -1;
|
||
}
|
||
else
|
||
{
|
||
int nDrawMode(0); // 是否填充线
|
||
m_pXDataMap->GetAt(HELB_VertDrawStyle, nDrawMode);
|
||
if (1 == nDrawMode)
|
||
{
|
||
BOOL bStartToDown = vtStr.isCodirectionalTo(-vtZAxis);
|
||
BOOL bEndToDown = vtEnd.isCodirectionalTo(-vtZAxis);
|
||
if (bStartToDown || bEndToDown) // 只有向下翻的弯头才绘制
|
||
{
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
|
||
AcGePoint3d ptStartMoveUp, ptEndMoveUp, ptStartMoveArc, ptEndMoveArc;
|
||
AcGePoint3d ptStartMoveDown, ptEndMoveDown;
|
||
|
||
if (bStartToDown)
|
||
{
|
||
ptStartMoveUp = ptStartU;
|
||
ptEndMoveUp = ptEndU;
|
||
ptStartMoveArc = ptStartArc;
|
||
ptEndMoveArc = ptEndArc;
|
||
ptStartMoveDown = ptStartD;
|
||
ptEndMoveDown = ptEndD;
|
||
//m_pXDataMap->GetAt(HELB_Diameter, dWidth);
|
||
}
|
||
else
|
||
{
|
||
ptStartMoveUp = ptEndU;
|
||
ptEndMoveUp = ptStartU;
|
||
ptStartMoveArc = ptEndArc;
|
||
ptEndMoveArc = ptStartArc;
|
||
ptStartMoveDown = ptEndD;
|
||
ptEndMoveDown = ptStartD;
|
||
//m_pXDataMap->GetAt(HELB_EndWidth, dWidth);
|
||
}
|
||
|
||
double dMaxDiameter = dDiameterS > dDiameterE ? dDiameterS : dDiameterE;
|
||
double dHalfWidth = dMaxDiameter;
|
||
|
||
AcGePoint3dArray ptUpArr, ptArcArr, ptDownArr;
|
||
AcGeVector3d vtOff = (ptEndMoveUp - ptStartMoveUp).normalize();
|
||
ptUpArr.append(ptStartMoveUp + vtOff * dHalfWidth * 1.0/8.5); // 按照6.0比例
|
||
ptUpArr.append(ptStartMoveUp + vtOff * dHalfWidth * 1.0/3.1);
|
||
ptUpArr.append(ptStartMoveUp + vtOff * dHalfWidth * 1.0/1.62);
|
||
ptUpArr.append(ptStartMoveUp + vtOff * dHalfWidth);
|
||
|
||
vtOff = (ptEndMoveArc - ptStartMoveArc).normalize();
|
||
ptStartMoveArc.z = ptStartMoveUp.z;
|
||
ptArcArr.append(ptStartMoveArc + vtOff * dHalfWidth * 1.0/8.5);
|
||
ptArcArr.append(ptStartMoveArc + vtOff * dHalfWidth * 1.0/3.1);
|
||
ptArcArr.append(ptStartMoveArc + vtOff * dHalfWidth * 1.0/1.62);
|
||
ptArcArr.append(ptStartMoveArc + vtOff * dHalfWidth);
|
||
|
||
//AcGeVector3d vtPerl = (ptStartD - ptStartU).normalize();
|
||
vtOff = (ptEndMoveDown - ptStartMoveDown).normalize();
|
||
ptStartMoveDown.z = ptStartMoveUp.z;
|
||
ptDownArr.append(ptStartMoveDown + vtOff * dHalfWidth * 1.0/8.5);
|
||
ptDownArr.append(ptStartMoveDown + vtOff * dHalfWidth * 1.0/3.1);
|
||
ptDownArr.append(ptStartMoveDown + vtOff * dHalfWidth * 1.0/1.62);
|
||
ptDownArr.append(ptStartMoveDown + vtOff * dHalfWidth);
|
||
|
||
int i(0);
|
||
AcGePoint3d ptTemp;
|
||
for (i = 0; i < ptUpArr.length() && i < ptArcArr.length(); i++)
|
||
{
|
||
//ptTemp = ptUpArr[i] + vtPerl * dWidth;
|
||
el.ptGe[0] = ptUpArr[i];
|
||
el.ptGe[1] = ptArcArr[i];
|
||
el.ptGe[2] = ptDownArr[i];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
void ImpHvacElbow::DrawAllArcInWrap3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
DrawAllArcuate3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeAllArcInWrap2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
if (IsHorzAlignment())
|
||
{
|
||
return DrawAllArcuate2DHor(cplCurve,nType);
|
||
}
|
||
else if(IsVertAlignment())
|
||
{
|
||
return DrawAllArcuate2DVer(cplCurve,nType);
|
||
}
|
||
else if (IsInclineAlignment())
|
||
{
|
||
return MakeAllArcuate2DCurves(cplCurve,nType);
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void ImpHvacElbow::DrawAllArcWrap3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
DrawAllArcuate3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeAllArcWrap2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
if (IsHorzAlignment())
|
||
{
|
||
return DrawAllArcuate2DHor(cplCurve,nType);
|
||
}
|
||
else if(IsVertAlignment())
|
||
{
|
||
return DrawAllArcuate2DVer(cplCurve,nType);
|
||
}
|
||
else if (IsInclineAlignment())
|
||
{
|
||
return MakeAllArcuate2DCurves(cplCurve,nType);
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
//多节弯头圆形3D
|
||
void ImpHvacElbow::DrawSegmental3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dDiameter = MayAsMUnit(300),dPlusEdge = MayAsMUnit(50.0);
|
||
int nSectType = 2;
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine = 1;
|
||
int nSingleLine = 0;
|
||
int nSegments = 4;
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
m_pXDataMap->GetAt(HELB_Segments, nSegments);
|
||
m_pXDataMap->GetAt(HVAC_SectType,nSectType);
|
||
|
||
double dDiameterStart = MayAsMUnit(400.0);
|
||
double dDiameterEnd = MayAsMUnit(400.0);
|
||
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine,nSingleLine);
|
||
m_pXDataMap->GetAt(HELB_Diameter, dDiameterStart);
|
||
if (!m_pXDataMap->GetAt(HELB_EndDiameter, dDiameterEnd))
|
||
{
|
||
dDiameterEnd = dDiameterStart;
|
||
}
|
||
|
||
double dMaxWidth = dDiameterStart > dDiameterEnd ? dDiameterStart : dDiameterEnd;
|
||
|
||
if ((ptStart.distanceTo(ptCorner) - MayAsMUnit(50.0)) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
dDiameterStart *= 0.5;
|
||
dDiameterEnd *= 0.5;
|
||
|
||
if (nSegments < 2)
|
||
nSegments = 2;
|
||
double dMinDiffAng = GetMinDiffAngle();
|
||
int nColumns = (int)(PI * 2 / dMinDiffAng);
|
||
|
||
//计算半径偏移量
|
||
double dDiameterOffset = dDiameterEnd - dDiameterStart;
|
||
|
||
AcGePoint3d ptOnArc = ptCorner;
|
||
AcGePoint3d ptStartArc = ptStart;
|
||
AcGePoint3d ptEndArc = ptEnd;
|
||
if (!GetPtOnArcExt(ptStartArc, ptCorner, ptEndArc, ptCorner, ptOnArc, dPlusEdge))
|
||
{
|
||
//输出错误信息
|
||
acutPrintf(_T("\n无法生成弯头！"));
|
||
return;
|
||
}
|
||
|
||
AcGeCircArc3d circleArc;
|
||
circleArc.set(ptStartArc, ptOnArc, ptEndArc);
|
||
|
||
AcGePoint3d ptCenterArc = circleArc.center();
|
||
|
||
AcGeVector3d vtStartArc = ptStartArc - ptCenterArc;
|
||
AcGeVector3d vtEndArc = ptEndArc - ptCenterArc;
|
||
AcGeVector3d vtNormalArc = vtEndArc.crossProduct(vtStartArc);
|
||
vtStartArc.normalize();
|
||
vtEndArc.normalize();
|
||
vtNormalArc.normalize();
|
||
|
||
double dAngle = vtStartArc.angleTo(vtEndArc);
|
||
double dSegAngle = dAngle / nSegments;
|
||
|
||
//关键节点数组
|
||
AcGePoint3dArray arptKeys;
|
||
|
||
AcGePoint3d ptTemp;
|
||
double dDiameterTemp = MayAsMUnit(300.0);
|
||
|
||
//起始段
|
||
AcGeVector3d vtAxisStart = ptStart - ptStartArc;
|
||
|
||
// Lixl add 2011-2-12-02
|
||
vtStartArc = vtAxisStart.crossProduct(vtNormalArc);
|
||
vtStartArc.normalize();
|
||
|
||
//起始段前端
|
||
for (int iStart = 0; iStart < nColumns; iStart++)
|
||
{
|
||
ptTemp = ptStart + dDiameterStart * vtStartArc;
|
||
ptTemp.rotateBy(dMinDiffAng * iStart, vtAxisStart, ptStart);
|
||
arptKeys.append(ptTemp);
|
||
}
|
||
|
||
ptTemp = ptStart + dDiameterStart * vtStartArc;
|
||
arptKeys.append(ptTemp);
|
||
|
||
//起始段后端
|
||
for (int iStartArc = 0; iStartArc < nColumns; iStartArc++)
|
||
{
|
||
ptTemp = ptStartArc + dDiameterStart * vtStartArc;
|
||
ptTemp.rotateBy(dMinDiffAng * iStartArc, vtAxisStart, ptStartArc);
|
||
arptKeys.append(ptTemp);
|
||
}
|
||
|
||
ptTemp = ptStartArc + dDiameterStart * vtStartArc;
|
||
arptKeys.append(ptTemp);
|
||
|
||
//中间圆弧段
|
||
for (int iArc = 1; iArc < nSegments; iArc++)
|
||
{
|
||
dDiameterTemp = dDiameterStart + dDiameterOffset * iArc / nSegments;
|
||
AcGePoint3d ptStartArcTemp = ptStartArc;
|
||
AcGePoint3d ptOnArcTemp = ptStartArcTemp.rotateBy(-dSegAngle * iArc, vtNormalArc, ptCenterArc);
|
||
AcGeVector3d vtOnArcTemp = ptOnArcTemp - ptCenterArc;
|
||
AcGeVector3d vtOnArcAxis = vtOnArcTemp;
|
||
vtOnArcAxis.rotateBy(PI / 2, vtNormalArc);
|
||
vtOnArcTemp.normalize();
|
||
|
||
for (int i = 0; i < nColumns; i++)
|
||
{
|
||
ptTemp = ptOnArcTemp + dDiameterTemp * vtOnArcTemp;
|
||
ptTemp.rotateBy(dMinDiffAng * i, vtOnArcAxis, ptOnArcTemp);
|
||
arptKeys.append(ptTemp);
|
||
}
|
||
|
||
ptTemp = ptOnArcTemp + dDiameterTemp * vtOnArcTemp;
|
||
arptKeys.append(ptTemp);
|
||
}
|
||
|
||
//末尾段
|
||
AcGeVector3d vtAxisEnd = ptEndArc - ptEnd;
|
||
|
||
// Lixl add 2011-2-12-02
|
||
vtEndArc = vtAxisEnd.crossProduct(vtNormalArc);
|
||
vtEndArc.normalize();
|
||
|
||
//末尾段前端
|
||
for (int iEndArc = 0; iEndArc < nColumns; iEndArc++)
|
||
{
|
||
ptTemp = ptEndArc + dDiameterEnd * vtEndArc;
|
||
ptTemp.rotateBy(dMinDiffAng * iEndArc, vtAxisEnd, ptEndArc);
|
||
arptKeys.append(ptTemp);
|
||
}
|
||
|
||
ptTemp = ptEndArc + dDiameterEnd * vtEndArc;
|
||
arptKeys.append(ptTemp);
|
||
|
||
//末尾段后端
|
||
for (int iEnd = 0; iEnd < nColumns; iEnd++)
|
||
{
|
||
ptTemp = ptEnd + dDiameterEnd * vtEndArc;
|
||
ptTemp.rotateBy(dMinDiffAng * iEnd, vtAxisEnd, ptEnd);
|
||
arptKeys.append(ptTemp);
|
||
}
|
||
|
||
ptTemp = ptEnd + dDiameterEnd * vtEndArc;
|
||
arptKeys.append(ptTemp);
|
||
|
||
//生成三维网格
|
||
DrawMesh(mode,nSegments + 3, nColumns + 1, arptKeys.asArrayPtr());
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeSegmental2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
double dCenWidth = GetCentLineWidth();
|
||
if (IsHorzAlignment())
|
||
{
|
||
AcGePoint3dArray pts;
|
||
if (GetPtsSegmentalHor(pts))
|
||
{
|
||
int nLength = pts.length() - 5;
|
||
nLength = nLength / 2;
|
||
int i = 0;
|
||
|
||
AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
|
||
int nHasBaseLine = 1;
|
||
double dEndLineWidth = GetEndLineWidth();
|
||
//m_pXDataMap->GetAt(HVAC_BaseLayer, idBaseLayer);
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine, nHasBaseLine);
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeWidth;
|
||
//上弧
|
||
for (i = 0; i < nLength - 1; i++)
|
||
{
|
||
el.ptGe[0] = pts.at(i);
|
||
el.ptGe[1] = pts.at(i + 1);
|
||
el.ptGe[2] = pts.at(i + 1);
|
||
cplCurve.append(el);
|
||
}
|
||
//下弧
|
||
for (i = nLength; i < nLength * 2 - 1; i++)
|
||
{
|
||
el.ptGe[0] = pts.at(i);
|
||
el.ptGe[1] = pts.at(i + 1);
|
||
el.ptGe[2] = pts.at(i + 1);
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
//两端直线
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = pts.at(0);
|
||
el.ptGe[1] = pts.at(nLength);
|
||
el.ptGe[2] = pts.at(nLength);
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pts.at(nLength - 1);
|
||
el.ptGe[1] = pts.at(nLength * 2 - 1);
|
||
el.ptGe[2] = pts.at(nLength * 2 - 1);
|
||
cplCurve.append(el);
|
||
}
|
||
//中心线
|
||
if (1 == nType)
|
||
{
|
||
//中间的间隔线
|
||
if (!IsSingleLine())
|
||
{
|
||
for (i = 2; i <= nLength - 3; i ++)
|
||
{
|
||
el.idSubLay = idSideLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
el.ptGe[0] = pts.at(i);
|
||
el.ptGe[1] = pts.at(nLength + i);
|
||
el.ptGe[2] = pts.at(nLength + i);
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
|
||
if ((HasBaseLine() || IsSingleLine()))
|
||
{
|
||
el.idSubLay = idBaseLayer;
|
||
el.gsMark = -1;
|
||
if (IsSingleLine())
|
||
el.dWidth = dEdgeWidth;
|
||
else
|
||
el.dWidth = dCenWidth;
|
||
el.ptGe[0] = pts.at(nLength * 2);
|
||
el.ptGe[1] = pts.at(nLength * 2 + 1);
|
||
el.ptGe[2] = pts.at(nLength * 2 + 1);
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pts.at(nLength * 2 + 1);
|
||
el.ptGe[1] = pts.at(nLength * 2 + 2);
|
||
el.ptGe[2] = pts.at(nLength * 2 + 3);
|
||
cplCurve.append(el);
|
||
el.ptGe[0] = pts.at(nLength * 2 + 3);
|
||
el.ptGe[1] = pts.at(nLength * 2 + 4);
|
||
el.ptGe[2] = pts.at(nLength * 2 + 4);
|
||
cplCurve.append(el);
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if(IsVertAlignment())
|
||
{
|
||
DrawAllArcuate2DVer(cplCurve,nType);
|
||
}
|
||
else if(IsInclineAlignment())
|
||
{
|
||
return MakeSegmental2DInc(cplCurve,nType);
|
||
}
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
// 分段拟合弯头,圆形,倾斜二维绘制
|
||
// 待完成
|
||
BOOL ImpHvacElbow::MakeSegmental2DInc( AecComplexCurve& cplCurve,int &nType ) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
if (eCircle != eSectType)
|
||
return FALSE;
|
||
|
||
// 点
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
// 端口宽
|
||
double dDiameter = MayAsMUnit(300),dStartWidth = MayAsMUnit(300),dEndWidth = MayAsMUnit(100),dPlusEdge = MayAsMUnit(50.0);
|
||
m_pXDataMap->GetAt(HELB_Diameter,dDiameter);
|
||
m_pXDataMap->GetAt(HELB_StartWidth,dStartWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth,dEndWidth);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
|
||
|
||
BOOL bSingleLine(FALSE);
|
||
BOOL bHasBaseLine(FALSE);
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine, bSingleLine);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLine);
|
||
|
||
// 线宽
|
||
double dEdgeLineWidth(0), dCenLineWidth(0), dEndLineWidth(0);
|
||
dEdgeLineWidth = GetEdgeLineWidth();
|
||
dEndLineWidth = GetEndLineWidth();
|
||
dCenLineWidth = GetCentLineWidth();
|
||
|
||
AcDbObjectId idEndLayer;
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
|
||
|
||
AcGePoint3dArray arptu,arptd;
|
||
if (!GetPrjPts(arptu, arptd))
|
||
return FALSE;
|
||
|
||
// 中心线上的点数组
|
||
AcGePoint3dArray arCen;
|
||
AcGePoint3d ptCen;
|
||
arCen.append(ptStart);
|
||
for (int i = 1; i <= arptu.length()-2; i++)
|
||
{
|
||
Midpoint(arptu[i], arptd[i], ptCen);
|
||
arCen.append(ptCen);
|
||
}
|
||
arCen.append(ptEnd);
|
||
|
||
AecEqui::AecCurveElement el;
|
||
memset(&el, 0, sizeof(AecEqui::AecCurveElement));
|
||
|
||
// 外轮廓
|
||
if (0 == nType)
|
||
{
|
||
el.dWidth = dEdgeLineWidth;
|
||
|
||
// 单线模式
|
||
if (bSingleLine)
|
||
{
|
||
for (int i = 0; i < arCen.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arptu[i];
|
||
el.ptGe[1] = arptu[i+1];
|
||
el.ptGe[2] = arptu[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
int i(0);
|
||
for (; i < arptu.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arptu[i];
|
||
el.ptGe[1] = arptu[i+1];
|
||
el.ptGe[2] = arptu[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
for (i = 0; i < arptd.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arptd[i];
|
||
el.ptGe[1] = arptd[i+1];
|
||
el.ptGe[2] = arptd[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
AcGeVector3d vtStr, vtEnd, vtNor, vtZAxis;
|
||
vtStr = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtNor = vtStr.crossProduct(vtEnd);
|
||
|
||
// 计算弯头截面的弧线(端线)
|
||
AcGePoint3dArray arPtS, arPtE;
|
||
vtZAxis = GetUcsZvt();
|
||
AcDbPolyline DbLine;
|
||
|
||
// 方向要从端点指向拐点
|
||
vtStr = - vtStr;
|
||
vtEnd = - vtEnd;
|
||
if (ptStart.z > ptCorner.z)
|
||
;
|
||
else
|
||
vtStr = -vtStr;
|
||
int iRes = GetEllipsePtsFromCircle(arPtS, ptStart, dStartWidth, vtStr, vtZAxis, DbLine, vtStr); //Lixl add 2011-11-23
|
||
DbLine.reset(Adesk::kFalse, iRes);
|
||
|
||
if (ptEnd.z > ptCorner.z)
|
||
;
|
||
else
|
||
vtEnd = -vtEnd;
|
||
iRes = GetEllipsePtsFromCircle(arPtE, ptEnd, dEndWidth, vtEnd, vtZAxis, DbLine, vtEnd); //Lixl add 2011-11-23
|
||
|
||
// 边线
|
||
el.idSubLay = idEndLayer;
|
||
el.dWidth = dEndLineWidth;
|
||
|
||
for (i = 0; i < arPtS.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arPtS[i];
|
||
el.ptGe[1] = arPtS[i+1];
|
||
el.ptGe[2] = arPtS[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
|
||
for (i = 0; i < arPtE.length()-1; i++)
|
||
{
|
||
el.ptGe[0] = arPtE[i];
|
||
el.ptGe[1] = arPtE[i+1];
|
||
el.ptGe[2] = arPtE[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
// 中心线
|
||
else if (1 == nType)
|
||
{
|
||
if (bHasBaseLine)
|
||
{
|
||
el.gsMark = -1;
|
||
el.dWidth = dCenLineWidth;
|
||
|
||
for (i = 0; i <= arCen.length()-2; i++)
|
||
{
|
||
el.ptGe[0] = arCen[i];
|
||
el.ptGe[1] = arCen[i+1];
|
||
el.ptGe[2] = arCen[i+1];
|
||
cplCurve.append(el);
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
void ImpHvacElbow::DrawIncline3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dDiameter = MayAsMUnit(300.0);
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
|
||
//==========================================
|
||
double dThickA = MayAsMUnit(50.0);
|
||
double dThickB = MayAsMUnit(50.0);
|
||
|
||
AcGePoint3d ptCorStart;
|
||
AcGePoint3d ptCorEnd;
|
||
|
||
double dStaWidth = MayAsMUnit(150.0);
|
||
double dEndWidth = MayAsMUnit(150.0);
|
||
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine;
|
||
|
||
//=====================================================
|
||
m_pXDataMap->GetAt(HELB_Thick,dThickA);
|
||
if (!m_pXDataMap->GetAt(HELB_EndThick, dThickB))
|
||
{
|
||
dThickB = dThickA;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_StartWidth,dStaWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth,dEndWidth);
|
||
//m_pXDataMap->GetAt(HVAC_PlusEdge,dPlusEdge);
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
|
||
//BEGIN==========================================
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorStart);
|
||
if (!m_pXDataMap->GetAt(HELB_AssisCornerPoint, ptCorEnd))
|
||
{
|
||
ptCorEnd = ptCorStart;
|
||
}
|
||
|
||
double dMaxWidth = dStaWidth > dEndWidth ? dStaWidth : dEndWidth;
|
||
|
||
if ((ptStart.distanceTo(ptCorStart) - MayAsMUnit(50.0)) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eIncline;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
|
||
//内斜线弯头弯曲角度为90度
|
||
const double dAngle = PI / 2;
|
||
|
||
AcGeVector3d vtCorStartCom = ptCorStart.asVector();
|
||
AcGeVector3d vtCorEndCom = ptCorEnd.asVector();
|
||
AcGeVector3d vtCornerCom = (vtCorStartCom + vtCorEndCom) / 2;
|
||
ptCorner = AcGePoint3d::kOrigin + vtCornerCom;
|
||
|
||
AcGePoint3d ptOnArc = ptCorner;
|
||
AcGePoint3d ptStartArc = ptStart;
|
||
AcGePoint3d ptEndArc = ptEnd;
|
||
|
||
//计算出中心线弧线段的起点、中点和终点
|
||
//GetPtOnArc(ptStartArc, ptOnArc, ptEndArc, dPlusEdge);
|
||
GetPtOnArcExt(ptStartArc, ptCorStart, ptEndArc, ptCorEnd, ptOnArc, dPlusEdge);
|
||
|
||
//构建中心圆弧并求得圆心
|
||
AcGeCircArc3d cirArc(ptStartArc, ptOnArc, ptEndArc);
|
||
AcGePoint3d ptCen = cirArc.center();
|
||
|
||
//计算弯头平面矢量和弧线平面矢量
|
||
AcGeVector3d vtStart = ptStart - ptCorStart;
|
||
AcGeVector3d vtEnd = ptEnd - ptCorEnd;
|
||
AcGeVector3d vtNormal = vtStart.crossProduct(vtEnd);
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtNormal.normalize();
|
||
|
||
AcGeVector3d vtStartArc = ptStartArc - ptCen;
|
||
AcGeVector3d vtEndArc = ptEndArc - ptCen;
|
||
AcGeVector3d vtNormalArc = vtEndArc.crossProduct(vtStartArc);
|
||
vtStartArc.normalize();
|
||
vtEndArc.normalize();
|
||
vtNormalArc.normalize();
|
||
|
||
//求得弯头头部和尾部的径向向量
|
||
vtStart.rotateBy(-PI / 2, vtNormal);
|
||
vtStart.normalize();
|
||
|
||
vtEnd.rotateBy(PI / 2, vtNormal);
|
||
vtEnd.normalize();
|
||
|
||
//生成中部拐点
|
||
AcGePoint3d ptCorU = ptCorner + vtNormal * (dThickA + dThickB) / 4 + vtStart * dStaWidth / 2 + vtEnd * dEndWidth / 2;
|
||
AcGePoint3d ptCorD = ptCorner - vtNormal * (dThickA + dThickB) / 4 + vtStart * dStaWidth / 2 + vtEnd * dEndWidth / 2;
|
||
|
||
//关键节点数组
|
||
AcGePoint3dArray arptKeys;
|
||
|
||
AcGePoint3d ptTemp[5];
|
||
|
||
//生成弯头头部
|
||
ptTemp[0] = ptStart + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[1] = ptStart - vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[2] = ptStart - vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[3] = ptStart + vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[4] = ptStart + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
|
||
for(int i = 0; i < 5; i++)
|
||
{
|
||
arptKeys.append(ptTemp[i]);
|
||
}
|
||
|
||
ptTemp[0] = ptStartArc + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[1] = ptStartArc - vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[2] = ptStartArc - vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[3] = ptStartArc + vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[4] = ptStartArc + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
|
||
for(int j = 0; j < 5; j++)
|
||
{
|
||
arptKeys.append(ptTemp[j]);
|
||
}
|
||
|
||
//生成弯头中部
|
||
ptTemp[0] = ptCorU;
|
||
ptTemp[1] = ptCorD;
|
||
ptTemp[4] = ptCorU;
|
||
|
||
for(int u = 0; u < 5; u++)
|
||
{
|
||
arptKeys.append(ptTemp[u]);
|
||
}
|
||
|
||
ptTemp[2] = ptEndArc - vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[3] = ptEndArc + vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
|
||
for(int d = 0; d < 5; d++)
|
||
{
|
||
arptKeys.append(ptTemp[d]);
|
||
}
|
||
|
||
//生成弯头尾部
|
||
ptTemp[0] = ptEndArc + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[1] = ptEndArc - vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[2] = ptEndArc - vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[3] = ptEndArc + vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[4] = ptEndArc + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
|
||
for(int k = 0; k < 5; k++)
|
||
{
|
||
arptKeys.append(ptTemp[k]);
|
||
}
|
||
|
||
ptTemp[0] = ptEnd + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[1] = ptEnd - vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[2] = ptEnd - vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[3] = ptEnd + vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[4] = ptEnd + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
|
||
for(int l = 0; l < 5; l++)
|
||
{
|
||
arptKeys.append(ptTemp[l]);
|
||
}
|
||
|
||
//添加关键节点并绘图
|
||
DrawMesh(mode,6, 5, arptKeys.asArrayPtr());
|
||
//====================================================================================
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeIncline2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dThick = MayAsMUnit(100.0),dDiameter = MayAsMUnit(300),dStartWidth = MayAsMUnit(300),dEndWidth = MayAsMUnit(100),dPlusEdge = MayAsMUnit(50.0);
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine = 1;
|
||
int nSingleLine = 0;
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
m_pXDataMap->GetAt(HELB_Diameter, dDiameter);
|
||
m_pXDataMap->GetAt(HELB_Thick, dThick);
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth, dEndWidth);
|
||
//m_pXDataMap->GetAt(HVAC_PlusEdge,dPlusEdge);
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine,nSingleLine);
|
||
|
||
double dEndThick = dThick;
|
||
m_pXDataMap->GetAt(HELB_EndThick, dEndThick);
|
||
|
||
if (IsHorzAlignment())
|
||
{
|
||
ptCorner.z = ptEnd.z = ptStart.z;
|
||
|
||
double dMaxWidth = dStartWidth > dEndWidth ? dStartWidth : dEndWidth;
|
||
|
||
if ((ptStart.distanceTo(ptCorner) - 50.0) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
dThick *= 0.5;
|
||
dEndThick *= 0.5;
|
||
|
||
return GetInclineCplCurveHor(cplCurve,nType,ptStart,ptCorner,ptEnd,dPlusEdge,dStartWidth,dEndWidth);
|
||
}
|
||
else if(IsVertAlignment())
|
||
{
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
dThick *= 0.5;
|
||
dEndThick *= 0.5;
|
||
|
||
//return GetAllArcuateCplCurveVerRec(cplCurve,nType,ptStart,ptCorner,ptEnd,dPlusEdge,dStartWidth,dEndWidth,dThick);
|
||
return GetAllArcuateCplCurveVerRec(cplCurve, nType, ptStart, ptCorner, ptEnd, dPlusEdge, dStartWidth, dEndWidth, dThick, dEndThick);
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
void ImpHvacElbow::DrawInclineWrap3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
DrawIncline3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeInclineWrap2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
MakeIncline2DCurves(cplCurve,nType);
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
void ImpHvacElbow::DrawInclineBoard3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
DrawIncline3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeInclineBoard2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
return MakeIncline2DCurves(cplCurve,nType);
|
||
}
|
||
|
||
void ImpHvacElbow::DrawInclineLead3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
DrawIncline3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeInclineLead2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
MakeIncline2DCurves(cplCurve,nType);
|
||
return cplCurve.length() > 0;
|
||
}
|
||
|
||
void ImpHvacElbow::DrawArcuate3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dDiameter = MayAsMUnit(300.0);
|
||
double dPlusEdge = MayAsMUnit(50.0);
|
||
|
||
double dThickA = MayAsMUnit(50.0);
|
||
double dThickB = MayAsMUnit(50.0);
|
||
|
||
AcGePoint3d ptCorStart;
|
||
AcGePoint3d ptCorEnd;
|
||
|
||
double dStaWidth = MayAsMUnit(150.0);
|
||
double dEndWidth = MayAsMUnit(150.0);
|
||
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine;
|
||
|
||
m_pXDataMap->GetAt(HELB_Thick, dThickA);
|
||
if (!m_pXDataMap->GetAt(HELB_EndThick, dThickB))
|
||
{
|
||
dThickB = dThickA;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_StartWidth,dStaWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth,dEndWidth);
|
||
//m_pXDataMap->GetAt(HVAC_PlusEdge,dPlusEdge);
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorStart);
|
||
if (!m_pXDataMap->GetAt(HELB_AssisCornerPoint, ptCorEnd))
|
||
{
|
||
ptCorEnd = ptCorStart;
|
||
}
|
||
|
||
double dMaxWidth = dStaWidth > dEndWidth ? dStaWidth : dEndWidth;
|
||
|
||
if ((ptStart.distanceTo(ptCorStart) - MayAsMUnit(50.0) ) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eArcuate;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
|
||
//内圆弧弯头弯曲角度为90度
|
||
const double dAngle = PI / 2;
|
||
|
||
double dMinDiffAng = GetMinDiffAngle();
|
||
int nRows = (int)(PI * 2 / dMinDiffAng);
|
||
|
||
//生成拐点
|
||
AcGeVector3d vtCorStartCom = ptCorStart.asVector();
|
||
AcGeVector3d vtCorEndCom = ptCorEnd.asVector();
|
||
AcGeVector3d vtCornerCom = (vtCorStartCom + vtCorEndCom) / 2;
|
||
ptCorner = AcGePoint3d::kOrigin + vtCornerCom;
|
||
|
||
AcGePoint3d ptOnArc = ptCorner;
|
||
AcGePoint3d ptStartArc = ptStart;
|
||
AcGePoint3d ptEndArc = ptEnd;
|
||
|
||
//计算出中心线弧线段的起点、中点和终点
|
||
//GetPtOnArc(ptStartArc, ptOnArc, ptEndArc, dPlusEdge);
|
||
GetPtOnArcExt(ptStartArc, ptCorStart, ptEndArc, ptCorEnd, ptOnArc, dPlusEdge);
|
||
|
||
//构建中心圆弧并求得圆心
|
||
AcGeCircArc3d cirArc(ptStartArc, ptOnArc, ptEndArc);
|
||
AcGePoint3d ptCen = cirArc.center();
|
||
|
||
//计算弯头平面矢量和弧线平面矢量
|
||
AcGeVector3d vtStart = ptStart - ptCorStart;
|
||
AcGeVector3d vtEnd = ptEnd - ptCorEnd;
|
||
AcGeVector3d vtNormal = vtStart.crossProduct(vtEnd);
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtNormal.normalize();
|
||
|
||
AcGeVector3d vtStartArc = ptStartArc - ptCen;
|
||
AcGeVector3d vtEndArc = ptEndArc - ptCen;
|
||
AcGeVector3d vtNormalArc = vtEndArc.crossProduct(vtStartArc);
|
||
vtStartArc.normalize();
|
||
vtEndArc.normalize();
|
||
vtNormalArc.normalize();
|
||
|
||
vtStart.rotateBy(-PI / 2, vtNormal);
|
||
vtStart.normalize();
|
||
|
||
vtEnd.rotateBy(PI / 2, vtNormal);
|
||
vtEnd.normalize();
|
||
|
||
//生成中部拐点
|
||
AcGePoint3d ptCorU = ptCorner + vtNormal * (dThickA + dThickB) / 4 + vtStart * dStaWidth / 2 + vtEnd * dEndWidth / 2;
|
||
AcGePoint3d ptCorD = ptCorner - vtNormal * (dThickA + dThickB) / 4 + vtStart * dStaWidth / 2 + vtEnd * dEndWidth / 2;
|
||
|
||
//构建弧线段
|
||
AcGeVector3d vtCor = ptOnArc - ptCen;
|
||
vtCor.normalize();
|
||
|
||
//计算边线圆弧起点、圆上点、终点、圆心和平面法向量
|
||
AcGePoint3d ptStartArcU = ptStartArc + vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
AcGePoint3d ptStartArcD = ptStartArc - vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
AcGePoint3d ptEndArcU = ptEndArc + vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
AcGePoint3d ptEndArcD = ptEndArc - vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
AcGePoint3d ptOnArcU = ptOnArc + vtNormal * (dThickA + dThickB) / 4 - vtCor * (dStaWidth + dEndWidth) / 4;
|
||
AcGePoint3d ptOnArcD = ptOnArc - vtNormal * (dThickA + dThickB) / 4 - vtCor * (dStaWidth + dEndWidth) / 4;
|
||
|
||
AcGeCircArc3d cirU(ptStartArcU, ptOnArcU, ptEndArcU);
|
||
AcGePoint3d ptCenU = cirU.center();
|
||
AcGeVector3d vtNormalU = cirU.normal();
|
||
|
||
AcGeCircArc3d cirD(ptStartArcD, ptOnArcD, ptEndArcD);
|
||
AcGePoint3d ptCenD = cirD.center();
|
||
AcGeVector3d vtNormalD = cirD.normal();
|
||
|
||
//关键节点数组
|
||
AcGePoint3dArray arptKeys;
|
||
|
||
AcGePoint3d ptTemp[5];
|
||
|
||
//生成弯头头部
|
||
ptTemp[0] = ptStart + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[1] = ptStart - vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[2] = ptStart - vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[3] = ptStart + vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[4] = ptStart + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
for(int i = 0; i < 5; i++)
|
||
{
|
||
arptKeys.append(ptTemp[i]);
|
||
}
|
||
|
||
ptTemp[0] = ptStartArc + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[1] = ptStartArc - vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[2] = ptStartArc - vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[3] = ptStartArc + vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[4] = ptStartArc + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
for(int j = 0; j < 5; j++)
|
||
{
|
||
arptKeys.append(ptTemp[j]);
|
||
}
|
||
|
||
//生成弯头中部
|
||
for(int m = 1; m < nRows; m++)
|
||
{
|
||
AcGePoint3d ptBufU = ptStartArcU;
|
||
AcGePoint3d ptBufD = ptStartArcD;
|
||
|
||
arptKeys.append(ptCorU);
|
||
arptKeys.append(ptCorD);
|
||
|
||
AcGeVector3d vtHead = ptEndArcD - ptCenD;
|
||
AcGeVector3d vtTail = ptStartArcD - ptCenD;
|
||
double dAngleFlag = vtTail.angleTo(vtHead, vtNormalD);
|
||
BOOL bBreak = (dMinDiffAng * m > dAngleFlag) || (fabs(dMinDiffAng * m / dAngleFlag - 1) < 1e-10);
|
||
arptKeys.append(bBreak ? ptEndArcD : ptBufD.rotateBy(dMinDiffAng * m, vtNormalD, ptCenD));
|
||
|
||
vtHead = ptEndArcU - ptCenU;
|
||
vtTail = ptStartArcU - ptCenU;
|
||
dAngleFlag = vtTail.angleTo(vtHead, vtNormalU);
|
||
bBreak = (dMinDiffAng * m > dAngleFlag) || (fabs(dMinDiffAng * m /dAngleFlag - 1) < 1e-10);
|
||
arptKeys.append(bBreak ? ptEndArcU : ptBufU.rotateBy(dMinDiffAng * m, vtNormalU, ptCenU));
|
||
|
||
arptKeys.append(ptCorU);
|
||
}
|
||
|
||
//生成弯头尾部
|
||
ptTemp[0] = ptEndArc + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[1] = ptEndArc - vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[2] = ptEndArc - vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[3] = ptEndArc + vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[4] = ptEndArc + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
|
||
for(int k = 0; k < 5; k++)
|
||
{
|
||
arptKeys.append(ptTemp[k]);
|
||
}
|
||
|
||
ptTemp[0] = ptEnd + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[1] = ptEnd - vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[2] = ptEnd - vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[3] = ptEnd + vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[4] = ptEnd + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
|
||
for(int l = 0; l < 5; l++)
|
||
{
|
||
arptKeys.append(ptTemp[l]);
|
||
}
|
||
DrawMesh(mode,nRows + 3, 5, arptKeys.asArrayPtr());
|
||
//===========================================================================================
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeArcuate2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dThick = MayAsMUnit(100.0),dDiameter = MayAsMUnit(300),dStartWidth = MayAsMUnit(300),dEndWidth = MayAsMUnit(100),dPlusEdge = MayAsMUnit(50.0);
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine = 1;
|
||
int nSingleLine = 0;
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
m_pXDataMap->GetAt(HELB_Diameter, dDiameter);
|
||
m_pXDataMap->GetAt(HELB_Thick, dThick);
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine,nSingleLine);
|
||
|
||
double dEndThick =dThick;
|
||
m_pXDataMap->GetAt(HELB_EndThick, dEndThick);
|
||
|
||
if (IsHorzAlignment())
|
||
{
|
||
ptCorner.z = ptEnd.z = ptStart.z;
|
||
|
||
double dMaxWidth = dStartWidth > dEndWidth ? dStartWidth : dEndWidth;
|
||
|
||
if ((ptStart.distanceTo(ptCorner) - MayAsMUnit(50.0)) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
dThick *= 0.5;
|
||
dEndThick *= 0.5;
|
||
|
||
return GetArcuateCplCurveHor(cplCurve,nType,ptStart,ptCorner,ptEnd,dPlusEdge,dStartWidth,dEndWidth);
|
||
}
|
||
else if(IsVertAlignment())
|
||
{
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
dThick *= 0.5;
|
||
dEndThick *= 0.5;
|
||
return GetAllArcuateCplCurveVerRec(cplCurve, nType, ptStart, ptCorner, ptEnd, dPlusEdge, dStartWidth, dEndWidth, dThick, dEndThick);
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void ImpHvacElbow::DrawArcuateWrap3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
DrawArcuate3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeArcuateWrap2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
return MakeArcuate2DCurves(cplCurve, nType);
|
||
}
|
||
|
||
void ImpHvacElbow::DrawArcuateBoard3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
DrawArcuate3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeArcuateBoard2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
return MakeArcuate2DCurves(cplCurve, nType);
|
||
}
|
||
|
||
void ImpHvacElbow::DrawArcuateSieve3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
DrawArcuate3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeArcuateSieve2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
return MakeArcuate2DCurves(cplCurve, nType);
|
||
}
|
||
|
||
void ImpHvacElbow::DrawArcuateLead3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
DrawArcuate3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeArcuateLead2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
return MakeArcuate2DCurves(cplCurve, nType);
|
||
}
|
||
|
||
void ImpHvacElbow::DrawAllOrtho3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dDiameter = MayAsMUnit(300.0);
|
||
double dPlusEdge = MayAsMUnit(50);
|
||
|
||
double dThickA = MayAsMUnit(50.0);
|
||
double dThickB = MayAsMUnit(50.0);
|
||
|
||
AcGePoint3d ptCorStart;
|
||
AcGePoint3d ptCorEnd;
|
||
|
||
double dStaWidth = MayAsMUnit(150.0);
|
||
double dEndWidth = MayAsMUnit(150.0);
|
||
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine;
|
||
|
||
m_pXDataMap->GetAt(HELB_Thick,dThickA);
|
||
if (!m_pXDataMap->GetAt(HELB_EndThick, dThickB))
|
||
{
|
||
dThickB = dThickA;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_StartWidth,dStaWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth,dEndWidth);
|
||
//m_pXDataMap->GetAt(HVAC_PlusEdge,dPlusEdge);
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorStart);
|
||
if(!m_pXDataMap->GetAt(HELB_AssisCornerPoint, ptCorEnd))
|
||
{
|
||
ptCorEnd = ptCorStart;
|
||
}
|
||
|
||
double dMaxWidth = dStaWidth > dEndWidth ? dStaWidth : dEndWidth;
|
||
|
||
if ((ptStart.distanceTo(ptCorStart) - dPlusEdge) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eIncline;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
|
||
//双直角弯头弯曲角度固定为90度
|
||
const double dAngle = PI / 2;
|
||
|
||
AcGeVector3d vtCorStartCom = ptCorStart.asVector();
|
||
AcGeVector3d vtCorEndCom = ptCorEnd.asVector();
|
||
AcGeVector3d vtCornerCom = (vtCorStartCom + vtCorEndCom) / 2;
|
||
ptCorner = AcGePoint3d::kOrigin + vtCornerCom;
|
||
|
||
AcGePoint3d ptOnArc = ptCorner;
|
||
AcGePoint3d ptStartArc = ptStart;
|
||
AcGePoint3d ptEndArc = ptEnd;
|
||
|
||
//计算出中心线弧线段的起点、中点和终点
|
||
//GetPtOnArc(ptStartArc, ptOnArc, ptEndArc, dPlusEdge);
|
||
GetPtOnArcExt(ptStartArc, ptCorStart, ptEndArc, ptCorEnd, ptOnArc, dPlusEdge);
|
||
|
||
//构建中心圆弧并求得圆心
|
||
AcGeCircArc3d cirArc(ptStartArc, ptOnArc, ptEndArc);
|
||
AcGePoint3d ptCen = cirArc.center();
|
||
|
||
//计算弯头平面矢量和弧线平面矢量
|
||
AcGeVector3d vtStart = ptStart - ptCorStart;
|
||
AcGeVector3d vtEnd = ptEnd - ptCorEnd;
|
||
AcGeVector3d vtNormal = vtStart.crossProduct(vtEnd);
|
||
vtStart.normalize();
|
||
vtEnd.normalize();
|
||
vtNormal.normalize();
|
||
|
||
AcGeVector3d vtStartArc = ptStartArc - ptCen;
|
||
AcGeVector3d vtEndArc = ptEndArc - ptCen;
|
||
AcGeVector3d vtNormalArc = vtEndArc.crossProduct(vtStartArc);
|
||
vtStartArc.normalize();
|
||
vtEndArc.normalize();
|
||
vtNormalArc.normalize();
|
||
|
||
vtStart.rotateBy(-PI / 2, vtNormal);
|
||
vtStart.normalize();
|
||
|
||
vtEnd.rotateBy(PI / 2, vtNormal);
|
||
vtEnd.normalize();
|
||
|
||
//计算中部四个拐点
|
||
AcGePoint3d ptCorU = ptCorner + vtNormal * (dThickA + dThickB) / 4 + vtStart * dStaWidth / 2 + vtEnd * dEndWidth / 2;
|
||
AcGePoint3d ptCorD = ptCorner - vtNormal * (dThickA + dThickB) / 4 + vtStart * dStaWidth / 2 + vtEnd * dEndWidth / 2;
|
||
AcGePoint3d ptCorUL = ptCorner + vtNormal * (dThickA + dThickB) / 4 - vtStart * dStaWidth / 2 - vtEnd * dEndWidth / 2;
|
||
AcGePoint3d ptCorDL = ptCorner - vtNormal * (dThickA + dThickB) / 4 - vtStart * dStaWidth / 2 - vtEnd * dEndWidth / 2;
|
||
|
||
//关键节点数组
|
||
AcGePoint3dArray arptKeys;
|
||
|
||
AcGePoint3d ptTemp[5];
|
||
|
||
//生成弯头头部
|
||
ptTemp[0] = ptStart + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[1] = ptStart - vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[2] = ptStart - vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[3] = ptStart + vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[4] = ptStart + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
|
||
for(int i = 0; i < 5; i++)
|
||
{
|
||
arptKeys.append(ptTemp[i]);
|
||
}
|
||
|
||
ptTemp[0] = ptStartArc + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[1] = ptStartArc - vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
ptTemp[2] = ptStartArc - vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[3] = ptStartArc + vtNormal * dThickA / 2 - vtStart * dStaWidth / 2;
|
||
ptTemp[4] = ptStartArc + vtNormal * dThickA / 2 + vtStart * dStaWidth / 2;
|
||
|
||
for(int j = 0; j < 5; j++)
|
||
{
|
||
arptKeys.append(ptTemp[j]);
|
||
}
|
||
|
||
//生成弯头中部
|
||
ptTemp[0] = ptCorU;
|
||
ptTemp[1] = ptCorD;
|
||
ptTemp[2] = ptCorDL;
|
||
ptTemp[3] = ptCorUL;
|
||
ptTemp[4] = ptCorU;
|
||
|
||
for(int u = 0; u < 5; u++)
|
||
{
|
||
arptKeys.append(ptTemp[u]);
|
||
}
|
||
|
||
//生成弯头尾部
|
||
ptTemp[0] = ptEndArc + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[1] = ptEndArc - vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[2] = ptEndArc - vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[3] = ptEndArc + vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[4] = ptEndArc + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
|
||
for(int k = 0; k < 5; k++)
|
||
{
|
||
arptKeys.append(ptTemp[k]);
|
||
}
|
||
|
||
ptTemp[0] = ptEnd + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[1] = ptEnd - vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
ptTemp[2] = ptEnd - vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[3] = ptEnd + vtNormal * dThickB / 2 - vtEnd * dEndWidth / 2;
|
||
ptTemp[4] = ptEnd + vtNormal * dThickB / 2 + vtEnd * dEndWidth / 2;
|
||
|
||
for(int l = 0; l < 5; l++)
|
||
{
|
||
arptKeys.append(ptTemp[l]);
|
||
}
|
||
DrawMesh(mode,5, 5, arptKeys.asArrayPtr());
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeAllOrtho2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dThick = MayAsMUnit(100.0),dDiameter = MayAsMUnit(300),dStartWidth = (300),dEndWidth = MayAsMUnit(100),dPlusEdge = MayAsMUnit(50.0);
|
||
AcDbObjectId idLayer;
|
||
int nBaseLine = 1;
|
||
int nSingleLine = 0;
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
m_pXDataMap->GetAt(HELB_Diameter, dDiameter);
|
||
m_pXDataMap->GetAt(HELB_Thick, dThick);
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HELB_StartPoint,ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint,ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint,ptEnd);
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine,nBaseLine);
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine,nSingleLine);
|
||
|
||
double dEndThick = dThick;
|
||
m_pXDataMap->GetAt(HELB_EndThick, dEndThick);
|
||
|
||
if (IsHorzAlignment())
|
||
{
|
||
ptCorner.z = ptEnd.z = ptStart.z;
|
||
|
||
double dMaxWidth = dStartWidth > dEndWidth ? dStartWidth : dEndWidth;
|
||
|
||
if ((ptStart.distanceTo(ptCorner) - dPlusEdge) - dMaxWidth / 2 < -1e-6)
|
||
{
|
||
dPlusEdge = 0.1;
|
||
}
|
||
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
dThick *= 0.5;
|
||
dEndThick *= 0.5;
|
||
|
||
return GetAllOrthoCplCurveHor(cplCurve,nType,ptStart,ptCorner,ptEnd,dPlusEdge,dStartWidth,dEndWidth);
|
||
}
|
||
else if(IsVertAlignment())
|
||
{
|
||
dStartWidth *= 0.5;
|
||
dEndWidth *= 0.5;
|
||
dThick *= 0.5;
|
||
dEndThick *= 0.5;
|
||
return GetAllArcuateCplCurveVerRec(cplCurve, nType, ptStart, ptCorner, ptEnd, dPlusEdge, dStartWidth, dEndWidth, dThick, dEndThick);
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void ImpHvacElbow::DrawOrthoWrap3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
DrawAllOrtho3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeOrthoWrap2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
return MakeAllOrtho2DCurves(cplCurve,nType);
|
||
}
|
||
|
||
void ImpHvacElbow::DrawOrthoLead3d(AcGiDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
DrawAllOrtho3d(mode);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::MakeOrthoLead2DCurves(AecComplexCurve& cplCurve,int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
return MakeAllOrtho2DCurves(cplCurve,nType);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::GetIntersectWith(AcGePoint3d &pt1,AcGePoint3d &pt2,AcGeVector3d &vt1,AcGeVector3d &vt2,AcGePoint3d &ptIntersect) const
|
||
{
|
||
AcGeLine3d line1,line2;
|
||
line1.set(pt1,vt1);
|
||
line2.set(pt2,vt2);
|
||
return line1.intersectWith(line2, ptIntersect);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::GetPtOnArc(AcGePoint3d &ptStart,AcGePoint3d &ptCorner,AcGePoint3d &ptEnd,double &dPlusEdge) const
|
||
{
|
||
AcGeVector3d vtStr,vtEnd,vtCor,vtNor;
|
||
AcGePoint3d ptGeCen;
|
||
|
||
AcGePoint3d ptCorStart = ptCorner;
|
||
ptCorStart.z = ptStart.z;
|
||
vtStr = ptStart - ptCorStart;
|
||
|
||
AcGePoint3d ptCorEnd = ptCorner;
|
||
ptCorEnd.z = ptEnd.z;
|
||
vtEnd = ptEnd - ptCorEnd;
|
||
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
vtNor = vtStr.crossProduct(vtEnd);
|
||
ptStart = ptStart - vtStr * dPlusEdge;
|
||
ptEnd = ptEnd - vtEnd * dPlusEdge;
|
||
vtStr.rotateBy(PI * 0.5,vtNor);
|
||
vtEnd.rotateBy(PI * 0.5,vtNor);
|
||
|
||
//================================================================
|
||
AcGePoint3d ptStartTemp = ptStart;
|
||
ptStartTemp.z = ptCorner.z;
|
||
|
||
AcGePoint3d ptEndTemp = ptEnd;
|
||
ptEndTemp.z = ptCorner.z;
|
||
|
||
if(!GetIntersectWith(ptStartTemp,ptEndTemp,vtStr,vtEnd,ptGeCen))
|
||
return FALSE;
|
||
|
||
vtCor = ptCorner - ptGeCen;
|
||
vtCor.normalize();
|
||
ptCorner = ptGeCen + vtCor * (ptStart.distanceTo(ptGeCen));
|
||
return TRUE;
|
||
}
|
||
|
||
AcGeVector3d ImpHvacElbow::normal() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
AcGePoint3d ptStart,ptCorner,ptEnd;
|
||
AcGeVector3d vts,vte;
|
||
m_pXDataMap->GetAt(HELB_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint, ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint, ptEnd);
|
||
vts = ptCorner - ptStart;
|
||
vte = ptCorner - ptEnd;
|
||
return vts.crossProduct(vte);
|
||
}
|
||
|
||
BOOL ImpHvacElbow::GetPtOnArcExt(AcGePoint3d &ptStartArc, const AcGePoint3d &ptCorStart, AcGePoint3d &ptEndArc, const AcGePoint3d &ptCorEnd, AcGePoint3d &ptOnArcOut, double &dPlusEdge) const
|
||
{
|
||
AcGeVector3d vtStr,vtEnd,vtCor,vtNor;
|
||
AcGeVector3d vtStartArc;
|
||
AcGeVector3d vtEndArc;
|
||
AcGePoint3d ptGeCen;
|
||
AcGePoint3d ptCorner;
|
||
|
||
AcGeVector3d vtCorStartCom = ptCorStart.asVector();
|
||
AcGeVector3d vtCorEndCom = ptCorEnd.asVector();
|
||
AcGeVector3d vtCornerCom = (vtCorStartCom + vtCorEndCom) / 2;
|
||
ptCorner = AcGePoint3d::kOrigin + vtCornerCom;
|
||
|
||
vtStr = ptStartArc - ptCorStart;
|
||
vtEnd = ptEndArc - ptCorEnd;
|
||
|
||
vtStr.normalize();
|
||
vtEnd.normalize();
|
||
|
||
ptStartArc = ptStartArc - vtStr * dPlusEdge;
|
||
ptEndArc = ptEndArc - vtEnd * dPlusEdge;
|
||
|
||
vtStartArc = ptStartArc - ptCorner;
|
||
vtEndArc = ptEndArc - ptCorner;
|
||
vtNor = vtStartArc.crossProduct(vtEndArc);
|
||
|
||
vtStartArc.rotateBy(PI * 0.5, vtNor);
|
||
vtEndArc.rotateBy(PI * 0.5, vtNor);
|
||
|
||
if(!GetIntersectWith(ptStartArc,ptEndArc,vtStartArc,vtEndArc,ptGeCen))
|
||
return FALSE;
|
||
|
||
vtCor = ptCorner - ptGeCen;
|
||
vtCor.normalize();
|
||
|
||
ptOnArcOut = ptGeCen + vtCor * (ptStartArc.distanceTo(ptGeCen));
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL ImpHvacElbow::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;
|
||
}
|
||
|
||
void ImpHvacElbow::Move3DBuffer(AcDbVoidPtrArray& ar3DBuffer) const
|
||
{
|
||
if (!m_ar3DDrableBufPtrs_.isEmpty())
|
||
{
|
||
ar3DBuffer.append(m_ar3DDrableBufPtrs_);
|
||
m_ar3DDrableBufPtrs_.removeAll();
|
||
}
|
||
}
|
||
|
||
bool ImpHvacElbow::Has3DBuffer() const
|
||
{
|
||
return !m_ar3DDrableBufPtrs_.isEmpty();
|
||
}
|
||
|
||
bool ImpHvacElbow::GetInterface(AcArray<AecInterface>& arInfs) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return false;
|
||
|
||
// 获取弯头各点位置
|
||
AcGePoint3d ptStart, ptCorner, ptEnd;
|
||
m_pXDataMap->GetAt(HELB_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HELB_CornerPoint, ptCorner);
|
||
m_pXDataMap->GetAt(HELB_EndPoint, ptEnd);
|
||
|
||
// 求两端方向
|
||
AcGeVector3d vtStart, vtEnd;
|
||
vtStart = ptStart - ptCorner;
|
||
vtEnd = ptEnd - ptCorner;
|
||
|
||
AecInterface inf;
|
||
inf.ptPos = ptStart;
|
||
inf.vtDir = vtStart;
|
||
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
|
||
|
||
LPCTSTR pszWidthKey, pszThickKey;
|
||
pszWidthKey = ((eCircle == eSectType) ? HELB_Diameter : HELB_StartWidth);
|
||
pszThickKey = HELB_Thick;
|
||
|
||
double dWidth = 0.0, dThick = 0.0;
|
||
m_pXDataMap->GetAt(pszWidthKey, dWidth);
|
||
m_pXDataMap->GetAt(pszThickKey, dThick);
|
||
|
||
// 设置接口数据
|
||
inf.nType = eSectType;
|
||
inf.dSize1 = dWidth;
|
||
inf.dSize2 = dThick;
|
||
inf.idOwner = m_pOwnerEnt->objectId();
|
||
arInfs.append(inf);
|
||
|
||
pszWidthKey = ((eCircle == eSectType) ? HELB_EndDiameter : HELB_EndWidth);
|
||
pszThickKey = HELB_EndThick;
|
||
m_pXDataMap->GetAt(pszWidthKey, dWidth);
|
||
m_pXDataMap->GetAt(pszThickKey, dThick);
|
||
|
||
inf.dSize1 = dWidth;
|
||
inf.dSize2 = dThick;
|
||
inf.ptPos = ptEnd;
|
||
inf.vtDir = vtEnd;
|
||
arInfs.append(inf);
|
||
|
||
return true;
|
||
}
|
||
|
||
BOOL ImpHvacElbow::IsArcuate() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
// 弯头类型
|
||
AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
|
||
m_pXDataMap->GetAt(HELB_Type, (int&)eElbowType);
|
||
|
||
switch (eElbowType)
|
||
{
|
||
case AecHvac::eAllArcuate: // 内外圆弧
|
||
case AecHvac::eAllArcWrap: // 内外圆弧消声
|
||
case AecHvac::eAllArcInWrap: // 消声弯头
|
||
case AecHvac::eSegmental: // 分段拟合
|
||
return TRUE;
|
||
case AecHvac::eArcuate: // 内弧线
|
||
case AecHvac::eArcuateWrap: // 内弧线消声
|
||
case AecHvac::eArcuateBoard: // 内弧线隔板消声
|
||
case AecHvac::eArcuateSieve: // 内弧线筛板消声
|
||
case AecHvac::eArcuateLead: // 内弧线导流
|
||
case AecHvac::eIncline: // 内斜线
|
||
case AecHvac::eInclineWrap: // 内斜线消声
|
||
case AecHvac::eInclineBoard: // 内斜线隔板消声
|
||
case AecHvac::eInclineLead: // 内斜线导流
|
||
case AecHvac::eAllOrtho: // 内外直角
|
||
case AecHvac::eOrthoWrap: // 内外直角消声
|
||
case AecHvac::eOrthoLead: // 内外直角导流
|
||
return FALSE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void ImpHvacElbow::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;
|
||
}
|
||
|
||
// 圆型截面显示直径
|
||
if (eCircle == eSectType)
|
||
{
|
||
double dDiameter = 0.0;
|
||
m_pXDataMap->GetAt(HELB_Diameter, dDiameter);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t直径：%.2f"), dDiameter);
|
||
}
|
||
// 非圆型截面显示宽度和厚度
|
||
else
|
||
{
|
||
double dStartWidth = 0.0, dEndWidth = 0.0, dThick = 0.0;
|
||
m_pXDataMap->GetAt(HELB_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HELB_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HELB_Thick, dThick);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t始端宽度：%.2f 末端宽度：%.2f 厚度：%.2f"), dStartWidth, dEndWidth, dThick);
|
||
}
|
||
|
||
// 起点
|
||
AcGePoint3d pt;
|
||
m_pXDataMap->GetAt(HELB_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(HELB_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);
|
||
} |