2273 lines
58 KiB
C++
2273 lines
58 KiB
C++
#include "stdafx.h"
|
||
|
||
#include "ImpHvacReducer.h"
|
||
#include "AecDbObjXDataMap.h"
|
||
#include "AuxTools.h"
|
||
#include "math.h"
|
||
#include "dbxutil.h"
|
||
#include "dbsymutl.h"
|
||
|
||
using namespace AecEqui;
|
||
|
||
extern double MayAsMUnit(double dVal);
|
||
ImpHvacReducer::ImpHvacReducer()
|
||
{
|
||
m_pXDataMap = NULL;
|
||
m_pOwnerEnt = NULL;
|
||
}
|
||
|
||
ImpHvacReducer::~ImpHvacReducer()
|
||
{
|
||
}
|
||
|
||
void ImpHvacReducer::list() const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return;
|
||
|
||
// 管件类型
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 暖通：变径"));
|
||
|
||
// 截面类型
|
||
ESection eStartSectType = eRect;
|
||
m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSectType);
|
||
switch (eStartSectType)
|
||
{
|
||
case eRect: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t 始端截面：矩形")); break;
|
||
case eCircle: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t 始端截面：圆形")); break;
|
||
case eOblate: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t 始端截面：扁圆形")); break;
|
||
}
|
||
ESection eEndSectType = eRect;
|
||
m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t 末端截面：矩形")); break;
|
||
case eCircle: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t 末端截面：圆形")); break;
|
||
case eOblate: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t 末端截面：扁圆形")); break;
|
||
}
|
||
|
||
// 圆型截面显示直径
|
||
if (eCircle == eStartSectType)
|
||
{
|
||
double dDiameter = 0.0;
|
||
m_pXDataMap->GetAt(HRED_StartDiameter, dDiameter);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t始端直径：%.2f"), dDiameter);
|
||
}
|
||
// 非圆型截面显示宽度和厚度
|
||
else
|
||
{
|
||
double dWidth = 0.0, dThick = 0.0;
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dWidth);
|
||
m_pXDataMap->GetAt(HRED_StartThick, dThick);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t始端宽度：%.2f 始端厚度：%.2f"), dWidth, dThick);
|
||
}
|
||
|
||
// 圆型截面显示直径
|
||
if (eCircle == eEndSectType)
|
||
{
|
||
double dDiameter = 0.0;
|
||
m_pXDataMap->GetAt(HRED_EndDiameter, dDiameter);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t末端直径：%.2f"), dDiameter);
|
||
}
|
||
// 非圆型截面显示宽度和厚度
|
||
else
|
||
{
|
||
double dWidth = 0.0, dThick = 0.0;
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dWidth);
|
||
m_pXDataMap->GetAt(HRED_EndThick, dThick);
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t末端宽度：%.2f 末端厚度：%.2f"), dWidth, dThick);
|
||
}
|
||
|
||
// 起点
|
||
AcGePoint3d pt;
|
||
m_pXDataMap->GetAt(HRED_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(HRED_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);
|
||
}
|
||
|
||
BOOL ImpHvacReducer::IsHorzAlignment() const
|
||
{
|
||
// 获得法向量
|
||
AcGeVector3d vtSect;
|
||
m_pXDataMap->GetAt(HRED_StartDir, vtSect);
|
||
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
|
||
return vtSect.isPerpendicularTo(vtZAxis);
|
||
}
|
||
|
||
BOOL ImpHvacReducer::IsVertAlignment() const
|
||
{
|
||
// 获得法向量
|
||
AcGeVector3d vtSect;
|
||
m_pXDataMap->GetAt(HRED_StartDir, vtSect);
|
||
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
|
||
return vtSect.isParallelTo(vtZAxis);
|
||
}
|
||
|
||
BOOL ImpHvacReducer::IsInclineAlignment() const
|
||
{
|
||
// 获得法向量
|
||
AcGeVector3d vtSect;
|
||
m_pXDataMap->GetAt(HRED_StartDir, vtSect);
|
||
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
|
||
return !vtSect.isPerpendicularTo(vtZAxis) && !vtSect.isParallelTo(vtZAxis);
|
||
}
|
||
|
||
BOOL ImpHvacReducer::IsSingleLine() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
BOOL bSingleLine = FALSE;
|
||
m_pXDataMap->GetAt(HVAC_IsSingleLine, (int&)bSingleLine);
|
||
|
||
return bSingleLine;
|
||
}
|
||
|
||
AcGeVector3d ImpHvacReducer::GetSectNormal() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
AcGeVector3d vtSta;
|
||
m_pXDataMap->GetAt(HRED_StartDir, vtSta);
|
||
if (!vtSta.isParallelTo(TAuxTools::GetUcsZvt()))
|
||
{
|
||
if (!vtSta.isPerpendicularTo(TAuxTools::GetUcsZvt()))
|
||
return vtSta;
|
||
else
|
||
vtSta = vtSta.orthoProject(TAuxTools::GetUcsZvt());
|
||
}
|
||
return vtSta;
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacReducer::Draw3d(AcGiDraw& mode) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eOk;
|
||
|
||
// 变径类型
|
||
ESection eStartSectType = eRect;
|
||
ESection eEndSectType = eRect;
|
||
m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSectType);
|
||
m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);
|
||
|
||
AcDbObjectId idLayBk = mode.GetLayerId();
|
||
mode.SetLayer(m_idDoubleLayer);
|
||
// 始端截面
|
||
switch (eStartSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
// 末端截面
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
ExplodeRect2Rect3d(mode);
|
||
break;
|
||
case eCircle: // 园形
|
||
ExplodeRect2Cir3d(mode);
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case eCircle: // 园形
|
||
// 末端截面
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
ExplodeCir2Rect3d(mode);
|
||
break;
|
||
case eCircle: // 园形
|
||
ExplodeCir2Cir3d(mode);
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case eOblate: // 扁圆形
|
||
// 末端截面
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
break;
|
||
case eCircle: // 园形
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
mode.SetLayer(idLayBk);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
BOOL ImpHvacReducer::DrawMesh(AcGiDraw &mode,const Adesk::UInt32 rows,const Adesk::UInt32 columns,const AcGePoint3d* pVertexList) const
|
||
{
|
||
AcGePoint3dArray vertexArray;
|
||
AcArray<Adesk::Int32> faceArray;
|
||
|
||
int nV0 = 0,nV1 = 0,nV2 = 0;
|
||
int nV3= 0;
|
||
int nFaceIndex = 0;
|
||
AcGePoint3d ptFace[4];
|
||
|
||
for (int i = 0;i < rows - 1;i++)
|
||
{
|
||
for (int j = 0;j < columns - 1;j++)
|
||
{
|
||
nV0 = i * columns + j;
|
||
nV1 = nV0 + 1;
|
||
|
||
//第二行,第一个
|
||
nV2 = (i + 1) * columns + j;
|
||
|
||
nV3 = nV2 + 1;
|
||
|
||
//三角:nV0-nV1-nV2
|
||
faceArray.append(3);
|
||
faceArray.append(nV0);//v0
|
||
faceArray.append(nV1);//v1
|
||
faceArray.append(nV2);//v2
|
||
|
||
ptFace[0] = pVertexList[nV0];
|
||
ptFace[1] = pVertexList[nV1];
|
||
ptFace[2] = pVertexList[nV2];
|
||
ptFace[3] = ptFace[0];
|
||
//mode.DrawFace(ptFace);
|
||
|
||
//三角:nV2-nV1-nV3
|
||
faceArray.append(3);
|
||
faceArray.append(nV2);//v2
|
||
faceArray.append(nV1);//v1
|
||
faceArray.append(nV3);//v3
|
||
|
||
ptFace[0] = pVertexList[nV2];
|
||
ptFace[1] = pVertexList[nV1];
|
||
ptFace[2] = pVertexList[nV3];
|
||
ptFace[3] = ptFace[0];
|
||
//mode.DrawFace(ptFace);
|
||
}
|
||
}
|
||
|
||
if (!faceArray.isEmpty())
|
||
{
|
||
int nIndex = 0;
|
||
for (int i = 0;i < rows;i++)
|
||
{
|
||
for (int j = 0;j < columns;j++)
|
||
{
|
||
nIndex = i * columns + j;
|
||
vertexArray.append(pVertexList[nIndex]);
|
||
}
|
||
}
|
||
|
||
AcDbSubDMesh* pSubMesh = new AcDbSubDMesh;
|
||
if ( Acad::eOk == pSubMesh->setSubDMesh(vertexArray,faceArray,0) )
|
||
{
|
||
mode.DrawEntity(pSubMesh);
|
||
m_ar3DDrableBufPtrs_.append(pSubMesh);
|
||
|
||
//有时候失败?
|
||
/*Acad::ErrorStatus es;
|
||
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
||
if ( Acad::eOk == (es = pSubMesh->convertToSolid(false,false,pSolid) ) )
|
||
{
|
||
mode.DrawEntity(pSolid);
|
||
}
|
||
delete pSubMesh;
|
||
*/
|
||
return TRUE;
|
||
}
|
||
delete pSubMesh;
|
||
}
|
||
|
||
mode.DrawMeshS (rows,columns,pVertexList,false);
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL ImpHvacReducer::DrawShell(AcGiDraw &mode,const Adesk::UInt32 nbVertex,const AcGePoint3d* pVertexList,const Adesk::UInt32 faceListSize,const Adesk::Int32* pFaceList) const
|
||
{
|
||
AcGePoint3dArray vertexArray;
|
||
AcArray<Adesk::Int32> faceArray;
|
||
|
||
for(int i = 0;i < nbVertex;i++)
|
||
{
|
||
vertexArray.append(pVertexList[i]);
|
||
}
|
||
for (int j = 0;j < faceListSize;j++)
|
||
{
|
||
faceArray.append(pFaceList[j]);
|
||
}
|
||
|
||
AcDbSubDMesh* pSubMesh = new AcDbSubDMesh;
|
||
if ( Acad::eOk == pSubMesh->setSubDMesh(vertexArray,faceArray,0) )
|
||
{
|
||
mode.DrawEntity(pSubMesh);
|
||
m_ar3DDrableBufPtrs_.append(pSubMesh);
|
||
|
||
//有时候失败?
|
||
/*Acad::ErrorStatus es;
|
||
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
||
if ( Acad::eOk == (es = pSubMesh->convertToSolid(false,false,pSolid) ) )
|
||
{
|
||
mode.DrawEntity(pSolid);
|
||
}
|
||
delete pSubMesh;
|
||
*/
|
||
return TRUE;
|
||
}
|
||
delete pSubMesh;
|
||
|
||
mode.DrawShell (nbVertex,pVertexList,faceListSize,pFaceList);
|
||
return FALSE;
|
||
}
|
||
|
||
void ImpHvacReducer::Move3DBuffer(AcDbVoidPtrArray& ar3DBuffer) const
|
||
{
|
||
if (!m_ar3DDrableBufPtrs_.isEmpty())
|
||
{
|
||
ar3DBuffer.append(m_ar3DDrableBufPtrs_);
|
||
m_ar3DDrableBufPtrs_.removeAll();
|
||
}
|
||
}
|
||
|
||
bool ImpHvacReducer::Has3DBuffer() const
|
||
{
|
||
return !m_ar3DDrableBufPtrs_.isEmpty();
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacReducer::Draw2d(AcGiDraw& mode) const
|
||
{
|
||
if (m_pXDataMap == NULL)
|
||
{
|
||
return Acad::eNotImplementedYet;
|
||
}
|
||
|
||
AecComplexCurve cplCurve;
|
||
MakeCurves(cplCurve);
|
||
|
||
AecComplexCurveDraw edage;
|
||
edage.SetEdage(cplCurve);
|
||
|
||
BOOL bWeight = FALSE;
|
||
|
||
AcDbObjectId idReal = m_idDoubleLayer;
|
||
AcDbObjectId idDash = m_idDashLayer;
|
||
AcDbObjectId idCent = m_idCenterLayer;
|
||
|
||
edage.Draw2d(mode,idReal,idDash,idCent,NULL,bWeight,FALSE);
|
||
|
||
AecComplexCurve cplCen;
|
||
GetCurvesInSide(cplCen);
|
||
|
||
edage.SetEdage(cplCen);
|
||
edage.Draw2d(mode,idReal,idDash,idCent,NULL,bWeight,FALSE);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
BOOL ImpHvacReducer::MakeCurves(AecComplexCurve& cplCurve) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 变径类型
|
||
ESection eStartSectType = eRect;
|
||
ESection eEndSectType = eRect;
|
||
m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSectType);
|
||
m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);
|
||
|
||
int nType = 0;
|
||
if (IsHorzAlignment()) // 水平
|
||
{
|
||
switch (eStartSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeRect2Rect2DCurves(cplCurve,nType);
|
||
break;
|
||
case eCircle: // 圆形
|
||
return MakeRect2Cir2DCurves(cplCurve,nType);
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
case eCircle: // 圆形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeCir2Rect2DCurves(cplCurve,nType);
|
||
break;
|
||
case eCircle: // 圆形
|
||
return MakeCir2Cir2DCurves(cplCurve,nType);
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
break;
|
||
case eCircle: // 园形
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
else if(IsVertAlignment()) // 立管
|
||
{
|
||
switch (eStartSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeRect2Rect2DCurvesVer(cplCurve,nType);
|
||
break;
|
||
case eCircle: // 圆形
|
||
return MakeRect2Cir2DCurvesVer(cplCurve,nType);
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
case eCircle: // 圆形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeCir2Rect2DCurvesVer(cplCurve,nType);
|
||
break;
|
||
case eCircle: // 圆形
|
||
return MakeCir2Cir2DCurvesVer(cplCurve,nType);
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
break;
|
||
case eCircle: // 圆形
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
else if (IsInclineAlignment()) //倾斜变径二维Lixl
|
||
{
|
||
switch (eStartSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeRect2Rect2DCurves(cplCurve,nType);
|
||
break;
|
||
case eCircle: // 圆形
|
||
return MakeRect2Cir2DCurves(cplCurve,nType);
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
case eCircle: // 圆形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeCir2Rect2DCurves(cplCurve,nType);
|
||
break;
|
||
case eCircle: // 圆形
|
||
return MakeIncCir2Cir2DCurves(cplCurve,nType);
|
||
break;
|
||
case eOblate: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL ImpHvacReducer::GetCurvesInSide(AecComplexCurve& compCurve) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 变径类型
|
||
ESection eStartSectType = eRect;
|
||
ESection eEndSectType = eRect;
|
||
m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSectType);
|
||
m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);
|
||
|
||
int nType = 1;
|
||
if (IsHorzAlignment()) // 水平
|
||
{
|
||
switch (eStartSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeRect2Rect2DCurves(compCurve, nType);
|
||
break;
|
||
case eCircle: // 园形
|
||
return MakeRect2Cir2DCurves(compCurve, nType);
|
||
break;
|
||
case eEllispe: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
case eCircle: // 园形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeCir2Rect2DCurves(compCurve, nType);
|
||
break;
|
||
case eCircle: // 园形
|
||
return MakeCir2Cir2DCurves(compCurve, nType);
|
||
break;
|
||
case eEllispe: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
case eEllispe: // 扁圆形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
break;
|
||
case eCircle: // 园形
|
||
break;
|
||
case eEllispe: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
else if(IsVertAlignment()) // 立管
|
||
{
|
||
switch (eStartSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeRect2Rect2DCurvesVer(compCurve, nType);
|
||
break;
|
||
case eCircle: // 园形
|
||
return MakeRect2Cir2DCurvesVer(compCurve, nType);
|
||
break;
|
||
case eEllispe: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
case eCircle: // 园形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeCir2Rect2DCurvesVer(compCurve, nType);
|
||
break;
|
||
case eCircle: // 园形
|
||
return MakeCir2Cir2DCurvesVer(compCurve, nType);
|
||
break;
|
||
case eEllispe: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
case eEllispe: // 扁圆形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
break;
|
||
case eCircle: // 园形
|
||
break;
|
||
case eEllispe: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
else if (IsInclineAlignment())
|
||
{
|
||
switch (eStartSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeRect2Rect2DCurves(compCurve,nType);
|
||
break;
|
||
case eCircle: // 圆形
|
||
return MakeRect2Cir2DCurves(compCurve,nType);
|
||
break;
|
||
case eEllispe: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
case eCircle: // 圆形
|
||
switch (eEndSectType)
|
||
{
|
||
case eRect: // 矩形
|
||
return MakeCir2Rect2DCurves(compCurve,nType);
|
||
break;
|
||
case eCircle: // 圆形
|
||
return MakeIncCir2Cir2DCurves(compCurve,nType);
|
||
break;
|
||
case eEllispe: // 扁圆形
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
Acad::ErrorStatus ImpHvacReducer::transformBy(const AcGeMatrix3d& xform)
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotApplicable;
|
||
|
||
// 取得位置点和法向
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtNormal, vtSta;
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
|
||
m_pXDataMap->GetAt(HRED_StartDir, vtSta);
|
||
|
||
// 变换位置
|
||
ptStart.transformBy(xform);
|
||
ptEnd.transformBy(xform);
|
||
vtNormal.transformBy(xform);
|
||
vtSta.transformBy(xform);
|
||
vtNormal.normalize();
|
||
vtSta.normalize();
|
||
|
||
// 更新点和法向
|
||
m_pXDataMap->SetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->SetAt(HRED_EndPoint, ptEnd);
|
||
m_pXDataMap->SetAt(KEY_NORMAL, vtNormal);
|
||
m_pXDataMap->SetAt(HRED_StartDir, vtSta);
|
||
|
||
// 设置尺寸
|
||
double dScale = xform.scale();
|
||
double dStaWidth(0.0), dEndWidth(0.), dStaThick(0.0), dEndThick(0.0);
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dStaWidth);
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HRED_StartThick, dStaThick);
|
||
m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
|
||
|
||
dStaWidth *= dScale;
|
||
dEndWidth *= dScale;
|
||
dStaThick *= dScale;
|
||
dEndThick *= dScale;
|
||
m_pXDataMap->SetAt(HRED_StartWidth, dStaWidth);
|
||
m_pXDataMap->SetAt(HRED_EndWidth, dEndWidth);
|
||
m_pXDataMap->SetAt(HRED_StartThick, dStaThick);
|
||
m_pXDataMap->SetAt(HRED_EndThick, dEndThick);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AecEqui::Position ImpHvacReducer::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;
|
||
}
|
||
return ePos;
|
||
}
|
||
|
||
// 绘制三维图形（方对方）
|
||
void ImpHvacReducer::ExplodeRect2Rect3d(AcGiDraw& mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dStartWidth = MayAsMUnit(200.0), dStartThick = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0),
|
||
dEndThick = MayAsMUnit(400.0), dPlusEdge(GetPlusEdge());
|
||
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
|
||
|
||
// 计算8顶点
|
||
AcGeVector3d vtSect = GetSectNormal();
|
||
AcGeVector3d vt = vtSect;
|
||
vt.rotateBy(PI / 2.0, vtNormal);
|
||
vt.normalize();
|
||
AcGePoint3dArray arPtS, arPtE;
|
||
arPtS.append(ptStart + dStartWidth * vt / 2.0 + dStartThick * vtNormal / 2.0);
|
||
arPtS.append(arPtS.at(0) - dStartWidth * vt);
|
||
arPtS.append(arPtS.at(1) - dStartThick * vtNormal);
|
||
arPtS.append(arPtS.at(0) - dStartThick * vtNormal);
|
||
arPtS.append(arPtS.at(0));
|
||
arPtE.append(ptEnd + dEndWidth * vt / 2.0 + dEndThick * vtNormal / 2.0);
|
||
arPtE.append(arPtE.at(0) - dEndWidth * vt);
|
||
arPtE.append(arPtE.at(1) - dEndThick * vtNormal);
|
||
arPtE.append(arPtE.at(0) - dEndThick * vtNormal);
|
||
arPtE.append(arPtE.at(0));
|
||
|
||
// 考虑法兰余量添加5行4列点
|
||
AcGePoint3dArray arPoint;
|
||
for(int i = 0; i < 5; i++)
|
||
{
|
||
arPoint.append(arPtS.at(i));
|
||
arPoint.append(arPtS.at(i) - dPlusEdge * vtSect);
|
||
arPoint.append(arPtE.at(i) + dPlusEdge * vtSect);
|
||
arPoint.append(arPtE.at(i));
|
||
}
|
||
|
||
DrawMesh(mode,5, 4, arPoint.asArrayPtr());
|
||
}
|
||
|
||
// 构建二维图形（方对方）
|
||
BOOL ImpHvacReducer::MakeRect2Rect2DCurves(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dStartWidth = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dPlusEdge = GetPlusEdge();
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
|
||
ESection eSectType = eRect;
|
||
m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSectType);
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
if ((eSectType == eRect) && !vtNormal.isParallelTo(TAuxTools::GetUcsZvt())) // 取厚
|
||
{
|
||
m_pXDataMap->GetAt(HRED_StartThick, dStartWidth);
|
||
m_pXDataMap->GetAt(HRED_EndThick, dEndWidth);
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
AcDbObjectId idEndLayer, idBaseLayer;
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
|
||
|
||
BOOL bHasBaseLine = FALSE;
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLine);
|
||
|
||
AecCurveElement curEle;
|
||
curEle.bHided = FALSE;
|
||
curEle.dWidth = 0.0;
|
||
curEle.gsMark = 0;
|
||
curEle.idSubLay = m_idDoubleLayer;
|
||
|
||
AcGeVector3d vtSect = GetSectNormal();
|
||
// 2D下绘制，截面方向向XY平面投影，后计算图形在XY平面上的关键点Lixl
|
||
vtSect = vtSect.orthoProject(TAuxTools::GetUcsZvt());
|
||
// 绘单线
|
||
if (IsSingleLine())
|
||
{
|
||
AcGeVector3d vtDir = ptStart - ptEnd;
|
||
AcGePoint3d ptS, ptM, ptE;
|
||
vtDir.normalize();
|
||
ptM = ptEnd + vtDir * ptStart.distanceTo(ptEnd) / 2.0;
|
||
if (ptStart.distanceTo(ptEnd) > MayAsMUnit(120.0))
|
||
{
|
||
ptS = ptM + vtDir * 60.0;
|
||
ptE = ptM - vtDir * 60.0;
|
||
curEle.ptGe[0] = ptStart;
|
||
curEle.ptGe[1] = ptS;
|
||
curEle.ptGe[2] = ptS;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptEnd;
|
||
curEle.ptGe[1] = ptE;
|
||
curEle.ptGe[2] = ptE;
|
||
cplCurve.append(curEle);
|
||
}
|
||
else
|
||
{
|
||
ptS = ptStart;
|
||
ptE = ptEnd;
|
||
}
|
||
|
||
vtDir.rotateBy(PI/2, TAuxTools::GetUcsZvt());
|
||
double dS = MayAsMUnit(20.0), dE = MayAsMUnit(50.0);
|
||
if (dStartWidth > dEndWidth)
|
||
{
|
||
dS = MayAsMUnit(50.0);
|
||
dE = MayAsMUnit(20.0);
|
||
}
|
||
curEle.ptGe[0] = ptS + (dS + MayAsMUnit(10.0)) * vtDir;
|
||
curEle.ptGe[1] = ptS - (dS + MayAsMUnit(10.0)) * vtDir;
|
||
curEle.ptGe[2] = ptS - (dS + MayAsMUnit(10.0)) * vtDir;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptE + (dE + MayAsMUnit(10.0)) * vtDir;
|
||
curEle.ptGe[1] = ptE - (dE + MayAsMUnit(10.0)) * vtDir;
|
||
curEle.ptGe[2] = ptE - (dE + MayAsMUnit(10.0)) * vtDir;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptS + dS * vtDir;
|
||
curEle.ptGe[1] = ptE + dE * vtDir;
|
||
curEle.ptGe[2] = ptE + dE * vtDir;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptS - dS * vtDir;
|
||
curEle.ptGe[1] = ptE - dE * vtDir;
|
||
curEle.ptGe[2] = ptE - dE * vtDir;
|
||
cplCurve.append(curEle);
|
||
return TRUE;
|
||
}
|
||
|
||
if (0 == nType)
|
||
{
|
||
AcGeVector3d vt = vtSect;
|
||
//vt.rotateBy(PI / 2.0, vtNormal);
|
||
vt.rotateBy(PI / 2.0, TAuxTools::GetUcsZvt());
|
||
vt.normalize();
|
||
AcGePoint3d arPoint[4], arPointIn[4];
|
||
arPoint[0] = ptStart - dStartWidth * vt / 2.0;
|
||
arPoint[1] = ptStart + dStartWidth * vt / 2.0;
|
||
arPoint[2] = ptEnd + dEndWidth * vt / 2.0;
|
||
arPoint[3] = ptEnd - dEndWidth * vt / 2.0;
|
||
arPointIn[0] = arPoint[0] - dPlusEdge * vtSect;
|
||
arPointIn[1] = arPoint[1] - dPlusEdge * vtSect;
|
||
arPointIn[2] = arPoint[2] + dPlusEdge * vtSect;
|
||
arPointIn[3] = arPoint[3] + dPlusEdge * vtSect;
|
||
|
||
curEle.dWidth = GetEdgeLineWidth();
|
||
curEle.ptGe[0] = arPoint[1];
|
||
curEle.ptGe[1] = arPointIn[1];
|
||
curEle.ptGe[2] = arPointIn[1];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPoint[0];
|
||
curEle.ptGe[1] = arPointIn[0];
|
||
curEle.ptGe[2] = arPointIn[0];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPointIn[1];
|
||
curEle.ptGe[1] = arPointIn[2];
|
||
curEle.ptGe[2] = arPointIn[2];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPointIn[0];
|
||
curEle.ptGe[1] = arPointIn[3];
|
||
curEle.ptGe[2] = arPointIn[3];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPointIn[2];
|
||
curEle.ptGe[1] = arPoint[2];
|
||
curEle.ptGe[2] = arPoint[2];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPointIn[3];
|
||
curEle.ptGe[1] = arPoint[3];
|
||
curEle.ptGe[2] = arPoint[3];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.idSubLay = idEndLayer; // 两端图层
|
||
curEle.dWidth = GetEndLineWidth();
|
||
curEle.ptGe[0] = arPoint[0];
|
||
curEle.ptGe[1] = arPoint[1];
|
||
curEle.ptGe[2] = arPoint[1];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPoint[2];
|
||
curEle.ptGe[1] = arPoint[3];
|
||
curEle.ptGe[2] = arPoint[3];
|
||
cplCurve.append(curEle);
|
||
}
|
||
else if (1 == nType)
|
||
{
|
||
if (bHasBaseLine)
|
||
{
|
||
curEle.idSubLay = m_idCenterLayer; // 基线图层
|
||
curEle.dWidth = GetCentLineWidth();
|
||
curEle.ptGe[0] = ptStart;
|
||
curEle.ptGe[1] = ptStart - dPlusEdge * vtSect;
|
||
curEle.ptGe[2] = ptStart - dPlusEdge * vtSect;
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = ptStart - dPlusEdge * vtSect;
|
||
curEle.ptGe[1] = ptEnd + dPlusEdge * vtSect;
|
||
curEle.ptGe[2] = ptEnd + dPlusEdge * vtSect;
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = ptEnd + dPlusEdge * vtSect;
|
||
curEle.ptGe[1] = ptEnd;
|
||
curEle.ptGe[2] = ptEnd;
|
||
cplCurve.append(curEle);
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
// 倾斜变径: 圆对圆
|
||
BOOL ImpHvacReducer::MakeIncCir2Cir2DCurves(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dStartWidth = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dPlusEdge = 0.0;
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
ESection eStaSectType = eRect;
|
||
ESection eEndSectType = eRect;
|
||
m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStaSectType);
|
||
m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
|
||
if ((eStaSectType == eRect) && !vtNormal.isParallelTo(TAuxTools::GetUcsZvt())) // 取厚
|
||
{
|
||
m_pXDataMap->GetAt(HRED_StartThick, dStartWidth);
|
||
m_pXDataMap->GetAt(HRED_EndThick, dEndWidth);
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
AcDbObjectId idEndLayer, idBaseLayer;
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
|
||
|
||
// 中心线图层
|
||
BOOL bHasBaseLine = FALSE;
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLine);
|
||
|
||
AecCurveElement curEle;
|
||
curEle.bHided = FALSE;
|
||
curEle.dWidth = 0.0;
|
||
curEle.gsMark = 0;
|
||
curEle.idSubLay = m_idDoubleLayer;
|
||
|
||
AcGeVector3d vtSect = GetSectNormal();
|
||
int i(0), nRet(0);
|
||
AcDbPolyline* pLine = new AcDbPolyline;
|
||
if (NULL == pLine)
|
||
return FALSE;
|
||
AcGePoint3dArray arPtsCir;
|
||
AcGeVector3d vt = vtSect.crossProduct(vtNormal);
|
||
vt.normalize();
|
||
|
||
// 绘单线
|
||
if (IsSingleLine())
|
||
{
|
||
AcGeVector3d vtDir = ptStart - ptEnd;
|
||
vtDir.orthoProject(TAuxTools::GetUcsZvt());
|
||
vtDir.normalize();
|
||
AcGePoint3d ptS, ptM, ptE;
|
||
ptM = ptEnd + vtDir * ptStart.distanceTo(ptEnd) / 2.0;
|
||
if (ptStart.distanceTo(ptEnd) > MayAsMUnit(120.0))
|
||
{
|
||
ptS = ptM + vtDir * MayAsMUnit(60.0);
|
||
ptE = ptM - vtDir * MayAsMUnit(60.0);
|
||
curEle.ptGe[0] = ptStart;
|
||
curEle.ptGe[1] = ptS;
|
||
curEle.ptGe[2] = ptS;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptEnd;
|
||
curEle.ptGe[1] = ptE;
|
||
curEle.ptGe[2] = ptE;
|
||
cplCurve.append(curEle);
|
||
}
|
||
else
|
||
{
|
||
ptS = ptStart;
|
||
ptE = ptEnd;
|
||
}
|
||
|
||
vtDir.rotateBy(PI/2, TAuxTools::GetUcsZvt());
|
||
double dS = MayAsMUnit(20.0), dE = MayAsMUnit(50.0);
|
||
if (dStartWidth > dEndWidth)
|
||
{
|
||
dS = MayAsMUnit(50.0);
|
||
dE = MayAsMUnit(20.0);
|
||
}
|
||
curEle.ptGe[0] = ptS + (dS + MayAsMUnit(10.0)) * vtDir;
|
||
curEle.ptGe[1] = ptS - (dS + MayAsMUnit(10.0))* vtDir;
|
||
curEle.ptGe[2] = ptS - (dS + MayAsMUnit(10.0)) * vtDir;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptE + (dE + MayAsMUnit(10.0)) * vtDir;
|
||
curEle.ptGe[1] = ptE - (dE + MayAsMUnit(10.0)) * vtDir;
|
||
curEle.ptGe[2] = ptE - (dE + MayAsMUnit(10.0)) * vtDir;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptS + dS * vtDir;
|
||
curEle.ptGe[1] = ptE + dE * vtDir;
|
||
curEle.ptGe[2] = ptE + dE * vtDir;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptS - dS * vtDir;
|
||
curEle.ptGe[1] = ptE - dE * vtDir;
|
||
curEle.ptGe[2] = ptE - dE * vtDir;
|
||
cplCurve.append(curEle);
|
||
return TRUE;
|
||
}
|
||
|
||
if (0 == nType)
|
||
{
|
||
AcGePoint3d arPoint[4];
|
||
arPoint[0] = ptStart - dStartWidth * vt / 2.0;
|
||
arPoint[1] = ptStart + dStartWidth * vt / 2.0;
|
||
arPoint[2] = ptEnd + dEndWidth * vt / 2.0;
|
||
arPoint[3] = ptEnd - dEndWidth * vt / 2.0;
|
||
|
||
curEle.idSubLay = idEndLayer; // 两端图层
|
||
curEle.dWidth = GetEndLineWidth();
|
||
// 末端半个椭圆
|
||
vt = -vtSect;//起点指向终点
|
||
if (eEndSectType == eCircle)
|
||
{
|
||
nRet = TAuxTools::GetEllipsePtsFromCircle(arPtsCir, ptEnd, dEndWidth, vt, TAuxTools::GetUcsZvt(), *pLine, vt);
|
||
if (-1 != nRet)
|
||
{
|
||
for (i = 0; i < arPtsCir.length()-1; i++)//Lixl add 2011-11-23
|
||
{
|
||
curEle.ptGe[0] = arPtsCir[i];
|
||
curEle.ptGe[1] = arPtsCir[i+1];
|
||
curEle.ptGe[2] = arPtsCir[i+1];
|
||
cplCurve.append(curEle);
|
||
}
|
||
arPoint[2] = arPtsCir.first();
|
||
arPoint[3] = arPtsCir.last();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
}
|
||
|
||
arPtsCir.setLogicalLength(0);
|
||
pLine->reset(Adesk::kFalse, i);
|
||
if (eStaSectType == eCircle)
|
||
{
|
||
nRet = TAuxTools::GetEllipsePtsFromCircle(arPtsCir, ptStart, dStartWidth, -vt, TAuxTools::GetUcsZvt(), *pLine, -vt);
|
||
if (-1 != nRet)
|
||
{
|
||
for (i = 0; i < arPtsCir.length()-1; i++)//Lixl add 2011-11-23
|
||
{
|
||
curEle.ptGe[0] = arPtsCir[i];
|
||
curEle.ptGe[1] = arPtsCir[i+1];
|
||
curEle.ptGe[2] = arPtsCir[i+1];
|
||
cplCurve.append(curEle);
|
||
}
|
||
arPoint[0] = arPtsCir.first();
|
||
arPoint[1] = arPtsCir.last();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
|
||
}
|
||
|
||
vt = -vtSect.crossProduct(vtNormal);
|
||
AcGePoint3d ptJudge = ptStart + vt * MayAsMUnit(10000);
|
||
ptJudge.z = (ptStart.z + ptEnd.z) * 0.5;
|
||
arPoint[0].z = ptJudge.z;
|
||
arPoint[1].z = ptJudge.z;
|
||
arPoint[2].z = ptJudge.z;
|
||
arPoint[3].z = ptJudge.z;
|
||
|
||
AcGePoint3d ptTmp;
|
||
// 0,3点在上, 1,2点在下
|
||
if (arPoint[0].distanceTo(ptJudge) < arPoint[1].distanceTo(ptJudge))
|
||
{
|
||
ptTmp = arPoint[0];
|
||
arPoint[0] = arPoint[1];
|
||
arPoint[1] = ptTmp;
|
||
}
|
||
if (arPoint[3].distanceTo(ptJudge) < arPoint[2].distanceTo(ptJudge))
|
||
{
|
||
ptTmp = arPoint[3];
|
||
arPoint[3] = arPoint[2];
|
||
arPoint[2] = ptTmp;
|
||
}
|
||
// 变径边线
|
||
curEle.idSubLay = AcDbObjectId::kNull;
|
||
curEle.dWidth = GetEdgeLineWidth();
|
||
curEle.ptGe[0] = arPoint[0];
|
||
curEle.ptGe[1] = arPoint[3];
|
||
curEle.ptGe[2] = arPoint[3];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPoint[1];
|
||
curEle.ptGe[1] = arPoint[2];
|
||
curEle.ptGe[2] = arPoint[2];
|
||
cplCurve.append(curEle);
|
||
}
|
||
else if (1 == nType)
|
||
{
|
||
if (bHasBaseLine)
|
||
{
|
||
curEle.idSubLay = m_idCenterLayer; // 基线图层
|
||
curEle.dWidth = GetCentLineWidth();
|
||
curEle.ptGe[0] = ptStart;
|
||
curEle.ptGe[1] = ptEnd;
|
||
curEle.ptGe[2] = ptEnd;
|
||
cplCurve.append(curEle);
|
||
}
|
||
|
||
// 内部端线
|
||
curEle.idSubLay = idEndLayer;
|
||
curEle.dWidth = GetEndLineWidth();
|
||
vt = -vtSect;
|
||
// 起点高,画起点内半个椭圆
|
||
if (ptStart.z > ptEnd.z)
|
||
{
|
||
nRet = TAuxTools::GetEllipsePtsFromCircle(arPtsCir, ptStart, dStartWidth, vt, TAuxTools::GetUcsZvt(), *pLine, vt);
|
||
if (-1 != nRet)
|
||
{
|
||
for (i = 0; i < arPtsCir.length()-1; i++)//Lixl add 2011-11-23
|
||
{
|
||
curEle.ptGe[0] = arPtsCir[i];
|
||
curEle.ptGe[1] = arPtsCir[i+1];
|
||
curEle.ptGe[2] = arPtsCir[i+1];
|
||
cplCurve.append(curEle);
|
||
}
|
||
}
|
||
}
|
||
else // 终点高,画终点内部半个椭圆
|
||
{
|
||
nRet = TAuxTools::GetEllipsePtsFromCircle(arPtsCir, ptEnd, dEndWidth, vt, TAuxTools::GetUcsZvt(), *pLine, -vt);
|
||
if (-1 != nRet)
|
||
{
|
||
for (i = 0; i < arPtsCir.length()-1; i++)//Lixl add 2011-11-23
|
||
{
|
||
curEle.ptGe[0] = arPtsCir[i];
|
||
curEle.ptGe[1] = arPtsCir[i+1];
|
||
curEle.ptGe[2] = arPtsCir[i+1];
|
||
cplCurve.append(curEle);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (NULL != pLine)
|
||
delete pLine;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
// 绘制三维图形（方对圆）
|
||
void ImpHvacReducer::ExplodeRect2Cir3d(AcGiDraw& mode, BOOL bStartIsRound) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dStartWidth = MayAsMUnit(200.0), dStartThick = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0),
|
||
dEndThick = MayAsMUnit(400.0), dPlusEdge = GetPlusEdge();
|
||
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
AcGeVector3d vtSect = GetSectNormal();
|
||
if (bStartIsRound)
|
||
{
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
}
|
||
else
|
||
{
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HRED_StartThick, dEndThick);
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HRED_EndThick, dStartThick);
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptStart);
|
||
vtSect = -vtSect;
|
||
}
|
||
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
|
||
|
||
double dMinDiffAng = PI / 12.0; // 圆弧分割的角度
|
||
//GetGlobalContext()->GetAt(KEY_MINDIFFANG, dMinDiffAng);
|
||
m_pXDataMap->GetAt(KEY_MINDIFFANG, dMinDiffAng);
|
||
int nSect = int(PI / (2.0 * dMinDiffAng)) + 1; // 每PI/2圆弧分成的段数
|
||
dMinDiffAng = PI / (2.0 * nSect);
|
||
|
||
// 起始端圆分割点
|
||
AcGeVector3d vt = vtSect;
|
||
vt.rotateBy(PI / 2.0, vtNormal);
|
||
vt.normalize();
|
||
AcGePoint3dArray arCirPt;
|
||
AcGePoint3d ptCir;
|
||
ptCir = ptStart + vt * dStartWidth / 2.0;
|
||
arCirPt.append(ptCir);
|
||
for (int i = 1; i < 4 * nSect; i++)
|
||
{
|
||
ptCir.rotateBy(dMinDiffAng, vtSect, ptStart);
|
||
arCirPt.append(ptCir);
|
||
}
|
||
arCirPt.append(ptStart + vt * dStartWidth / 2.0); // 最后一个封闭，可消除计算误差
|
||
|
||
// 终止端矩形顶点
|
||
AcGePoint3dArray arRectPt;
|
||
arRectPt.append(ptEnd + dEndWidth * vt / 2.0 - dEndThick * vtNormal / 2.0);
|
||
arRectPt.append(arRectPt.at(0) + dEndThick * vtNormal);
|
||
arRectPt.append(arRectPt.at(1) - dEndWidth * vt);
|
||
arRectPt.append(arRectPt.at(0) - dEndWidth * vt);
|
||
arRectPt.append(arRectPt.at(0));
|
||
|
||
// 4*(nSect+1)+1行4列网格点
|
||
AcGePoint3dArray arPoint;
|
||
for (i = 0; i < 4; i++)
|
||
{
|
||
// 圆上点和矩形边
|
||
arPoint.append(arCirPt.at(i * nSect));
|
||
arPoint.append(arCirPt.at(i * nSect) - dPlusEdge * vtSect);
|
||
arPoint.append(arRectPt.at(i) + dPlusEdge * vtSect);
|
||
arPoint.append(arRectPt.at(i));
|
||
|
||
// 圆上边和矩形顶点
|
||
for (int j = 0; j < nSect; j++)
|
||
{
|
||
arPoint.append(arCirPt.at(i * nSect + j));
|
||
arPoint.append(arCirPt.at(i * nSect + j) - dPlusEdge * vtSect);
|
||
arPoint.append(arRectPt.at(i + 1) + dPlusEdge * vtSect);
|
||
arPoint.append(arRectPt.at(i + 1));
|
||
}
|
||
}
|
||
arPoint.append(arCirPt.at(0));
|
||
arPoint.append(arCirPt.at(0) - dPlusEdge * vtSect);
|
||
arPoint.append(arRectPt.at(0) + dPlusEdge * vtSect);
|
||
arPoint.append(arRectPt.at(0));
|
||
|
||
DrawMesh(mode,4 * (nSect + 1) + 1, 4, arPoint.asArrayPtr());
|
||
}
|
||
|
||
// 构建二维图形（方对圆）
|
||
BOOL ImpHvacReducer::MakeRect2Cir2DCurves(AecComplexCurve& cplCurve, int &nType, BOOL bStartIsRound) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dStartWidth = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dPlusEdge = GetPlusEdge();
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
|
||
AcGeVector3d vtSect = GetSectNormal();
|
||
if (bStartIsRound)
|
||
{
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
|
||
if (vtNormal.isParallelTo(TAuxTools::GetUcsZvt())) // 宽厚颠倒
|
||
{
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
}
|
||
// LixlModify支持倾斜管上的变径
|
||
else if (!vtNormal.isPerpendicularTo(TAuxTools::GetUcsZvt()))
|
||
{
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
}
|
||
else
|
||
{
|
||
m_pXDataMap->GetAt(HRED_EndThick, dEndWidth);
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
}
|
||
else
|
||
{
|
||
vtSect = -vtSect;
|
||
if (vtNormal.isParallelTo(TAuxTools::GetUcsZvt()))
|
||
{
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dEndWidth);
|
||
}
|
||
// LixlModify支持倾斜管上的变径
|
||
else if (!vtNormal.isPerpendicularTo(TAuxTools::GetUcsZvt()))
|
||
{
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dEndWidth);
|
||
}
|
||
else
|
||
{
|
||
m_pXDataMap->GetAt(HRED_StartThick, dEndWidth);
|
||
}
|
||
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptStart);
|
||
}
|
||
|
||
AcDbObjectId idEndLayer, idBaseLayer;
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
|
||
//TDbFittingBase* pFit = TDbFittingBase::cast(m_pOwnerEnt);
|
||
//if (NULL != pFit)
|
||
// idBaseLayer = pFit->CenterLayer();
|
||
BOOL bHasBaseLine = FALSE;
|
||
m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLine);
|
||
|
||
AecCurveElement curEle;
|
||
curEle.bHided = FALSE;
|
||
curEle.dWidth = 0.0;
|
||
curEle.gsMark = 0;
|
||
curEle.idSubLay = m_idDoubleLayer;
|
||
|
||
// 绘单线
|
||
if (IsSingleLine())
|
||
{
|
||
AcGeVector3d vtDir = ptStart - ptEnd;
|
||
AcGePoint3d ptS, ptM, ptE;
|
||
vtDir.normalize();
|
||
ptM = ptEnd + vtDir * ptStart.distanceTo(ptEnd) / 2.0;
|
||
if (ptStart.distanceTo(ptEnd) > MayAsMUnit(120.0))
|
||
{
|
||
ptS = ptM + vtDir * MayAsMUnit(60.0);
|
||
ptE = ptM - vtDir * MayAsMUnit(60.0);
|
||
curEle.ptGe[0] = ptStart;
|
||
curEle.ptGe[1] = ptS;
|
||
curEle.ptGe[2] = ptS;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptEnd;
|
||
curEle.ptGe[1] = ptE;
|
||
curEle.ptGe[2] = ptE;
|
||
cplCurve.append(curEle);
|
||
}
|
||
else
|
||
{
|
||
ptS = ptStart;
|
||
ptE = ptEnd;
|
||
}
|
||
|
||
vtDir.rotateBy(PI / 2.0, TAuxTools::GetUcsZvt());
|
||
curEle.ptGe[0] = ptS + MayAsMUnit(10.0) * vtDir; // ptS是圆断面
|
||
curEle.ptGe[1] = ptS - MayAsMUnit(10.0) * vtDir;
|
||
curEle.ptGe[2] = ptS - MayAsMUnit(10.0) * vtDir;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptE + MayAsMUnit(60.0) * vtDir;
|
||
curEle.ptGe[1] = ptE - MayAsMUnit(60.0) * vtDir;
|
||
curEle.ptGe[2] = ptE - MayAsMUnit(60.0) * vtDir;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptE + MayAsMUnit(50.0) * vtDir;
|
||
curEle.ptGe[1] = ptS;
|
||
curEle.ptGe[2] = ptS;
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = ptE - MayAsMUnit(50.0) * vtDir;
|
||
curEle.ptGe[1] = ptS;
|
||
curEle.ptGe[2] = ptS;
|
||
cplCurve.append(curEle);
|
||
return TRUE;
|
||
}
|
||
|
||
AcGeVector3d vt = vtSect;
|
||
vt.rotateBy(PI / 2.0, vtNormal);
|
||
vt.normalize();
|
||
AcGePoint3d arPoint[4], arPointIn[4];
|
||
arPoint[0] = ptStart - dStartWidth * vt / 2.0;
|
||
arPoint[1] = ptStart + dStartWidth * vt / 2.0;
|
||
arPoint[2] = ptEnd + dEndWidth * vt / 2.0;
|
||
arPoint[3] = ptEnd - dEndWidth * vt / 2.0;
|
||
arPointIn[0] = arPoint[0] - dPlusEdge * vtSect;
|
||
arPointIn[1] = arPoint[1] - dPlusEdge * vtSect;
|
||
arPointIn[2] = arPoint[2] + dPlusEdge * vtSect;
|
||
arPointIn[3] = arPoint[3] + dPlusEdge * vtSect;
|
||
|
||
if (1 == nType) // 内部线
|
||
{
|
||
curEle.ptGe[0] = ptStart - dPlusEdge * vtSect;
|
||
curEle.ptGe[1] = arPointIn[2];
|
||
curEle.ptGe[2] = arPointIn[2];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = ptStart - dPlusEdge * vtSect;
|
||
curEle.ptGe[1] = arPointIn[3];
|
||
curEle.ptGe[2] = arPointIn[3];
|
||
cplCurve.append(curEle);
|
||
|
||
if (bHasBaseLine)
|
||
{
|
||
curEle.idSubLay = m_idCenterLayer; // 基线图层
|
||
curEle.dWidth = GetCentLineWidth();
|
||
curEle.ptGe[0] = ptStart;
|
||
curEle.ptGe[1] = ptStart - dPlusEdge * vtSect;
|
||
curEle.ptGe[2] = ptStart - dPlusEdge * vtSect;
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = ptStart - dPlusEdge * vtSect;
|
||
curEle.ptGe[1] = ptEnd + dPlusEdge * vtSect;
|
||
curEle.ptGe[2] = ptEnd + dPlusEdge * vtSect;
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = ptEnd + dPlusEdge * vtSect;
|
||
curEle.ptGe[1] = ptEnd;
|
||
curEle.ptGe[2] = ptEnd;
|
||
cplCurve.append(curEle);
|
||
}
|
||
}
|
||
else if (0 == nType) // 外边线
|
||
{
|
||
curEle.dWidth = GetEdgeLineWidth();
|
||
curEle.ptGe[0] = arPoint[1];
|
||
curEle.ptGe[1] = arPointIn[1];
|
||
curEle.ptGe[2] = arPointIn[1];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPoint[0];
|
||
curEle.ptGe[1] = arPointIn[0];
|
||
curEle.ptGe[2] = arPointIn[0];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPointIn[1];
|
||
curEle.ptGe[1] = arPointIn[2];
|
||
curEle.ptGe[2] = arPointIn[2];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPointIn[0];
|
||
curEle.ptGe[1] = arPointIn[3];
|
||
curEle.ptGe[2] = arPointIn[3];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPointIn[2];
|
||
curEle.ptGe[1] = arPoint[2];
|
||
curEle.ptGe[2] = arPoint[2];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPointIn[3];
|
||
curEle.ptGe[1] = arPoint[3];
|
||
curEle.ptGe[2] = arPoint[3];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.idSubLay = idEndLayer; // 两端图层
|
||
curEle.dWidth = GetEndLineWidth();
|
||
curEle.ptGe[0] = arPoint[0];
|
||
curEle.ptGe[1] = arPoint[1];
|
||
curEle.ptGe[2] = arPoint[1];
|
||
cplCurve.append(curEle);
|
||
|
||
curEle.ptGe[0] = arPoint[2];
|
||
curEle.ptGe[1] = arPoint[3];
|
||
curEle.ptGe[2] = arPoint[3];
|
||
cplCurve.append(curEle);
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
// 绘制三维图形（圆对方）
|
||
void ImpHvacReducer::ExplodeCir2Rect3d(AcGiDraw& mode) const
|
||
{
|
||
ExplodeRect2Cir3d(mode, TRUE);
|
||
}
|
||
|
||
// 构建二维图形（圆对方）
|
||
BOOL ImpHvacReducer::MakeCir2Rect2DCurves(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
return MakeRect2Cir2DCurves(cplCurve, nType, TRUE);
|
||
}
|
||
|
||
// 绘制三维图形（圆对圆）
|
||
void ImpHvacReducer::ExplodeCir2Cir3d(AcGiDraw& mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dStartWidth = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dPlusEdge = GetPlusEdge();
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
|
||
|
||
AcGeVector3d vtSect = GetSectNormal();
|
||
double dMinDiffAng = PI / 12.0; // 圆弧分割的角度
|
||
//GetGlobalContext()->GetAt(KEY_MINDIFFANG, dMinDiffAng);
|
||
m_pXDataMap->GetAt(KEY_MINDIFFANG, dMinDiffAng);
|
||
int nSect = int(2.0 * PI / dMinDiffAng) + 1;
|
||
dMinDiffAng = 2.0 * PI / nSect;
|
||
|
||
// 起始端圆分割点
|
||
AcGeVector3d vt = vtSect;
|
||
vt.rotateBy(PI / 2.0, vtNormal);
|
||
vt.normalize();
|
||
AcGePoint3dArray arCirPtStart;
|
||
AcGePoint3d ptCir;
|
||
ptCir = ptStart + vt * dStartWidth / 2.0;
|
||
arCirPtStart.append(ptCir);
|
||
for (int i = 1; i < nSect; i++)
|
||
{
|
||
ptCir.rotateBy(dMinDiffAng, vtSect, ptStart);
|
||
arCirPtStart.append(ptCir);
|
||
}
|
||
arCirPtStart.append(ptStart + vt * dStartWidth / 2.0); // 最后一个封闭，可消除计算误差
|
||
|
||
// 终止端端圆分割点
|
||
AcGePoint3dArray arCirPtEnd;
|
||
ptCir = ptEnd + vt * dEndWidth / 2.0;
|
||
arCirPtEnd.append(ptCir);
|
||
for (i = 1; i < nSect; i++)
|
||
{
|
||
ptCir.rotateBy(dMinDiffAng, vtSect, ptEnd);
|
||
arCirPtEnd.append(ptCir);
|
||
}
|
||
arCirPtEnd.append(ptEnd + vt * dEndWidth / 2.0);
|
||
|
||
// nSect+1行2列网格点
|
||
AcGePoint3dArray arPoint;
|
||
for (i = 0; i < nSect + 1; i++)
|
||
{
|
||
arPoint.append(arCirPtStart.at(i));
|
||
arPoint.append(arCirPtStart.at(i) - dPlusEdge * vtSect);
|
||
arPoint.append(arCirPtEnd.at(i) + dPlusEdge * vtSect);
|
||
arPoint.append(arCirPtEnd.at(i));
|
||
}
|
||
DrawMesh(mode,nSect + 1, 4, arPoint.asArrayPtr());
|
||
}
|
||
|
||
// 构建二维图形（圆对圆）
|
||
BOOL ImpHvacReducer::MakeCir2Cir2DCurves(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
return MakeRect2Rect2DCurves(cplCurve, nType);
|
||
}
|
||
|
||
// 获得外轮廓点
|
||
void ImpHvacReducer::GetOutVertex(AcGePoint3dArray& arPoint, ESection eStart, ESection eEnd) const
|
||
{
|
||
double dStartWidth = MayAsMUnit(200.0), dStartThick = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dEndThick = MayAsMUnit(400.0);
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
|
||
if (eStart == eRect)
|
||
m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
|
||
else
|
||
dStartThick = dStartWidth; // 圆形取厚度为宽
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
if (eStart == eRect)
|
||
m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
|
||
else
|
||
dEndThick = dEndWidth;
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
|
||
|
||
// 计算8顶点（圆形近似为方形计算）
|
||
AcGeVector3d vtSect = AcGeVector3d::kZAxis;
|
||
AcGeVector3d vt = vtSect;
|
||
vt.rotateBy(PI / 2.0, vtNormal);
|
||
vt.normalize();
|
||
AcGePoint3dArray arStartPt;
|
||
arStartPt.append(ptStart + dStartWidth * vt / 2.0 + dStartThick * vtNormal / 2.0);
|
||
arStartPt.append(arStartPt.at(0) - dStartWidth * vt);
|
||
arStartPt.append(arStartPt.at(1) - dStartThick * vtNormal);
|
||
arStartPt.append(arStartPt.at(0) - dStartThick * vtNormal);
|
||
AcGePoint3dArray arEndPt;
|
||
arEndPt.append(ptEnd + dEndWidth * vt / 2.0 + dEndThick * vtNormal / 2.0);
|
||
arEndPt.append(arEndPt.at(0) - dEndWidth * vt);
|
||
arEndPt.append(arEndPt.at(1) - dEndThick * vtNormal);
|
||
arEndPt.append(arEndPt.at(0) - dEndThick * vtNormal);
|
||
|
||
// 边旋转到与x，y轴平行
|
||
double dAngle = vtNormal.angleTo(AcGeVector3d::kXAxis);
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
arStartPt.at(i).rotateBy(dAngle, vtSect, ptStart);
|
||
arEndPt.at(i).rotateBy(dAngle, vtSect, ptStart);
|
||
}
|
||
|
||
// 寻找外轮廓点
|
||
if (arStartPt.at(0).x < arEndPt.at(0).x)
|
||
{
|
||
arPoint.append(arEndPt.at(0));
|
||
arPoint.append(arEndPt.at(1));
|
||
if (arStartPt.at(1).y < arEndPt.at(1).y)
|
||
{
|
||
arPoint.append(arEndPt.at(2));
|
||
if (arStartPt.at(2).x < arEndPt.at(2).x)// 左偏
|
||
{
|
||
arPoint.append(arStartPt.at(2));
|
||
arPoint.append(arStartPt.at(3));
|
||
if (arStartPt.at(3).y < arEndPt.at(3).y) // 左，下偏出
|
||
{
|
||
arPoint.append(arStartPt.at(0));
|
||
}
|
||
else // 左偏出
|
||
{
|
||
arPoint.append(arEndPt.at(3));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
arPoint.append(arEndPt.at(3));
|
||
if (arStartPt.at(3).y < arEndPt.at(3).y) // 下偏出
|
||
{
|
||
arPoint.append(arStartPt.at(3));
|
||
arPoint.append(arStartPt.at(0));
|
||
}
|
||
else // 全在里面
|
||
{
|
||
}
|
||
}
|
||
}
|
||
else // 上偏
|
||
{
|
||
arPoint.append(arStartPt.at(1));
|
||
arPoint.append(arStartPt.at(2));
|
||
if (arStartPt.at(2).x < arEndPt.at(2).x)// 左偏
|
||
{
|
||
arPoint.append(arStartPt.at(3));
|
||
if (arStartPt.at(3).y < arEndPt.at(3).y) // 上，左，下偏出
|
||
{
|
||
arPoint.append(arStartPt.at(0));
|
||
}
|
||
else // 上，左偏出
|
||
{
|
||
arPoint.append(arEndPt.at(3));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
arPoint.append(arEndPt.at(2));
|
||
arPoint.append(arEndPt.at(3));
|
||
if (arStartPt.at(3).y < arEndPt.at(3).y) // 上，下偏出
|
||
{
|
||
arPoint.append(arStartPt.at(3));
|
||
arPoint.append(arStartPt.at(0));
|
||
}
|
||
else // 上偏出
|
||
{
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else // 右偏
|
||
{
|
||
arPoint.append(arStartPt.at(0));
|
||
arPoint.append(arStartPt.at(1));
|
||
if (arStartPt.at(1).y < arEndPt.at(1).y)
|
||
{
|
||
arPoint.append(arEndPt.at(1));
|
||
arPoint.append(arEndPt.at(2));
|
||
if (arStartPt.at(2).x < arEndPt.at(2).x)// 左偏
|
||
{
|
||
arPoint.append(arStartPt.at(2));
|
||
arPoint.append(arStartPt.at(3));
|
||
if (arStartPt.at(3).y < arEndPt.at(3).y) // 右，左，下偏出
|
||
{
|
||
}
|
||
else // 右，左偏出
|
||
{
|
||
arPoint.append(arEndPt.at(3));
|
||
arPoint.append(arEndPt.at(0));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
arPoint.append(arEndPt.at(3));
|
||
if (arStartPt.at(3).y < arEndPt.at(3).y) // 右，下偏出
|
||
{
|
||
arPoint.append(arStartPt.at(3));
|
||
}
|
||
else // 右偏出
|
||
{
|
||
arPoint.append(arEndPt.at(0));
|
||
}
|
||
}
|
||
}
|
||
else // 上偏
|
||
{
|
||
arPoint.append(arStartPt.at(2));
|
||
if (arStartPt.at(2).x < arEndPt.at(2).x)// 左偏
|
||
{
|
||
arPoint.append(arStartPt.at(3));
|
||
if (arStartPt.at(3).y < arEndPt.at(3).y) // 右，上，左，下偏出
|
||
{
|
||
}
|
||
else // 右，上，左偏出
|
||
{
|
||
arPoint.append(arEndPt.at(3));
|
||
arPoint.append(arEndPt.at(0));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
arPoint.append(arEndPt.at(2));
|
||
arPoint.append(arEndPt.at(3));
|
||
if (arStartPt.at(3).y < arEndPt.at(3).y) // 右，上，下偏出
|
||
{
|
||
arPoint.append(arStartPt.at(3));
|
||
}
|
||
else // 右，上偏出
|
||
{
|
||
arPoint.append(arEndPt.at(0));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 恢复点的原位置
|
||
for (i = 0; i < arPoint.length(); i++)
|
||
{
|
||
arPoint.at(i).rotateBy(-dAngle, vtSect, ptStart);
|
||
}
|
||
}
|
||
|
||
/*
|
||
2______________________1
|
||
| |
|
||
| 0 |
|
||
| |
|
||
3______________________4|
|
||
*/
|
||
// bGetStartVertex 真:取起点截面周围顶点,假:取终点截面周围顶点
|
||
// 矩形截面,执行此函数后6个点,圆形界面26个点,顺序,中心点,逆时针24个点,逆时针起点终点重复一个点
|
||
void ImpHvacReducer::GetOutVertex2(AcGePoint3dArray& arPoint, bool bGetStartVertex) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
// 竖直放置时的外轮廓
|
||
if (IsVertAlignment())
|
||
{
|
||
AcGeVector3d vtSect, vtNor;
|
||
m_pXDataMap->GetAt(HRED_StartDir, vtSect);
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
|
||
AcGePoint3d ptCenter, ptTmp;
|
||
double dWidth(0.0), dThick(0.0);
|
||
ESection eSect(eRect);
|
||
if (bGetStartVertex)
|
||
{
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSect);
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dWidth);
|
||
m_pXDataMap->GetAt(HRED_StartThick, dThick);
|
||
}
|
||
else
|
||
{
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HRED_EndSectType, (int&)eSect);
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dWidth);
|
||
m_pXDataMap->GetAt(HRED_EndThick, dThick);
|
||
}
|
||
|
||
AcGeVector3d vtDir = vtNor.crossProduct(vtSect);
|
||
AcGeVector3d vtDirV = vtDir.normalize();
|
||
vtDirV.rotateBy(PI*0.5, vtSect);
|
||
|
||
// 0
|
||
arPoint.append(ptCenter);
|
||
if (eRect == eSect)
|
||
{
|
||
ptTmp = ptCenter + vtDir * dWidth * 0.5;
|
||
ptTmp = ptTmp + vtDirV * dThick * 0.5;
|
||
arPoint.append(ptTmp);//1
|
||
ptTmp = arPoint[1] - vtDir * dWidth;
|
||
arPoint.append(ptTmp);//2
|
||
ptTmp = arPoint[2] - vtDirV * dThick;
|
||
arPoint.append(ptTmp);//3
|
||
ptTmp = arPoint[1] - vtDirV * dThick;
|
||
arPoint.append(ptTmp);//4
|
||
// 为闭合,增加1点为重复点
|
||
arPoint.append(arPoint[1]);
|
||
}
|
||
else if (eCircle == eSect)
|
||
{
|
||
// 把圆按照最小分度角,分成几部分,取圆上点
|
||
double dMixAngle = TAuxTools::GetMinDiffAngle();
|
||
int nPart = 24;
|
||
dMixAngle = PI*2.0 / nPart;
|
||
|
||
ptTmp = ptCenter + vtDir * dWidth * 0.5;
|
||
arPoint.append(ptTmp);
|
||
for (int i = 0; i < nPart; i++)
|
||
{
|
||
ptTmp.rotateBy(dMixAngle, vtSect, ptCenter);
|
||
arPoint.append(ptTmp);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
BOOL ImpHvacReducer::MakeRect2Rect2DCurvesVer(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
AcGePoint3dArray arSta, arEnd;
|
||
GetOutVertex2(arSta, true);
|
||
GetOutVertex2(arEnd, false);
|
||
if (arSta.length() != arEnd.length()
|
||
|| arSta.length() != 6)
|
||
return FALSE;
|
||
|
||
double dEndWidht = GetEndLineWidth();
|
||
double dEdgeWidth = GetEdgeLineWidth();
|
||
AcDbObjectId idEndLayer;
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
|
||
|
||
AecCurveElement curEle;
|
||
curEle.bHided = FALSE;
|
||
curEle.dWidth = 0.0;
|
||
curEle.gsMark = 0;
|
||
curEle.idSubLay = m_idDoubleLayer;
|
||
|
||
{
|
||
curEle.idSubLay = idEndLayer;
|
||
curEle.dWidth = dEndWidht;
|
||
// 起点截面边线
|
||
int i = 0;
|
||
for (i = 1; i < arSta.length()-1; i++)
|
||
{
|
||
curEle.ptGe[0] = arSta[i];
|
||
curEle.ptGe[1] = arSta[i+1];
|
||
curEle.ptGe[2] = arSta[i+1];
|
||
cplCurve.append(curEle);
|
||
}
|
||
// 终点截面边线
|
||
for (i = 1; i < arSta.length()-1; i++)
|
||
{
|
||
curEle.ptGe[0] = arEnd[i];
|
||
curEle.ptGe[1] = arEnd[i+1];
|
||
curEle.ptGe[2] = arEnd[i+1];
|
||
cplCurve.append(curEle);
|
||
}
|
||
|
||
// 绘制两个截面顶点之间的连线
|
||
curEle.idSubLay.setNull();
|
||
curEle.dWidth = dEdgeWidth;
|
||
for (i = 1; i <= 4; i++)
|
||
{
|
||
curEle.ptGe[0] = arSta[i];
|
||
curEle.ptGe[1] = arEnd[i];
|
||
curEle.ptGe[2] = arEnd[i];
|
||
cplCurve.append(curEle);
|
||
}
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
// 垂直构建二维图形（方对圆）
|
||
BOOL ImpHvacReducer::MakeRect2Cir2DCurvesVer(AecComplexCurve& cplCurve, int &nType, BOOL bStartIsRound) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dStartDia = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dEndThick = MayAsMUnit(400.0);
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
if (bStartIsRound)
|
||
{
|
||
m_pXDataMap->GetAt(HRED_StartDiameter, dStartDia);
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
}
|
||
else
|
||
{
|
||
m_pXDataMap->GetAt(HRED_EndDiameter, dStartDia);
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HRED_StartThick, dEndThick);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptEnd);
|
||
}
|
||
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
|
||
|
||
AcDbObjectId idEndLayer;
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
|
||
|
||
// 计算顶点
|
||
AcGeVector3d vtSect = GetSectNormal();
|
||
AcGeVector3d vt = vtSect;
|
||
vt.rotateBy(PI / 2.0, vtNormal);
|
||
vt.normalize();
|
||
AcGePoint3dArray arStartPt;
|
||
AcGePoint3d ptCir = ptStart + dStartDia * vt / 2.0;
|
||
arStartPt.append(ptCir);
|
||
for (int i = 1; i < 8; i++)
|
||
{
|
||
ptCir.rotateBy(PI / 4.0, vtSect, ptStart);
|
||
arStartPt.append(ptCir);
|
||
}
|
||
arStartPt.append(ptStart + dStartDia * vt / 2.0);
|
||
AcGePoint3dArray arEndPt;
|
||
arEndPt.append(ptEnd + dEndWidth * vt / 2.0 - dEndThick * vtNormal / 2.0);
|
||
arEndPt.append(arEndPt.at(0) + dEndThick * vtNormal);
|
||
arEndPt.append(arEndPt.at(1) - dEndWidth * vt);
|
||
arEndPt.append(arEndPt.at(0) - dEndWidth * vt);
|
||
arEndPt.append(arEndPt.at(0));
|
||
|
||
AecCurveElement curEle;
|
||
curEle.bHided = FALSE;
|
||
curEle.dWidth = 0.0;
|
||
curEle.gsMark = 0;
|
||
curEle.idSubLay = m_idDoubleLayer;
|
||
// if (0 == nType)
|
||
{
|
||
curEle.dWidth = GetEdgeLineWidth();
|
||
for (i = 0; i < 4; i++)
|
||
{
|
||
curEle.ptGe[0] = arStartPt.at(2 * i);
|
||
curEle.ptGe[1] = arEndPt.at(i);
|
||
curEle.ptGe[2] = arEndPt.at(i);
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = arStartPt.at(2 * i);
|
||
curEle.ptGe[1] = arEndPt.at(i + 1);
|
||
curEle.ptGe[2] = arEndPt.at(i + 1);
|
||
cplCurve.append(curEle);
|
||
}
|
||
|
||
curEle.idSubLay = idEndLayer; // 两端图层
|
||
curEle.dWidth = GetEndLineWidth();
|
||
for (i = 0; i < 4; i++)
|
||
{
|
||
curEle.ptGe[0] = arStartPt.at(2 * i);
|
||
curEle.ptGe[1] = arStartPt.at(2 * i + 1);
|
||
curEle.ptGe[2] = arStartPt.at(2 * i + 2);
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = arEndPt.at(i);
|
||
curEle.ptGe[1] = arEndPt.at(i + 1);
|
||
curEle.ptGe[2] = arEndPt.at(i + 1);
|
||
cplCurve.append(curEle);
|
||
}
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
// 垂直构建二维图形（圆对方）
|
||
BOOL ImpHvacReducer::MakeCir2Rect2DCurvesVer(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
MakeRect2Cir2DCurvesVer(cplCurve, nType, TRUE);
|
||
return TRUE;
|
||
}
|
||
|
||
// 垂直构建二维图形（圆对圆）
|
||
BOOL ImpHvacReducer::MakeCir2Cir2DCurvesVer(AecComplexCurve& cplCurve, int &nType) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dStartDia = MayAsMUnit(200.0), dEndDia = MayAsMUnit(400.0);
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
|
||
m_pXDataMap->GetAt(HRED_StartDiameter, dStartDia);
|
||
m_pXDataMap->GetAt(HRED_EndDiameter, dEndDia);
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
|
||
AcDbObjectId idEndLayer;
|
||
m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
|
||
|
||
// 计算顶点
|
||
AcGeVector3d vtSect = GetSectNormal();
|
||
AcGeVector3d vt = vtSect;
|
||
vt.rotateBy(PI / 2.0, vtNormal);
|
||
vt.normalize();
|
||
AcGePoint3dArray arStartPt;
|
||
AcGePoint3d ptCir = ptStart + dStartDia * vt / 2.0;
|
||
arStartPt.append(ptCir);
|
||
for (int i = 1; i < 8; i++)
|
||
{
|
||
ptCir.rotateBy(PI / 4.0, vtSect, ptStart);
|
||
arStartPt.append(ptCir);
|
||
}
|
||
arStartPt.append(ptStart + dStartDia * vt / 2.0);
|
||
AcGePoint3dArray arEndPt;
|
||
ptCir = ptEnd + dEndDia * vt / 2.0;
|
||
arEndPt.append(ptCir);
|
||
for (i = 1; i < 8; i++)
|
||
{
|
||
ptCir.rotateBy(PI / 4.0, vtSect, ptEnd);
|
||
arEndPt.append(ptCir);
|
||
}
|
||
arEndPt.append(ptEnd + dEndDia * vt / 2.0);
|
||
|
||
AecCurveElement curEle;
|
||
curEle.bHided = FALSE;
|
||
curEle.dWidth = 0.0;
|
||
curEle.gsMark = 0;
|
||
curEle.idSubLay = m_idDoubleLayer;
|
||
|
||
if (0 == nType)
|
||
{
|
||
curEle.idSubLay = idEndLayer; // 两端图层
|
||
curEle.dWidth = GetEndLineWidth();
|
||
for (i = 0; i < 4; i++)
|
||
{
|
||
curEle.ptGe[0] = arStartPt.at(2 * i);
|
||
curEle.ptGe[1] = arStartPt.at(2 * i + 1);
|
||
curEle.ptGe[2] = arStartPt.at(2 * i + 2);
|
||
cplCurve.append(curEle);
|
||
curEle.ptGe[0] = arEndPt.at(2 * i);
|
||
curEle.ptGe[1] = arEndPt.at(2 * i + 1);
|
||
curEle.ptGe[2] = arEndPt.at(2 * i + 2);
|
||
cplCurve.append(curEle);
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
double ImpHvacReducer::GetEdgeLineWidth() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dWidth(0.0);
|
||
m_pXDataMap->GetAt(HVAC_EdgeWidth, dWidth);
|
||
|
||
return dWidth;
|
||
}
|
||
|
||
double ImpHvacReducer::GetCentLineWidth() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dWidth(0.0);
|
||
m_pXDataMap->GetAt(HVAC_CentWidth, dWidth);
|
||
|
||
return dWidth;
|
||
}
|
||
|
||
double ImpHvacReducer::GetEndLineWidth() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
double dWidth(0.0);
|
||
m_pXDataMap->GetAt(HVAC_EndWidth, dWidth);
|
||
|
||
return dWidth;
|
||
}
|
||
|
||
double ImpHvacReducer::GetPlusEdge() const
|
||
{
|
||
return 0.0;
|
||
}
|
||
|
||
AcGePoint3d ImpHvacReducer::GetEndPtAuto()
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtEnd, vtOffset;
|
||
double dPlus(0.0);
|
||
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_StartDir, vtEnd);
|
||
m_pXDataMap->GetAt(HRED_Offset, vtOffset);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlus);
|
||
vtEnd *= -1;
|
||
|
||
double dSizeSub = GetMaxSizeSub();
|
||
double dHoriLen = dSizeSub * 1.5 + MayAsMUnit(100);
|
||
|
||
if (dHoriLen < MayAsMUnit(200.0))
|
||
dHoriLen = MayAsMUnit(200.0);
|
||
|
||
ptEnd = ptStart + (dHoriLen + dPlus * 2) * vtEnd;
|
||
ptEnd += vtOffset;
|
||
|
||
return ptEnd;
|
||
}
|
||
|
||
// 不支持既不同心又没有一边对其情况心情况
|
||
AcGePoint3d ImpHvacReducer::GetEndPtByangle()
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtEnd, vtOffset;
|
||
double dSizeSub(0.0), dPlus(0.0), dAngle(0.0);
|
||
|
||
m_pXDataMap->GetAt(HRED_Angle, dAngle);
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_StartDir, vtEnd);
|
||
m_pXDataMap->GetAt(HRED_Offset, vtOffset);
|
||
m_pXDataMap->GetAt(HVAC_PlusEdge, dPlus);
|
||
dSizeSub = GetMaxSizeSub();
|
||
vtEnd *= -1;
|
||
|
||
double dHoriLen(0.0);
|
||
if (vtOffset.length() < 1e-3) // 同心
|
||
dHoriLen = dSizeSub * 0.5 / tan(dAngle*0.5);
|
||
else
|
||
dHoriLen = dSizeSub / tan(dAngle);
|
||
|
||
double dAllDist = dHoriLen + dPlus * 2;
|
||
if (dAllDist < MayAsMUnit(200)) // 避免天圆地方是看不出来
|
||
dAllDist = MayAsMUnit(200);
|
||
|
||
ptEnd = ptStart + dAllDist * vtEnd;
|
||
ptEnd += vtOffset;
|
||
|
||
return ptEnd;
|
||
}
|
||
|
||
AcGePoint3d ImpHvacReducer::GetEndPtByLen()
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
double dLen(0.0);
|
||
AcGePoint3d ptStart, ptEnd;
|
||
AcGeVector3d vtEnd, vtOffset;
|
||
|
||
m_pXDataMap->GetAt(HRED_Length, dLen);
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
m_pXDataMap->GetAt(HRED_StartDir, vtEnd);
|
||
vtEnd *= -1;
|
||
|
||
if (dLen < MayAsMUnit(200))
|
||
dLen = MayAsMUnit(200);
|
||
|
||
vtOffset = ptEnd - ptStart;
|
||
vtOffset = vtOffset.orthoProject(vtEnd);
|
||
|
||
ptEnd = ptStart + dLen * vtEnd;
|
||
ptEnd += vtOffset;
|
||
|
||
return ptEnd;
|
||
}
|
||
|
||
double ImpHvacReducer::GetMaxSizeSub()
|
||
{
|
||
ESection eStartSect = eRect;
|
||
ESection eEndSect = eRect;
|
||
double dStartWidth(0.0), dEndWidth(0.0), dStartThick(0.0), dEndThick(0.0),
|
||
dMaxSizeSub(0.0);
|
||
|
||
m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSect);
|
||
m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSect);
|
||
m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
|
||
m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
|
||
m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
|
||
m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
|
||
|
||
if (eStartSect == eEndSect)
|
||
{
|
||
double dWidthSub = fabs(dStartWidth - dEndWidth);
|
||
if (eStartSect == eRect)
|
||
{
|
||
double dThickSub = fabs(dStartThick - dEndThick);
|
||
dMaxSizeSub = dWidthSub > dThickSub ? dWidthSub:dThickSub;
|
||
}
|
||
else
|
||
{
|
||
dMaxSizeSub = dWidthSub;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (eStartSect == eRect)
|
||
{
|
||
double dWidthSub = fabs(dStartWidth - dEndWidth);
|
||
double dThickSub = fabs(dStartThick - dEndWidth);
|
||
dMaxSizeSub = dWidthSub > dThickSub ? dWidthSub:dThickSub;
|
||
}
|
||
else
|
||
{
|
||
double dWidthSub = fabs(dStartWidth - dEndWidth);
|
||
double dThickSub = fabs(dStartWidth - dEndThick);
|
||
dMaxSizeSub = dWidthSub > dThickSub ? dWidthSub:dThickSub;
|
||
}
|
||
}
|
||
return dMaxSizeSub;
|
||
}
|
||
|
||
AcGeVector3d ImpHvacReducer::normal() const
|
||
{
|
||
return AcGeVector3d::kZAxis;
|
||
}
|
||
|
||
BOOL ImpHvacReducer::GetInterfaceSizeData(int nIndex, AecInterface& inf) const
|
||
{
|
||
if(NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 获取截面类型
|
||
ESection eSectType = eRect;
|
||
|
||
// 获取接口截面、宽度、厚度数据key值
|
||
LPCTSTR pszWidthKey, pszThickKey;
|
||
switch (nIndex)
|
||
{
|
||
case 0:
|
||
m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSectType);
|
||
pszWidthKey = ((eCircle == eSectType) ? HRED_StartDiameter : HRED_StartWidth);
|
||
pszThickKey = HRED_StartThick;
|
||
break;
|
||
case 1:
|
||
m_pXDataMap->GetAt(HRED_EndSectType, (int&)eSectType);
|
||
pszWidthKey = ((eCircle == eSectType) ? HRED_EndDiameter : HRED_EndWidth);
|
||
pszThickKey = HRED_EndThick;
|
||
break;
|
||
default:
|
||
return FALSE;
|
||
}
|
||
|
||
// 获取尺寸
|
||
double dWidth = 0.0, dThick = 0.0;
|
||
m_pXDataMap->GetAt(pszWidthKey, dWidth);
|
||
m_pXDataMap->GetAt(pszThickKey, dThick);
|
||
|
||
// 设置接口数据
|
||
inf.nSectType = eSectType;
|
||
inf.dSize1 = dWidth;
|
||
inf.dSize2 = dThick;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
bool ImpHvacReducer::GetInterface(AcArray<AecInterface>& arInfs) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return false;
|
||
|
||
// 获取变径各点位置
|
||
AcGePoint3d ptStart, ptEnd;
|
||
m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
|
||
m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
|
||
|
||
// 求两端方向
|
||
AcGeVector3d vtStart = GetSectNormal();
|
||
AcGeVector3d vtEnd = -vtStart;
|
||
|
||
AecInterface inf;
|
||
inf.idOwner = m_pOwnerEnt->objectId();
|
||
for (int nIndex = 0;nIndex < 2;nIndex++)
|
||
{
|
||
switch(nIndex)
|
||
{
|
||
case 0:
|
||
{
|
||
inf.vtDir = vtStart;
|
||
inf.ptPos = ptStart;
|
||
GetInterfaceSizeData(nIndex, inf);
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
inf.vtDir = vtEnd;
|
||
inf.ptPos = ptEnd;
|
||
GetInterfaceSizeData(nIndex, inf);
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
arInfs.append(inf);
|
||
}
|
||
return true;
|
||
} |