8961 lines
198 KiB
C++
8961 lines
198 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbEcFitting.h"
|
|
#include "dbgrip.h"
|
|
#include "AecGripCback.h"
|
|
#include "MFCDbDwgFiler.h"
|
|
#include "GiDrawUtility.h"
|
|
#include "AecComplexCurveDraw.h"
|
|
#include "KTCADUtilityEx.h"
|
|
#include "KTSetting.h"
|
|
#include "AecDbEwPipeBase.h"
|
|
#include "AecDbEarthWorm.h"
|
|
#include "AecDbECableTray.h"
|
|
#include "AcGiViewDraw.h"
|
|
|
|
#ifndef WCAP_END_HR
|
|
#define WCAP_END_HR 0.2541
|
|
#endif
|
|
|
|
#ifndef MESH_N
|
|
#define MESH_N 20
|
|
#endif
|
|
|
|
#define CAPENDRADIUS 0.254
|
|
|
|
static const Adesk::UInt16 kColorByBlock = 0;
|
|
static const Adesk::UInt16 kRed = 1;
|
|
static const Adesk::UInt16 kYellow = 2;
|
|
static const Adesk::UInt16 kGreen = 3;
|
|
static const Adesk::UInt16 kCyan = 4;
|
|
static const Adesk::UInt16 kBlue = 5;
|
|
static const Adesk::UInt16 kMagenta = 6;
|
|
static const Adesk::UInt16 kWhite = 7;
|
|
static const Adesk::UInt16 kColorByLayer = 256;
|
|
|
|
extern CString IDCreate();
|
|
extern double PixelToWcs(int nPixel);
|
|
extern BOOL Is2DView();
|
|
extern AcGeVector3d GetUcsZvt();
|
|
extern AcDbCurve* FormatPolyline(AcDbCurve* pBaseCur);
|
|
extern void PushGripMessage(GripMessage&);
|
|
|
|
extern AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);
|
|
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
|
|
extern AcDbArc* FormatArc(AcGePoint3d& ptGe1,AcGePoint3d& ptGe2,AcGePoint3d& ptGe3);
|
|
extern AcDbRegion* PolylineToRegion( AcDbPolyline* pPl);
|
|
extern AcDb3dPolyline* Format3dPolyline(const AcGePoint3dArray& arPts);
|
|
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb = NULL,bool bClose = true);
|
|
extern bool MakeBlockRefSet(AcDbVoidPtrArray &arEntPtrs, const AcDbObjectId &idLay, Adesk::Boolean bDoSubent, LPCTSTR pszName, AcDbDatabase *pDb = NULL);
|
|
extern AcDbCurve *GetMaxOffsetCurve(AcDbCurve *pPl, double dOff);
|
|
|
|
static void FreeBuffer(int n,AcDbVoidPtrArray& arEntPtrs)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
while(arEntPtrs.length() > n )
|
|
{
|
|
pEnt = (AcDbEntity*)arEntPtrs.last();
|
|
if (pEnt != NULL)
|
|
{
|
|
pEnt->erase();
|
|
pEnt->close();
|
|
arEntPtrs.removeLast();
|
|
DELETE_PTR(pEnt);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void MoveRegion(const AcGeVector3d& vt, AcDbRegion* pReg)
|
|
{
|
|
if (pReg != NULL)
|
|
{
|
|
AcGeMatrix3d xm;
|
|
xm.setTranslation(vt);
|
|
pReg->transformBy(xm);
|
|
}
|
|
}
|
|
|
|
static void TestPoint(AcGePoint3d *pptGe, int nCount, Adesk::Int16 nColor)
|
|
{
|
|
AcDbPolyline *pPl = new AcDbPolyline;
|
|
for (int i = 0; i < nCount; i++)
|
|
{
|
|
pPl->addVertexAt(i, pptGe[i].convert2d(AcGePlane::kXYPlane));
|
|
}
|
|
pPl->setColorIndex(nColor);
|
|
AddToModelSpace(pPl);
|
|
}
|
|
|
|
static void OffsetPoint(AcGePoint3d& pt1,AcGePoint3d& pt2,double dThick)
|
|
{
|
|
AcGeVector3d vt = pt2 - pt1;
|
|
vt.normalize();
|
|
|
|
pt1 += vt * dThick;
|
|
pt2 -= vt * dThick;
|
|
}
|
|
|
|
static double AsDNUnit(double dVal)
|
|
{
|
|
struct resbuf rb;
|
|
acedGetVar(_T("INSUNITS"), &rb);
|
|
if (rb.resval.rint == AcDb::kUnitsMeters)
|
|
{
|
|
dVal *= 0.001;
|
|
}
|
|
return dVal;
|
|
}
|
|
|
|
static double GetElbowL(AecHvac::DuctParam *pParam)
|
|
{
|
|
double dL = 0.0;
|
|
if (pParam->eType == eCircle)
|
|
dL = pParam->dSize[0];
|
|
|
|
double dD = __max(pParam->dSize[3], pParam->dSize[0]);
|
|
|
|
double dRatio = pParam->m_dRatio;
|
|
double dLx = (int)(dRatio * dD / 3.0 + 0.5);//默认50
|
|
if (dLx > AsDNUnit(50.0))
|
|
dLx = AsDNUnit(50.0);
|
|
dL = dRatio * dD + dLx;
|
|
return dL;
|
|
}
|
|
|
|
static double GetElbowLx(AecHvac::DuctParam *pParam)
|
|
{
|
|
double dD = __max(pParam->dSize[3], pParam->dSize[0]);
|
|
double dRatio = pParam->m_dRatio;
|
|
double dLx = (int)(dRatio * dD / 3.0 + 0.5);//默认50
|
|
if (dLx > AsDNUnit(50.0))
|
|
dLx = AsDNUnit(50.0);
|
|
|
|
if (pParam->eType == eCircle)
|
|
dLx = AsDNUnit(50.0);
|
|
|
|
return dLx;
|
|
}
|
|
|
|
static AcGePoint3d GetIntersectPt(AcGePoint3d &ptGe3, AcGeVector3d &vtMin, AcGePoint3d &ptGe5, AcGeVector3d &vtMaj)
|
|
{
|
|
AcGePoint3d ptGe4 = MidPoint(ptGe3, ptGe5);
|
|
AcGeLine3d ln3(ptGe3, vtMin);
|
|
AcGeLine3d ln4(ptGe5, vtMaj);
|
|
ln3.intersectWith(ln4, ptGe4);
|
|
return ptGe4;
|
|
}
|
|
|
|
Adesk::UInt32 AecDbEcFitting::kCurrentVersionNumber = 2;//升级
|
|
ACRX_DXF_DEFINE_MEMBERS (AecDbEcFitting, AecDbEntityBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_DBECFIT,
|
|
"AecDbEcFitting"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
AecDbEcFitting::AecDbEcFitting(void)
|
|
{
|
|
m_nInfActive = -1;
|
|
m_bActive = false;
|
|
m_sGUID = IDCreate();
|
|
m_pGripAppData = new AecGripData[GRIP_MAXNUM];
|
|
m_mapSpecXData.SetAt(KEY_NO,m_sGUID);
|
|
}
|
|
|
|
AecDbEcFitting::~AecDbEcFitting(void)
|
|
{
|
|
Clean3DBuffer();
|
|
Clean2DBuffer();
|
|
FreeBuffer(0,m_arDrawBuffer3d1);
|
|
FreeBuffer(0,m_arDrawBuffer3d2);
|
|
delete [] m_pGripAppData;
|
|
}
|
|
|
|
bool AecDbEcFitting::SetDuctParam(const AecHvac::DuctParam& data)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
double dL = 0.0,dW = 0.0,dt = 0.0;
|
|
double dD = 0.0;
|
|
m_mapSpecXData.SetAt(KEY_SECSHAPE,(int)data.eType);
|
|
|
|
m_mapSpecXData.SetAt(KEY_APP, data.m_app);
|
|
if (data.m_app == WPipe::eTrench)
|
|
{
|
|
m_mapSpecXData.SetAt(KEY_HIDESTART, 1);
|
|
m_mapSpecXData.SetAt(KEY_HIDEEND, 1);
|
|
m_mapSpecXData.SetAt(PIPE_DRAWDIR, WPipe::eID);
|
|
|
|
//m_mapSpecXData.SetAt(PIPE_OD, data.dSize[0] + 2.0 * data.dSize[2]);
|
|
//m_mapSpecXData.SetAt(PIPE_THICK, data.dSize[2]);
|
|
}
|
|
|
|
if (data.m_app == WPipe::eBridge)
|
|
{
|
|
double dL0 = 0, dW0 = 0;
|
|
m_mapSpecXData.GetAt(KEY_SIZE1, dL0);
|
|
m_mapSpecXData.GetAt(KEY_SIZE2, dW0);
|
|
|
|
double dUse1 = 0, dUse2 = 0;
|
|
m_mapSpecXData.GetAt(KEY_FILLUSED, dUse1);//0.55
|
|
m_mapSpecXData.GetAt(KEY_FILLUSED, dUse2);//0.45
|
|
|
|
BOOL bSpart = 0;
|
|
m_mapSpecXData.GetAt(KEY_SPART, bSpart);
|
|
|
|
if (dUse1 > 1.e-3 && !bSpart)//有填充率
|
|
{
|
|
double dAreaUsedOld = dUse1 * dL0 * dW0;
|
|
double dAreaNewSet = dAreaUsedOld / (data.dSize[0] * data.dSize[1]);
|
|
m_mapSpecXData.SetAt(KEY_FILLUSED, dAreaNewSet);//0.55
|
|
}
|
|
else if (dUse1 > 1.e-3 && dUse2 > 1.e-3 && bSpart)
|
|
{
|
|
double dAreaUsedOld = dUse1 * dL0 * dW0 * 0.5;
|
|
double dAreaNewSet = dAreaUsedOld / (data.dSize[0] * data.dSize[1] * 0.5);
|
|
m_mapSpecXData.SetAt(KEY_FILLUSED, dAreaNewSet);//0.55
|
|
|
|
dAreaUsedOld = dUse2 * dL0 * dW0 * 0.5;
|
|
dAreaNewSet = dAreaUsedOld / (data.dSize[0] * data.dSize[1] * 0.5);
|
|
m_mapSpecXData.SetAt(KEY_FILLUSED, dAreaNewSet);//0.45
|
|
}
|
|
}
|
|
|
|
bool bSet = true;
|
|
switch(data.eType)
|
|
{
|
|
case eRect:
|
|
{
|
|
dL = data.dSize[0];
|
|
dW = data.dSize[1];
|
|
dt = data.dSize[2];
|
|
|
|
if (dL > 1.e-6 && dW > 1.e-6 && dt > 1.e-6)
|
|
{
|
|
m_mapSpecXData.SetAt(KEY_SIZE1,data.dSize[0]); //L
|
|
m_mapSpecXData.SetAt(KEY_SIZE2,data.dSize[1]); //w
|
|
m_mapSpecXData.SetAt(PIPE_THICK,data.dSize[2]);//t
|
|
m_mapSpecXData.SetAt(KEY_SIZE3,data.dSize[3]);//w1,三通,变径用 分支
|
|
m_mapSpecXData.SetAt(KEY_MATERIAL,data.szMat);
|
|
m_mapSpecXData.SetAt(KEY_FACTORY,data.szFat);
|
|
m_mapSpecXData.SetAt(KEY_CENNODRAW,!data.m_bCenDraw);//中心线
|
|
m_mapSpecXData.SetAt(KEY_L,data.m_dL);
|
|
m_mapSpecXData.SetAt(KEY_RRATIO,data.m_dRatio);
|
|
m_mapSpecXData.SetAt(KEY_FULLPER,data.m_dFullPer);
|
|
m_mapSpecXData.SetAt(KEY_SN,data.szNo);
|
|
m_mapSpecXData.SetAt(KEY_TYPE,data.szType);
|
|
m_mapSpecXData.SetAt(KEY_EXT,data.szExt);
|
|
m_mapSpecXData.SetAt(KEY_COVER,data.m_bCover);
|
|
m_mapSpecXData.SetAt(KEY_SPART,data.m_bSpart);
|
|
m_mapSpecXData.SetAt(KEY_SYSSPLT, data.m_nSysSplit);
|
|
m_mapSpecXData.SetAt(PIPE_SYS,data.szSys);
|
|
m_mapSpecXData.SetAt(KEY_REM,data.szRem);
|
|
|
|
bSet = true;
|
|
}
|
|
break;
|
|
}
|
|
case eCircle:
|
|
{
|
|
dD = data.dSize[0];
|
|
dt = data.dSize[1];
|
|
|
|
if (dD > 1.e-6 && dt > 1.e-6)
|
|
{
|
|
m_mapSpecXData.SetAt(KEY_SIZE1,data.dSize[0]); //D
|
|
m_mapSpecXData.SetAt(KEY_SIZE2,data.dSize[1]); //D
|
|
m_mapSpecXData.SetAt(PIPE_THICK,data.dSize[2]);//t
|
|
m_mapSpecXData.SetAt(KEY_SIZE3,data.dSize[3]);//w1,变径用
|
|
m_mapSpecXData.SetAt(KEY_MATERIAL,data.szMat);
|
|
m_mapSpecXData.SetAt(KEY_FACTORY,data.szFat);
|
|
m_mapSpecXData.SetAt(KEY_CENNODRAW,!data.m_bCenDraw);//中心线
|
|
m_mapSpecXData.SetAt(KEY_L,data.m_dL);
|
|
m_mapSpecXData.SetAt(KEY_RRATIO,data.m_dRatio);
|
|
m_mapSpecXData.SetAt(KEY_FULLPER,data.m_dFullPer);
|
|
m_mapSpecXData.SetAt(KEY_SN,data.szNo);
|
|
m_mapSpecXData.SetAt(KEY_TYPE,data.szType);
|
|
m_mapSpecXData.SetAt(KEY_EXT,data.szExt);
|
|
m_mapSpecXData.SetAt(KEY_COVER,data.m_bCover);
|
|
m_mapSpecXData.SetAt(KEY_SPART,data.m_bSpart);
|
|
m_mapSpecXData.SetAt(KEY_SYSSPLT, data.m_nSysSplit);
|
|
m_mapSpecXData.SetAt(PIPE_SYS,data.szSys);
|
|
m_mapSpecXData.SetAt(KEY_REM,data.szRem);
|
|
|
|
bSet = true;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
m_mapSpecXData.SetAt(KEY_WELLW, data.dSize[4]);
|
|
|
|
//保存预留数据 电缆沟等用
|
|
CString sKey;
|
|
for (int i = 5; i < 33; i++)//
|
|
{
|
|
sKey.Format(_T("%s_%d"), KEY_SIZE, i);
|
|
m_mapSpecXData.SetAt(sKey, data.dSize[i]);
|
|
}
|
|
|
|
return bSet;
|
|
}
|
|
|
|
void AecDbEcFitting::GetDuctParam(AecHvac::DuctParam& data) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
memset(&data,0,sizeof(AecHvac::DuctParam));
|
|
|
|
int nType = 0;
|
|
m_mapSpecXData.GetAt(KEY_SECSHAPE,nType);
|
|
|
|
int nCenNDraw = 0;
|
|
|
|
ESection eType = (ESection)nType;
|
|
data.eType = eType;
|
|
|
|
data.m_app = WPipe::eBridge;
|
|
int nApp = 7;
|
|
m_mapSpecXData.GetAt(KEY_APP, nApp);
|
|
data.m_app = WPipe::EApp(nApp);
|
|
if (nApp == 0)
|
|
data.m_app = WPipe::eBridge;
|
|
|
|
switch(eType)
|
|
{
|
|
case eRect:
|
|
{
|
|
m_mapSpecXData.GetAt(KEY_SIZE1,data.dSize[0]); //L
|
|
m_mapSpecXData.GetAt(KEY_SIZE2,data.dSize[1]); //w
|
|
m_mapSpecXData.GetAt(PIPE_THICK,data.dSize[2]);//t
|
|
m_mapSpecXData.GetAt(KEY_SIZE3,data.dSize[3]);//L2 支宽
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);//中心线
|
|
data.m_bCenDraw = nCenNDraw ? FALSE : TRUE;
|
|
data.eType = eRect;
|
|
break;
|
|
}
|
|
case eCircle:
|
|
{
|
|
m_mapSpecXData.GetAt(KEY_SIZE1,data.dSize[0]); //D
|
|
m_mapSpecXData.GetAt(KEY_SIZE2,data.dSize[1]); //D
|
|
m_mapSpecXData.GetAt(PIPE_THICK,data.dSize[2]);//t
|
|
m_mapSpecXData.GetAt(KEY_SIZE3,data.dSize[3]);//L2 支宽
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);//中心线
|
|
data.m_bCenDraw = nCenNDraw ? FALSE : TRUE;
|
|
data.eType = eCircle;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
m_mapSpecXData.GetAt(KEY_WELLW, data.dSize[4]);
|
|
m_mapSpecXData.GetAt(KEY_RRATIO,data.m_dRatio);
|
|
|
|
m_mapSpecXData.GetAt(KEY_FULLPER, data.m_dFullPer);
|
|
data.m_dFillUsed = 0;
|
|
//m_mapSpecXData.GetAt(KEY_FILLUSED, data.m_dFillUsed);
|
|
|
|
m_mapSpecXData.GetAt(KEY_FULLPER2, data.m_dFullPer2);
|
|
data.m_dFillUsed2 = 0;
|
|
//m_mapSpecXData.GetAt(KEY_FILLUSED2, data.m_dFillUsed2);
|
|
|
|
m_mapSpecXData.GetAt(KEY_L,data.m_dL);//变径长 L
|
|
|
|
data.m_vtNrom = GetNormal();
|
|
data.m_nAlign = 1;//居中
|
|
|
|
CString sTemp;
|
|
m_mapSpecXData.GetAt(KEY_SN,sTemp);
|
|
_tcscpy(data.szNo,(LPCTSTR)sTemp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_TYPE,sTemp);
|
|
_tcscpy(data.szType,(LPCTSTR)sTemp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_EXT,sTemp);
|
|
_tcscpy(data.szExt,(LPCTSTR)sTemp);
|
|
|
|
m_mapSpecXData.GetAt(PIPE_SYS,sTemp);
|
|
_tcscpy(data.szSys,(LPCTSTR)sTemp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_COVER,data.m_bCover);
|
|
m_mapSpecXData.GetAt(KEY_SPART,data.m_bSpart);
|
|
m_mapSpecXData.GetAt(KEY_SYSSPLT, data.m_nSysSplit);
|
|
|
|
m_mapSpecXData.GetAt(KEY_MATERIAL,sTemp);
|
|
_tcscpy(data.szMat,(LPCTSTR)sTemp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_FACTORY,sTemp);
|
|
_tcscpy(data.szFat,(LPCTSTR)sTemp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_REM,sTemp);
|
|
_tcscpy(data.szRem,(LPCTSTR)sTemp);
|
|
|
|
//提取预留数据 电缆沟等用
|
|
CString sKey;
|
|
for (int i = 5; i < 33; i++)//
|
|
{
|
|
sKey.Format(_T("%s_%d"), KEY_SIZE, i);
|
|
m_mapSpecXData.GetAt(sKey, data.dSize[i]);
|
|
}
|
|
}
|
|
|
|
bool AecDbEcFitting::GetDlgData(DlgData &data,BOOL bIsMajOrMin) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecHvac::DuctParam param;
|
|
memset(¶m, 0, sizeof(AecHvac::DuctParam));
|
|
GetDuctParam(param);
|
|
|
|
m_mapSpecXData.GetAt(KEY_KIND, data.m_sGKind);
|
|
m_mapSpecXData.GetAt(KEY_RRATIO, data.m_dRatio);
|
|
|
|
if (bIsMajOrMin == 0)//主
|
|
{
|
|
data.m_dTopEl = param.dSize[11];
|
|
data.m_bHasCover = param.m_bCover;
|
|
data.m_dW = param.dSize[4];
|
|
data.m_dH = param.dSize[5];
|
|
data.m_dt = param.dSize[6];
|
|
data.m_db = param.dSize[7];
|
|
data.m_dd = param.dSize[8];
|
|
data.m_dh2 = param.dSize[9];
|
|
data.m_dk = param.dSize[10];
|
|
}
|
|
else//支
|
|
{
|
|
data.m_dTopEl = param.dSize[11];
|
|
data.m_bHasCover = param.m_bCover;
|
|
data.m_dW = param.dSize[12];
|
|
data.m_dH = param.dSize[13];
|
|
data.m_dt = param.dSize[14];
|
|
data.m_db = param.dSize[15];
|
|
data.m_dd = param.dSize[16];
|
|
data.m_dh2 = param.dSize[17];
|
|
data.m_dk = param.dSize[18];
|
|
|
|
if (data.m_dW < 1.e-1)//没有分支
|
|
{
|
|
data.m_dTopEl = param.dSize[11];
|
|
data.m_bHasCover = param.m_bCover;
|
|
data.m_dW = param.dSize[4];
|
|
data.m_dH = param.dSize[5];
|
|
data.m_dt = param.dSize[6];
|
|
data.m_db = param.dSize[7];
|
|
data.m_dd = param.dSize[8];
|
|
data.m_dh2 = param.dSize[9];
|
|
data.m_dk = param.dSize[10];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool AecDbEcFitting::SetXHolder(EAlign kPos, XHolder &xH)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
switch (kPos)
|
|
{
|
|
case kLeft:
|
|
{
|
|
m_mapSpecXData.SetAt(KEY_LEFT, &xH, sizeof(XHolder));
|
|
break;
|
|
}
|
|
case kRight:
|
|
{
|
|
m_mapSpecXData.SetAt(KEY_RIGHT, &xH, sizeof(XHolder));
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AecDbEcFitting::GetXHolder(EAlign kPos, XHolder &xH) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int nSize1 = sizeof(XHolder);
|
|
int nSize2 = 0;
|
|
XHolder *pHolder = NULL;
|
|
|
|
switch (kPos)
|
|
{
|
|
case kLeft:
|
|
{
|
|
if (!m_mapSpecXData.GetAt(KEY_LEFT, (void *&)pHolder, nSize2))
|
|
return false;
|
|
|
|
if (nSize2 == nSize1 && pHolder != NULL)
|
|
{
|
|
memcpy(&xH, pHolder, nSize1);
|
|
delete pHolder;
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
case kRight:
|
|
{
|
|
if (!m_mapSpecXData.GetAt(KEY_RIGHT, (void *&)pHolder, nSize2))
|
|
return false;
|
|
|
|
if (nSize2 == nSize1 && pHolder != NULL)
|
|
{
|
|
memcpy(&xH, pHolder, nSize1);
|
|
delete pHolder;
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void AecDbEcFitting::SetSingleLayer(AcDbObjectId& idLayer)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_idSingleLayer = idLayer;
|
|
}
|
|
|
|
AcDbObjectId AecDbEcFitting::GetSingleLayer() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_idSingleLayer;
|
|
}
|
|
|
|
void AecDbEcFitting::SetSingleLineType(AcDbObjectId& idLt)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_idSingleLnType = idLt;
|
|
}
|
|
|
|
AcDbObjectId AecDbEcFitting::GetSingleLineType() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_idSingleLnType;
|
|
}
|
|
|
|
void AecDbEcFitting::SetDoubleLayer(AcDbObjectId& idLayer)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_idDoubleLayer = idLayer;
|
|
}
|
|
|
|
AcDbObjectId AecDbEcFitting::GetDoubleLayer() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_idDoubleLayer;
|
|
}
|
|
|
|
void AecDbEcFitting::SetDoubleLineType(AcDbObjectId& idLt)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_idDoubleLnType = idLt;
|
|
}
|
|
|
|
AcDbObjectId AecDbEcFitting::GetDoubleLineType() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_idDoubleLnType;
|
|
}
|
|
|
|
void AecDbEcFitting::SetDashLayer(AcDbObjectId &idLayer)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_idDashLayer = idLayer;
|
|
}
|
|
|
|
AcDbObjectId AecDbEcFitting::GetDashLayer() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_idDashLayer;
|
|
}
|
|
|
|
void AecDbEcFitting::SetCenterLayer(AcDbObjectId& idLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idCenterLayer = idLayer;
|
|
}
|
|
|
|
AcDbObjectId AecDbEcFitting::GetCenterLayer() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_idCenterLayer;
|
|
}
|
|
|
|
void AecDbEcFitting::AssertWriteEnabled(Adesk::Boolean autoUndo,Adesk::Boolean recordModified )
|
|
{
|
|
//if (objectId().isValid())
|
|
{
|
|
//FreeBuffer(0,m_ar2DDrableBufPtrs);
|
|
//FreeBuffer(0,m_ar3DDrableBufPtrs);
|
|
//m_ar3DDrableBufPtrs.removeAll();
|
|
|
|
Clean3DBuffer();
|
|
Clean2DBuffer();
|
|
|
|
//m_ar2DDrableBufPtrs.removeAll();
|
|
|
|
AecDbEntityBase::AssertWriteEnabled(autoUndo, recordModified);
|
|
//assertWriteEnabled();
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::dwgInFields(AcDbDwgFiler* pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
|
|
{
|
|
es = AecDbEntityBase::dwgInFields (pFiler) ;
|
|
if ( es != Acad::eOk )
|
|
return (es) ;
|
|
}
|
|
|
|
//----- Object version number needs to be read first
|
|
Adesk::UInt32 version =0 ;
|
|
if ( (es = pFiler->readUInt32 (&version)) != Acad::eOk )
|
|
return (es) ;
|
|
|
|
if ( version > AecDbEcFitting::kCurrentVersionNumber )
|
|
return (Acad::eMakeMeProxy);
|
|
|
|
m_mapSpecXData.dwgInFields(pFiler);
|
|
|
|
pFiler->readInt16(&m_nInfActive);
|
|
|
|
TCHAR* pszTmp = NULL;
|
|
pFiler->readString(&pszTmp);
|
|
if (pszTmp != NULL)
|
|
{
|
|
m_sGUID = pszTmp;
|
|
}
|
|
|
|
pFiler->readSoftPointerId((AcDbSoftPointerId*)&m_idSingleLayer);
|
|
pFiler->readSoftPointerId((AcDbSoftPointerId*)&m_idSingleLnType);
|
|
|
|
pFiler->readSoftPointerId((AcDbSoftPointerId*)&m_idDoubleLayer);
|
|
pFiler->readSoftPointerId((AcDbSoftPointerId*)&m_idDoubleLnType);
|
|
|
|
if (version > 1)
|
|
{
|
|
ReadUserInterface(pFiler);
|
|
}
|
|
|
|
return (pFiler->filerStatus());
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
|
|
{
|
|
es = AecDbEntityBase::dwgOutFields (pFiler) ;
|
|
if ( es != Acad::eOk )
|
|
return (es) ;
|
|
}
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ( (es =pFiler->writeUInt32 (AecDbEcFitting::kCurrentVersionNumber)) != Acad::eOk )
|
|
return (es) ;
|
|
|
|
m_mapSpecXData.dwgOutFields(pFiler);
|
|
|
|
pFiler->writeInt16(m_nInfActive);
|
|
pFiler->writeString((LPCTSTR)m_sGUID);
|
|
|
|
pFiler->writeSoftPointerId(m_idSingleLayer);
|
|
pFiler->writeSoftPointerId(m_idSingleLnType);
|
|
|
|
pFiler->writeSoftPointerId(m_idDoubleLayer);
|
|
pFiler->writeSoftPointerId(m_idDoubleLnType);
|
|
|
|
WriteUserInterface(pFiler);
|
|
|
|
return (pFiler->filerStatus());
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::dxfInFields(AcDbDxfFiler* pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbEcFitting::SetActive(bool bActive)
|
|
{
|
|
assertWriteEnabled();
|
|
m_bActive = bActive;
|
|
}
|
|
|
|
bool AecDbEcFitting::IsActive() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_bActive;
|
|
}
|
|
|
|
void AecDbEcFitting::NewGUID()
|
|
{
|
|
assertWriteEnabled();
|
|
m_sGUID = IDCreate();
|
|
}
|
|
|
|
void AecDbEcFitting::subList() const
|
|
{
|
|
assertReadEnabled();
|
|
AecDbEntityBase::subList();
|
|
|
|
acutPrintf(_T("\n桥架连接件:"));
|
|
AcArray<AecInterface> arInf;
|
|
GetInterface(arInf);
|
|
|
|
for (int i = 0;i < arInf.length();i++)
|
|
{
|
|
AecInterface &inf = arInf.at(i);
|
|
acutPrintf(_T("\nInf%d : pt = (%.3f,%.3f,%.3f) size = %.3f,%.3f"), i + 1, inf.ptPos.x, inf.ptPos.y, inf.ptPos.z, inf.dSize1, inf.dSize2);
|
|
}
|
|
|
|
acutPrintf(_T("\n属性数据:"));
|
|
m_mapSpecXData.List();
|
|
acutPrintf(_T("\n"));
|
|
}
|
|
|
|
bool AecDbEcFitting::GetBimInfoTip(CString& sInfoTip) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecHvac::DuctParam data;
|
|
memset(&data,0,sizeof(AecHvac::DuctParam));
|
|
|
|
GetDuctParam(data);
|
|
|
|
CString sField,sFmt;
|
|
sField = _T("桥架:\n");
|
|
sInfoTip += sField;
|
|
|
|
MAKEFIELD(_T("类型"),_T("%s"),data.szType,sInfoTip);
|
|
|
|
MAKEFIELD(_T("宽度"),_T("%d"),(int)(data.dSize[0]+0.5),sInfoTip);
|
|
MAKEFIELD(_T("高度"),_T("%d"),(int)(data.dSize[1]+0.5),sInfoTip);
|
|
|
|
MAKEFIELD(_T("板材厚度"),_T("%.1f"),data.dSize[2],sInfoTip);
|
|
|
|
MAKEFIELD(_T("底标高"),_T("%.1f"),data.m_dEl - 0.5 * data.dSize[1],sInfoTip);
|
|
|
|
MAKEFIELD(_T("系统"),_T("%s"),data.szSys,sInfoTip);
|
|
|
|
MAKEFIELD(_T("材料"),_T("%s"),data.szMat,sInfoTip);
|
|
|
|
MAKEFIELD(_T("厂家"),_T("%s"),data.szFat,sInfoTip);
|
|
|
|
MAKEFIELD(_T("编号"),_T("%s"),data.szNo,sInfoTip);
|
|
|
|
return true;
|
|
}
|
|
|
|
//设置 加 减 填充率
|
|
extern bool IsSameAsSysUse(LPCTSTR pszSys1, LPCTSTR pszSysD);
|
|
bool AecDbEcFitting::SendUserData(struct resbuf *pRb)
|
|
{
|
|
//解析 是 int-sys-double
|
|
if (pRb != NULL)
|
|
{
|
|
CString sSys;
|
|
double dD = 0;
|
|
int nAddOrSub = 1;
|
|
|
|
struct resbuf *pRb1 = pRb->rbnext;
|
|
struct resbuf *pRb2 = NULL;
|
|
if (pRb1 != NULL)
|
|
{
|
|
pRb2 = pRb1->rbnext;
|
|
}
|
|
|
|
bool bYs = false;
|
|
if (pRb1 != NULL && pRb2 != NULL)
|
|
{
|
|
if (pRb->restype == AcDb::kDxfXdInteger16)
|
|
{
|
|
nAddOrSub = pRb->resval.rint ? -1 : 1;
|
|
bYs = true;
|
|
}
|
|
else
|
|
{
|
|
bYs = false;
|
|
}
|
|
|
|
if (pRb1->restype == kDxfXdAsciiString)
|
|
{
|
|
sSys = pRb1->resval.rstring;
|
|
bYs = true;
|
|
}
|
|
else
|
|
{
|
|
bYs = false;
|
|
}
|
|
|
|
if (pRb2->restype == AcDb::kDxfReal)
|
|
{
|
|
dD = pRb2->resval.rreal;
|
|
bYs = true;
|
|
}
|
|
else
|
|
{
|
|
bYs = false;
|
|
}
|
|
|
|
if (bYs)
|
|
{
|
|
double dFillUsed = 0.0, dThisUsed = 0;
|
|
CString sSys2, sSysData = sSys;
|
|
double dSCab = 0.25 * PI * dD * dD;
|
|
|
|
struct resbuf rb;
|
|
acedGetVar(_T("INSUNITS"), &rb);
|
|
if (rb.resval.rint == AcDb::kUnitsMeters)
|
|
{
|
|
dSCab *= 1.e-6;
|
|
}
|
|
|
|
AecDbObjXDataMap *pDataMap = GetSpecialtyData(AcDb::kForWrite);
|
|
|
|
DlgData dlgData;
|
|
if (!GetDlgData(dlgData))
|
|
{
|
|
AecHvac::DuctParam param;
|
|
GetDuctParam(param);
|
|
|
|
if (param.m_bSpart)//有隔板
|
|
{
|
|
//隔板系统分类
|
|
//param.m_nSysSplit;
|
|
//判断
|
|
CString sSyss = param.szSys;
|
|
sSyss.TrimRight();
|
|
int nPos = sSyss.Find(_T('|'), 0);
|
|
if (nPos != -1)
|
|
{
|
|
sSys = sSyss.Mid(0, nPos);
|
|
if (nPos < sSyss.GetLength() - 1)
|
|
{
|
|
sSys2 = sSyss.Mid(nPos + 1);
|
|
}
|
|
|
|
if (IsSameAsSysUse(sSys, sSysData))
|
|
//if (sSysData.Find(sSys) != -1)//走左侧层
|
|
{
|
|
//...
|
|
dFillUsed = 0.0;
|
|
pDataMap->GetAt(KEY_FILLUSED, dFillUsed);//0.65
|
|
|
|
//面积 / 总面积 = 0.15
|
|
dThisUsed = dSCab;
|
|
dThisUsed /= (param.dSize[4]) * param.dSize[1];
|
|
|
|
//ext.累加 0.45 + 0.15
|
|
dFillUsed += dThisUsed * nAddOrSub;
|
|
pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
|
|
}
|
|
//else if (sSysData.Find(sSys2) != -1)//走右侧层
|
|
else if (IsSameAsSysUse(sSys2, sSysData))
|
|
{
|
|
//...
|
|
dFillUsed = 0.0;
|
|
pDataMap->GetAt(KEY_FILLUSED2, dFillUsed);
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dThisUsed = dSCab;
|
|
dThisUsed /= (param.dSize[0] - param.dSize[4]) * param.dSize[1];
|
|
|
|
//ext.累加 0.45 + 0.15
|
|
dFillUsed += dThisUsed * nAddOrSub;
|
|
pDataMap->SetAt(KEY_FILLUSED2, dFillUsed);
|
|
}
|
|
else//都没有找到,走单层
|
|
{
|
|
//...
|
|
dFillUsed = 0.0;
|
|
pDataMap->GetAt(KEY_FILLUSED, dFillUsed);
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dThisUsed = dSCab;
|
|
dThisUsed /= param.dSize[0] * param.dSize[1];
|
|
|
|
//ext.累加 0.45 + 0.15
|
|
dFillUsed += dThisUsed * nAddOrSub;
|
|
pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
|
|
}
|
|
}
|
|
else//有隔板,没有分层系统,走单层
|
|
{
|
|
dFillUsed = 0.0;
|
|
pDataMap->GetAt(KEY_FILLUSED, dFillUsed);
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dThisUsed = dSCab;
|
|
dThisUsed /= param.dSize[0] * param.dSize[1];
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dFillUsed += dThisUsed * nAddOrSub;
|
|
pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dFillUsed = 0.0;
|
|
pDataMap->GetAt(KEY_FILLUSED, dFillUsed);
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dThisUsed = dSCab;
|
|
dThisUsed /= param.dSize[0] * param.dSize[1];
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dFillUsed += dThisUsed * nAddOrSub;
|
|
pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::copyFrom(const AcRxObject* pSrc)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AecDbEcFitting* pFit = AecDbEcFitting::cast(pSrc);
|
|
if (pFit != NULL)
|
|
{
|
|
m_mapSpecXData.Empty();
|
|
m_mapSpecXData.CopyFrom(&pFit->m_mapSpecXData);
|
|
|
|
m_nInfActive = pFit->m_nInfActive;
|
|
//m_sGUID = IDCreate();
|
|
m_mapSpecXData.GetAt(KEY_NO,m_sGUID);
|
|
m_bActive = pFit->m_bActive;
|
|
|
|
m_idSingleLayer = pFit->m_idSingleLayer;
|
|
m_idSingleLnType = pFit->m_idSingleLnType;
|
|
|
|
m_idDoubleLayer = pFit->m_idDoubleLayer;
|
|
m_idDoubleLnType = pFit->m_idDoubleLnType;
|
|
|
|
this->m_arUserInfs.removeAll();
|
|
this->m_arUserInfs.append(pFit->m_arUserInfs);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AcGeVector3d vtMaj,vtMin;
|
|
AcGePoint3d ptMid;
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
vtMaj.transformBy(xform);
|
|
vtMin.transformBy(xform);
|
|
ptMid.transformBy(xform);
|
|
|
|
m_mapSpecXData.SetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.SetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.SetAt(KEY_MID, ptMid);
|
|
|
|
//用户接口联动
|
|
for (int i = 0; i < m_arUserInfs.length(); i++)
|
|
{
|
|
AecUserInterface &inf = m_arUserInfs.at(i);
|
|
for (int j = 0; j < inf.nPoints; j++)
|
|
{
|
|
inf.ptGe[j].transformBy(xform);
|
|
inf.vtDir.transformBy(xform);
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
LPCTSTR AecDbEcFitting::GetGripCmd() const
|
|
{
|
|
assertReadEnabled();
|
|
return _T("EL_cabtryadd");
|
|
}
|
|
|
|
SHJson::WValue &AecDbEcFitting::ToJson(bool bExprotGeo) const
|
|
{
|
|
using namespace SHJson;
|
|
assertReadEnabled();
|
|
WValue &v = AecDbEntityBase::ToJson(bExprotGeo);
|
|
addMember(v, _T("__nInfActive__"), m_nInfActive);
|
|
addMember(v, _T("__sGUID__"), m_sGUID);
|
|
addMember(v, _T("__bActive__"), m_bActive);
|
|
return v;
|
|
}
|
|
|
|
bool AecDbEcFitting::ByJson(const SHJson::WValue &v)
|
|
{
|
|
using namespace SHJson;
|
|
AssertWriteEnabled();
|
|
|
|
MCIt it1(v.FindMember(_T("__nInfActive__")))
|
|
, it2(v.FindMember(_T("__sGUID__")))
|
|
, it3(v.FindMember(_T("__bActive__")));
|
|
if (it1 != v.MemberEnd() && it2 != v.MemberEnd() && it3 != v.MemberEnd())
|
|
{
|
|
m_nInfActive = it1->value.GetInt();
|
|
m_sGUID = it2->value.GetString();
|
|
m_bActive = it3->value.GetBool();
|
|
}
|
|
|
|
return AecDbEntityBase::ByJson(v);
|
|
}
|
|
|
|
#if ARX>16
|
|
Acad::ErrorStatus AecDbEcFitting::subGetGripPoints(AcDbGripDataPtrArray& grips,
|
|
const double curViewUnitSize,
|
|
const int gripSize,
|
|
const AcGeVector3d& curViewDir,
|
|
const int bitflags) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGePoint3dArray gripPoints;
|
|
|
|
AcArray<AecInterface> arInfs;
|
|
GetInterface(arInfs);
|
|
|
|
AcGePoint3d ptMid;
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
CString sCmd = GetGripCmd();
|
|
AcDbGripData* pGripData = NULL;
|
|
|
|
EPosition ePos = eCommand0;
|
|
int i(0);
|
|
for (i = 0;i < arInfs.length();i++)
|
|
{
|
|
pGripData = new AcDbGripData;
|
|
|
|
memset(&m_pGripAppData[i],0,sizeof(AecGripData));
|
|
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = ePos;
|
|
m_pGripAppData[i].ptGrip = arInfs.at(i).ptPos;
|
|
_tcscpy(m_pGripAppData[i].szTip,sCmd);
|
|
m_pGripAppData[i].pOwner = (AcDbEntity*)this;
|
|
m_pGripAppData[i].idHost = objectId();
|
|
|
|
pGripData->setGripPoint(arInfs.at(i).ptPos);
|
|
pGripData->setAppData((void*)&m_pGripAppData[i]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
grips.append(pGripData);
|
|
}
|
|
|
|
pGripData = new AcDbGripData;
|
|
memset(&m_pGripAppData[i],0,sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = eMid;
|
|
m_pGripAppData[i].ptGrip = ptMid;
|
|
_tcscpy(m_pGripAppData[i].szTip,_T("位置夹点"));
|
|
m_pGripAppData[i].pOwner = (AcDbEntity*)this;
|
|
m_pGripAppData[i].idHost = objectId();
|
|
|
|
pGripData->setGripPoint(ptMid);
|
|
pGripData->setAppData((void*)&m_pGripAppData[i]);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
grips.append(pGripData);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGePoint3d ptMid;
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
stretchPoints.append(ptMid);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::subMoveGripPointsAt(const AcDbVoidPtrArray& gripAppData, const AcGeVector3d& offset, const int bitflags)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AecGripData* pAppData = NULL;
|
|
AcDbIntArray arIndex;
|
|
|
|
if ( !gripAppData.isEmpty() )
|
|
{
|
|
pAppData = (AecGripData*)gripAppData.first();
|
|
arIndex.append(pAppData->nIndex);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
AcGeVector3d vtOffset = offset;
|
|
if(Is2DView())
|
|
{
|
|
vtOffset = offset.orthoProject(GetUcsZvt());
|
|
}
|
|
|
|
AecInterface inf;
|
|
GripMessage msg;
|
|
memset(&msg,0,sizeof(GripMessage));
|
|
//reset
|
|
msg.nSegindex = -1;
|
|
msg.nType = -1;
|
|
msg.idHost.setNull();
|
|
msg.pParam = 0;
|
|
msg.nData = -1;
|
|
_tcscpy(msg.szLockId, _T("0"));//锁定id,如果有
|
|
msg.fData = 0;
|
|
msg.nSegindex = 0;
|
|
msg.nSubSegIndex = 0;
|
|
msg.vtOffset.set(0,0,0);
|
|
msg.ptGrip.set(0,0,0);
|
|
|
|
AcGeMatrix3d xformM;
|
|
xformM.setToTranslation(vtOffset);
|
|
|
|
int nGripIndex = arIndex.first();
|
|
if (nGripIndex < GetInterfaceCount())
|
|
{
|
|
msg.nType = eCommand0;
|
|
msg.nData = nGripIndex;
|
|
GetInterface(msg.nData,inf);
|
|
msg.ptGrip = inf.ptPos;
|
|
msg.idHost = pAppData->idHost;
|
|
msg.vtOffset = vtOffset;
|
|
|
|
PushGripMessage(msg);
|
|
|
|
CString sCmd = GetGripCmd();
|
|
if (!sCmd.IsEmpty())
|
|
{
|
|
acedPostCommand(_T("\x03"));
|
|
sCmd += _T("\n");
|
|
acedPostCommand(sCmd);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TransformBy(xformM);
|
|
|
|
//按接口关系更新相关联对象
|
|
msg.nType = eMid;
|
|
msg.nData = -1;
|
|
msg.idHost = pAppData->idHost;
|
|
msg.vtOffset = vtOffset;
|
|
|
|
PushGripMessage(msg);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::subMoveStretchPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
if (indices.length() > 0)
|
|
{
|
|
AcGePoint3d ptMid;
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
ptMid += offset;
|
|
m_mapSpecXData.SetAt(KEY_MID,ptMid);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbEcFitting::GetGripText(int nPos, CString& sText)
|
|
{
|
|
if (nPos < GetInterfaceCount())
|
|
{
|
|
sText = _T("拉伸命令夹点");
|
|
}
|
|
else
|
|
{
|
|
sText = _T("位置夹点");
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& pickPoint,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
if (Has2DBuffer())
|
|
{
|
|
AcDbEntity* pSubEnt = NULL;
|
|
const AcDbVoidPtrArray &ar2D = Get2DBuffer();
|
|
for (int i = 0;i < ar2D.length();i++)
|
|
{
|
|
pSubEnt = (AcDbEntity*)ar2D.at(i);
|
|
pSubEnt->getOsnapPoints(osnapMode,gsSelectionMark,pickPoint,lastPoint,viewXform,snapPoints,geomIds);
|
|
}
|
|
|
|
AcArray<AecInterface> arInfs;
|
|
GetInterface(arInfs);
|
|
|
|
for (int i = 0;i < arInfs.length();i++)
|
|
{
|
|
const AecInterface &inf = arInfs.at(i);
|
|
snapPoints.append(inf.ptPos);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::subGetGeomExtents(AcDbExtents& extents) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbExtents ext1;
|
|
AcDbEntity* pEnt = NULL;
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0;i < ar3D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar3D.at(i);
|
|
pEnt->getGeomExtents(ext1);
|
|
extents.addExt(ext1);
|
|
}
|
|
|
|
const AcDbVoidPtrArray &ar2D = Get2DBuffer();
|
|
for (int j = 0;j < ar2D.length();j++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar2D.at(j);
|
|
pEnt->getGeomExtents(ext1);
|
|
extents.addExt(ext1);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::subIntersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (Has2DBuffer())
|
|
{
|
|
AcDbEntity* pSubEnt = NULL;
|
|
const AcDbVoidPtrArray &ar2D = Get2DBuffer();
|
|
for (int i = 0;i < ar2D.length();i++)
|
|
{
|
|
pSubEnt = (AcDbEntity*)ar2D.at(i);
|
|
pSubEnt->intersectWith(pEnt,intType,points,thisGsMarker,otherGsMarker);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::subIntersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
const AcGePlane& projPlane,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (Has2DBuffer())
|
|
{
|
|
AcDbEntity* pSubEnt = NULL;
|
|
const AcDbVoidPtrArray &ar2D = Get2DBuffer();
|
|
for (int i = 0;i < ar2D.length();i++)
|
|
{
|
|
pSubEnt = (AcDbEntity*)ar2D.at(i);
|
|
pSubEnt->intersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
#endif
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::ShowUsedFill(AcGiDraw &dc) const
|
|
{
|
|
int nApp = 0;
|
|
m_mapSpecXData.GetAt(KEY_APP, nApp);
|
|
WPipe::EApp eApp = (WPipe::EApp)nApp;
|
|
|
|
//显示已用填充率
|
|
struct resbuf rb;
|
|
rb.resval.rint = 0;
|
|
acedGetVar(_T("useri3"), &rb);
|
|
if (rb.resval.rint == 1395 && eApp == WPipe::eBridge)
|
|
{
|
|
CString sFill, sFill2, sText;
|
|
//显示填充率
|
|
double dFillUsed1 = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_FILLUSED, dFillUsed1);//0.65
|
|
if (dFillUsed1 > 0.001)
|
|
{
|
|
sFill.Format(_T("已用填充率=%d%%"), (int)(dFillUsed1 * 100));
|
|
}
|
|
|
|
double dFillUsed2 = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_FILLUSED2, dFillUsed2);
|
|
if (dFillUsed2 > 0.001)
|
|
{
|
|
sFill2.Format(_T("已用填充率2=%d%%"), (int)(dFillUsed2 * 100));
|
|
}
|
|
sText = sFill + sFill2;
|
|
if (!sText.IsEmpty())
|
|
{
|
|
AcGeVector3d vtMaj;
|
|
AcGePoint3d ptMid, ptE;
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
ptE = ptMid + vtMaj * 200.0;
|
|
AcGePoint3d pt1 = ptMid;
|
|
AcGePoint3d pt2 = ptE;
|
|
AcGePoint3d pt3;
|
|
Midpoint(pt1, pt2, pt3);
|
|
double dH = 2.5;
|
|
m_mapSpecXData.GetAt(KEY_SIZE1, dH);
|
|
dH *= 0.25;
|
|
dc.DrawTextFit(sText, pt3, pt2, dH, _T("Standard"));
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//管线系统屏蔽掉
|
|
if ( dc.IsDragging() )
|
|
{
|
|
//return Acad::eOk;
|
|
}
|
|
|
|
//图层
|
|
AcDbObjectId idLay = dc.GetLayerId();
|
|
dc.SetLayer(layerId());
|
|
//dc.SetSelectionMarker(1);
|
|
|
|
int nCrBk = dc.GetColor();
|
|
int nColor = nCrBk;
|
|
if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
|
|
{
|
|
dc.SetColor(nColor);
|
|
}
|
|
|
|
if (Has2DBuffer())
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
const AcDbVoidPtrArray &ar2D = Get2DBuffer();
|
|
for (int i = 0;i < ar2D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar2D.at(i);
|
|
//pEnt->setColorIndex(nColor);
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
|
|
dc.SetLayer(idLay);
|
|
dc.SetColor(nCrBk);
|
|
|
|
ShowUsedFill(dc);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
int nApp = 0;
|
|
m_mapSpecXData.GetAt(KEY_APP, nApp);
|
|
WPipe::EApp eApp = (WPipe::EApp)nApp;
|
|
|
|
switch (eApp)
|
|
{
|
|
case WPipe::eTrench:
|
|
{
|
|
DrawTrech2D(dc);
|
|
break;
|
|
}
|
|
case WPipe::eBridge:
|
|
{
|
|
DrawBridge2D(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
DrawUserInf(dc);
|
|
|
|
ShowUsedFill(dc);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawUserInf(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGePoint3d ptGe[16], ptGe1,ptGe2, ptS, ptE;
|
|
for (int i = 0; i < m_arUserInfs.length(); i++)
|
|
{
|
|
const AecUserInterface &inf = m_arUserInfs.at(i);
|
|
|
|
if (inf.nPoints == 2)
|
|
{
|
|
AcDbCircle *pCir = new AcDbCircle;
|
|
pCir->setCenter(inf.ptGe[0]);
|
|
pCir->setNormal(inf.vtDir);
|
|
pCir->setRadius(inf.ptGe[1].distanceTo(inf.ptGe[0]));
|
|
pCir->setLayer(layerId());
|
|
|
|
if (inf.vtDir.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
dc.DrawEntity(pCir);
|
|
Add2DBuffer(pCir);
|
|
}
|
|
else
|
|
{
|
|
AcDbCurve *pCurve = NULL;
|
|
pCir->getOrthoProjectedCurve(AcGePlane::kXYPlane, pCurve);
|
|
if (pCurve != NULL)
|
|
{
|
|
dc.DrawEntity(pCurve);
|
|
Add2DBuffer(pCurve);
|
|
|
|
pCurve->getStartPoint(ptS);
|
|
pCurve->getEndPoint(ptE);
|
|
|
|
AcDbLine *pLn = NULL;
|
|
|
|
ptGe1 = ptS + inf.vtDir;
|
|
pLn = new AcDbLine(ptS, ptGe1);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
|
|
ptGe2 = ptE + inf.vtDir;
|
|
pLn = new AcDbLine(ptE, ptGe2);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
|
|
pLn = new AcDbLine(ptGe1, ptGe2);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
delete pCir;
|
|
}
|
|
}
|
|
else if (inf.nPoints > 2)
|
|
{
|
|
//投影到XY
|
|
AcGePoint3dArray arPts,arPts2;
|
|
for (int j = 0; j < inf.nPoints; j++)
|
|
{
|
|
ptGe[j] = inf.ptGe[j].orthoProject(AcGePlane::kXYPlane);
|
|
if (arPts.find(ptGe[j]) == -1)
|
|
arPts.append(ptGe[j]);
|
|
}
|
|
|
|
AcDbLine *pLn = NULL;
|
|
if (!inf.vtDir.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
for (int j = 0; j < arPts.length(); j++)
|
|
{
|
|
ptGe2 = arPts.at(j) + inf.vtDir;
|
|
arPts2.append(ptGe2);
|
|
pLn = new AcDbLine(arPts.at(j), ptGe2);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
|
|
for (int j = 0; j < arPts2.length() - 1; j++)
|
|
{
|
|
pLn = new AcDbLine(arPts2.at(j), arPts2.at(j + 1));
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
arPts.removeAll();
|
|
for (int j = 0; j < inf.nPoints; j++)
|
|
{
|
|
ptGe[j] = inf.ptGe[j].orthoProject(AcGePlane::kXYPlane);
|
|
|
|
if (arPts.length() > 0)
|
|
{
|
|
pLn = new AcDbLine(arPts.last(), ptGe[j]);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
arPts.append(ptGe[j]);
|
|
if (j == inf.nPoints - 1)
|
|
{
|
|
pLn = new AcDbLine(arPts.first(), ptGe[j]);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawBridge2D(AcGiDraw &dc) const
|
|
{
|
|
int nType = 0;
|
|
m_mapSpecXData.GetAt(KEY_RUNTIME, nType);
|
|
EFittingType eType = (EFittingType)nType;
|
|
|
|
switch (eType)
|
|
{
|
|
case eElbow:
|
|
DrawElbow2d(dc);
|
|
break;
|
|
case eTee:
|
|
DrawTee2d(dc);
|
|
break;
|
|
case eCross:
|
|
DrawCross2d(dc);
|
|
break;
|
|
case eReduce:
|
|
DrawReduce2d(dc);
|
|
break;
|
|
case eOffset:
|
|
DrawOffset2d(dc);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrech2D(AcGiDraw &dc) const
|
|
{
|
|
int nType = 0;
|
|
m_mapSpecXData.GetAt(KEY_RUNTIME, nType);
|
|
EFittingType eType = (EFittingType)nType;
|
|
|
|
switch (eType)
|
|
{
|
|
case eElbow:
|
|
DrawTrElbow2d(dc);
|
|
break;
|
|
case eTee:
|
|
DrawTrTee2d(dc);
|
|
break;
|
|
case eCross:
|
|
DrawTrCross2d(dc);
|
|
break;
|
|
case eReduce:
|
|
DrawTrReduce2d(dc);
|
|
break;
|
|
case eOffset:
|
|
DrawTrOffset2d(dc);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawBridge3D(AcGiDraw &dc) const
|
|
{
|
|
int nType = 0;
|
|
m_mapSpecXData.GetAt(KEY_RUNTIME, nType);
|
|
EFittingType eType = (EFittingType)nType;
|
|
|
|
switch (eType)
|
|
{
|
|
case eElbow:
|
|
DrawElbow3d(dc);
|
|
break;
|
|
case eTee:
|
|
DrawTee3d(dc);
|
|
break;
|
|
case eCross:
|
|
DrawCross3d(dc);
|
|
break;
|
|
case eReduce:
|
|
DrawReduce3d(dc);
|
|
break;
|
|
case eOffset:
|
|
DrawOffset3d(dc);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
extern bool FormatRect(AcGePoint3d *pptGe, double dw, double dt);
|
|
extern AcDbRegion *CreatePolygonRegionOnly(AcGePoint3d *pPoints, int nSize);
|
|
bool AecDbEcFitting::GetDlgRegionData(DlgData &data, AcArray<RegionAndEl> &arRegEl) const
|
|
{
|
|
AcDbRegion *pRegion = NULL;
|
|
|
|
//原始位置为原点
|
|
//底板
|
|
AcDbVoidPtrArray arLnPtrs;
|
|
RegionAndEl rel;
|
|
rel.pReg = NULL;
|
|
_tcscpy(rel.m_szMat, _T("混凝土"));
|
|
|
|
AcGePoint3d ptGe[5];
|
|
|
|
FormatRect(ptGe, data.m_dd, data.m_db);
|
|
|
|
pRegion = CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegion == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
rel.m_dZ = data.m_dTopEl;
|
|
rel.m_dZ -= data.m_dk;
|
|
rel.m_dZ -= data.m_dH;
|
|
rel.m_dZ -= 0.5 * data.m_db;
|
|
rel.pReg = pRegion;
|
|
rel.nType = 1;//板
|
|
rel.m_dX = 0.0;//偏移
|
|
rel.dSize[0] = data.m_dd;
|
|
rel.dSize[1] = data.m_db;
|
|
rel.dSize[2] = 0.0;
|
|
arRegEl.append(rel);
|
|
|
|
//侧面墙体
|
|
FormatRect(ptGe, data.m_dt, (data.m_dH - data.m_dh2));
|
|
pRegion = CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegion == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
_tcscpy(rel.m_szMat, _T("砌砖墙体"));
|
|
rel.m_dZ = data.m_dTopEl;
|
|
rel.m_dZ -= data.m_dk;
|
|
rel.m_dZ -= data.m_dh2;
|
|
rel.m_dZ -= 0.5 * (data.m_dH - data.m_dh2);
|
|
rel.m_dX = 0.0;
|
|
rel.m_dX -= 0.5 * data.m_dW;
|
|
rel.m_dX -= 0.5 * data.m_dt;
|
|
rel.pReg = pRegion;
|
|
rel.nType = 2;//墙
|
|
|
|
rel.dSize[0] = data.m_dt;
|
|
rel.dSize[1] = (data.m_dH - data.m_dh2);
|
|
rel.dSize[2] = 0.0;
|
|
|
|
arRegEl.append(rel);
|
|
|
|
//侧面墙体2
|
|
rel.m_dX += (data.m_dW + data.m_dt);
|
|
rel.pReg = (AcDbRegion *)pRegion->clone();
|
|
arRegEl.append(rel);
|
|
|
|
//压顶
|
|
FormatRect(ptGe, data.m_dt, data.m_dh2);
|
|
pRegion = CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegion == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
_tcscpy(rel.m_szMat, _T("混凝土"));
|
|
rel.m_dZ = data.m_dTopEl;
|
|
rel.m_dZ -= data.m_dk;
|
|
rel.m_dZ -= 0.5 * data.m_dh2;
|
|
rel.pReg = pRegion;
|
|
rel.nType = 2;
|
|
rel.m_dX = 0.0;
|
|
rel.m_dX -= 0.5 * data.m_dW;
|
|
rel.m_dX -= 0.5 * data.m_dt;
|
|
|
|
rel.dSize[0] = data.m_dt;
|
|
rel.dSize[1] = data.m_dh2;
|
|
rel.dSize[2] = 0.0;
|
|
|
|
arRegEl.append(rel);
|
|
|
|
rel.m_dX += (data.m_dW + data.m_dt);
|
|
rel.pReg = (AcDbRegion *)pRegion->clone();
|
|
arRegEl.append(rel);
|
|
|
|
//盖板
|
|
if (data.m_bHasCover)
|
|
{
|
|
FormatRect(ptGe, data.m_dW + 2.0 * data.m_dt, data.m_dk);
|
|
pRegion = CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegion == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_tcscpy(rel.m_szMat, _T("钢筋混凝土盖板"));
|
|
rel.m_dZ = data.m_dTopEl;
|
|
rel.m_dZ -= 0.5 * data.m_dk;
|
|
rel.m_dX = 0.0;
|
|
rel.nType = 1;// 板
|
|
rel.pReg = pRegion;
|
|
|
|
rel.dSize[0] = data.m_dW + 2.0 * data.m_dt;
|
|
rel.dSize[1] = data.m_dk;
|
|
rel.dSize[2] = 0.0;
|
|
|
|
arRegEl.append(rel);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrech3D(AcGiDraw &dc) const
|
|
{
|
|
int nType = 0;
|
|
m_mapSpecXData.GetAt(KEY_RUNTIME, nType);
|
|
EFittingType eType = (EFittingType)nType;
|
|
|
|
switch (eType)
|
|
{
|
|
case eElbow:
|
|
DrawTrElbow3d(dc);
|
|
break;
|
|
case eTee:
|
|
DrawTrTee3d(dc);
|
|
break;
|
|
case eCross:
|
|
DrawTrCross3d(dc);
|
|
break;
|
|
case eReduce:
|
|
DrawTrReduce3d(dc);
|
|
break;
|
|
case eOffset:
|
|
DrawTrOffset3d(dc);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawElbow2d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
|
|
m_mapSpecXData.GetAt(HELB_Type, (int&)eElbowType);
|
|
|
|
switch(eElbowType)
|
|
{
|
|
case AecHvac::eIncline://内斜线
|
|
{
|
|
DrawIncline2d(dc);
|
|
break;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrElbow2d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
|
|
m_mapSpecXData.GetAt(HELB_Type, (int &)eElbowType);
|
|
|
|
switch (eElbowType)
|
|
{
|
|
case AecHvac::eIncline://内斜线
|
|
{
|
|
DrawTrIncline2d(dc);
|
|
break;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTee2d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacTeeType eTeeType = AecHvac::eTShapeBranch;
|
|
m_mapSpecXData.GetAt(HTEE_Type, (int&)eTeeType);
|
|
|
|
switch(eTeeType)
|
|
{
|
|
case AecHvac::eIncline2Branch://内斜线
|
|
{
|
|
DrawIncline2Tee2d(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrTee2d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacTeeType eTeeType = AecHvac::eTShapeBranch;
|
|
m_mapSpecXData.GetAt(HTEE_Type, (int &)eTeeType);
|
|
|
|
switch (eTeeType)
|
|
{
|
|
case AecHvac::eIncline2Branch://内斜线
|
|
{
|
|
DrawTrIncline2Tee2d(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
static void InsertL2Point(AcGePoint3d& ptX,AcGePoint3d& ptOrg,AcGePoint3d& ptY,double dLx,AcGePoint3dArray& arPts)
|
|
{
|
|
AcGeVector3d vt = ptOrg - ptX;
|
|
vt.normalize();
|
|
|
|
AcGePoint3d pt = ptX + vt * dLx;
|
|
arPts.append(pt);
|
|
|
|
vt = ptOrg - ptY;
|
|
vt.normalize();
|
|
|
|
pt = ptY + vt * dLx;
|
|
arPts.append(pt);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee2d0(AcGiDraw &dc) const
|
|
{
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
|
|
double dThick = 0.35, dLx = 50.0, dH = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
dH = dParam.dSize[1];// H
|
|
dDn2 = dParam.dSize[3];//分支宽度
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
|
|
double dL = dDn * dRatio;
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
AcGePoint3d ptGe[10];
|
|
|
|
//如果是俯视图
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//水平
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[0] -= vtMin * dDn * 0.5;
|
|
arPts.append(ptGe[0]);
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
|
|
arPts.append(ptGe[1]);
|
|
|
|
ptGe[2] = ptGe[1] + vtMin * dDn;
|
|
arPts.append(ptGe[2]);
|
|
|
|
ptGe[3] = ptGe[2] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
|
|
InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
|
|
arPts.append(ptGe[4]);
|
|
|
|
ptGe[5] = ptGe[4] - vtMaj * dDn2;
|
|
arPts.append(ptGe[5]);
|
|
|
|
ptGe[6] = ptGe[3] - vtMaj * dDn2;
|
|
ptGe[7] = ptGe[0] + vtMin * dDn;
|
|
InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
|
|
arPts.append(ptGe[7]);
|
|
|
|
ptGe[8] = ptGe[0];
|
|
arPts.append(ptGe[8]);
|
|
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
AcDbPolyline *pPl = NULL;
|
|
if (bHide)
|
|
{
|
|
AcDbVoidPtrArray arPls;
|
|
AcGePoint3d *ptGe2 = arPts.asArrayPtr();
|
|
pPl = FormatPolyline(ptGe2, 2);
|
|
if (pPl != NULL)
|
|
arPls.append(pPl);
|
|
|
|
ptGe2 += 2;
|
|
pPl = FormatPolyline(ptGe2, 4);
|
|
if (pPl != NULL)
|
|
arPls.append(pPl);
|
|
|
|
ptGe2 += 4;
|
|
pPl = FormatPolyline(ptGe2, 4);
|
|
if (pPl != NULL)
|
|
arPls.append(pPl);
|
|
|
|
for (int k = 0; k < arPls.length(); k++)
|
|
{
|
|
pPl = (AcDbPolyline *)arPls.at(k);
|
|
pPl->setLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pPl = FormatPolyline(arPts.asArrayPtr(), arPts.length());
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[1] = ptMid + vtMin * (dL + dLx);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline *pPl = NULL;
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(AcGePoint3d::kOrigin, vtNorm);
|
|
if (ln3d.isParallelTo(AcGePlane::kXYPlane))//竖放
|
|
{
|
|
// ___
|
|
// |
|
|
ln3d.set(AcGePoint3d::kOrigin, vtMaj);
|
|
if (ln3d.isParallelTo(AcGePlane::kXYPlane))//vtMaj // XY面
|
|
{
|
|
AcGeVector3d vtV = vtMaj;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[0] -= vtV * 0.5 * dDn;
|
|
|
|
ptGe[1] = ptGe[0] + vtV * dDn;
|
|
ptGe[2] = ptGe[1] + vtMaj * 2.0 * (dL + dLx);
|
|
ptGe[3] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
|
|
ptGe[4] = ptGe[0];
|
|
|
|
pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
//Section
|
|
switch (dParam.eType)
|
|
{
|
|
case eRect:
|
|
{
|
|
//折边
|
|
ptGe[0] += vtMaj * dLx;
|
|
ptGe[1] += vtMaj * dLx;
|
|
ptGe[2] -= vtMaj * dLx;
|
|
ptGe[3] -= vtMaj * dLx;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
if (!vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("DASHED")));
|
|
}
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
ptGe[0] += vtMaj * (dL - 0.5 * dH);
|
|
ptGe[1] += vtMaj * (dL - 0.5 * dH);
|
|
ptGe[2] -= vtMaj * (dL - 0.5 * dH);
|
|
ptGe[3] -= vtMaj * (dL - 0.5 * dH);
|
|
ptGe[4] = ptGe[0];
|
|
|
|
pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
if (!vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("DASHED")));
|
|
}
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
break;
|
|
}
|
|
case eCircle:
|
|
{
|
|
AcDbCircle *pCir = new AcDbCircle;
|
|
pCir->setCenter(ptMid);
|
|
pCir->setRadius(dDn * 0.5);
|
|
pCir->setNormal(AcGeVector3d::kZAxis);
|
|
|
|
pCir->setLayer(m_idDoubleLayer);
|
|
if (!vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
pCir->setLinetype(KTSetting::InitLineStyle(_T("DASHED")));
|
|
}
|
|
|
|
dc.DrawEntity(pCir);
|
|
Add2DBuffer(pCir);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
//cen
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
|
|
ptGe[1] = ptMid;
|
|
ptGe[1] += vtMaj * (dL + dLx);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
|
|
//|-
|
|
ln3d.set(AcGePoint3d::kOrigin, vtMin);
|
|
if (ln3d.isParallelTo(AcGePlane::kXYPlane))//vtMin // XY面
|
|
{
|
|
AcGeVector3d vtV = vtMin;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
|
|
if (dParam.eType == eRect)
|
|
{
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMin * 0.5 * dDn;
|
|
ptGe[0] -= vtV * 0.5 * dDn;
|
|
|
|
ptGe[1] = ptGe[0] + vtV * (dL + dLx + 0.5 * dDn);
|
|
ptGe[2] = ptGe[1] + vtV * dDn;
|
|
ptGe[3] = ptGe[0] + vtV * dDn;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else if (dParam.eType == eCircle)
|
|
{
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtV * 0.5 * dDn;
|
|
|
|
ptGe[1] = ptGe[0] + vtV * (dL + dLx);
|
|
ptGe[2] = ptGe[1] + vtV * dDn;
|
|
ptGe[3] = ptGe[0] + vtV * dDn;
|
|
|
|
pPl = FormatPolyline(ptGe, 4);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
//Section
|
|
switch (dParam.eType)
|
|
{
|
|
case eRect:
|
|
{
|
|
ptGe[0] += vtMin * dDn;
|
|
ptGe[1] = ptGe[2] + vtMin * dDn;
|
|
|
|
pPl = FormatPolyline(ptGe, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
break;
|
|
}
|
|
case eCircle:
|
|
{
|
|
AcDbCircle *pCir = new AcDbCircle;
|
|
pCir->setCenter(ptMid);
|
|
pCir->setRadius(dDn * 0.5);
|
|
pCir->setNormal(AcGeVector3d::kZAxis);
|
|
|
|
dc.SetLayer(m_idDoubleLayer);
|
|
dc.SetLineType(m_idDoubleLnType);
|
|
|
|
dc.DrawEntity(pCir);
|
|
Add2DBuffer(pCir);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
//cen
|
|
ptGe[0] = ptMid;
|
|
ptGe[1] = ptMid + vtMin * (dL + dLx);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee2d3(AcGiDraw &dc) const
|
|
{
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
|
|
double dThick = 0.35, dLx = 50.0, dH = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
dH = dParam.dSize[1];// H
|
|
dDn2 = dParam.dSize[3];//分支宽度
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
|
|
double dL = dDn * dRatio;
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
AcGePoint3d ptGe[10];
|
|
|
|
AcGeVector3d vtX, vtZ, vtY;
|
|
if (vtMin.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtZ = vtMin;
|
|
vtX = vtMaj;
|
|
}
|
|
if (vtMaj.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtZ = vtMaj;
|
|
vtX = vtMin;
|
|
}
|
|
vtY = vtX;
|
|
vtY.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
|
|
AcGeLine3d ln(ptMid, vtX);
|
|
if (ln.isParallelTo(AcGePlane::kXYPlane))
|
|
{
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtX * (dL + dLx);
|
|
ptGe[0] += vtY * 0.5 * dDn;
|
|
|
|
ptGe[1] = ptGe[0] + vtX * 2.0 * (dL + dLx);
|
|
ptGe[2] = ptGe[1] - vtY * dDn;
|
|
ptGe[3] = ptGe[0] - vtY * dDn;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
//Z向 userinf
|
|
//调用 drawuserinf
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//上角垂直三通
|
|
Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee2d5(AcGiDraw &dc) const
|
|
{
|
|
//一个水平弯头 + 竖桥架
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
|
|
double dThick = 0.35, dLx = 50.0, dH = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
dH = dParam.dSize[1];// H
|
|
dDn2 = dParam.dSize[3];//分支宽度
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
|
|
//double dL = dDn * dRatio + dLx;
|
|
double dL = GetElbowL(&dParam);
|
|
dL += dLx;//三通长度
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
|
|
//vtMaj vtMin 平行 XY 面
|
|
AcGePoint3d ptGe[8], ptGeU[6];
|
|
AcGeVector3d vtNormal = vtMin.crossProduct(vtMaj);
|
|
if (vtNormal.isParallelTo(AcGeVector3d::kZAxis))//水平放置
|
|
{
|
|
AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
|
|
AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
|
|
vtMV.normalize();
|
|
vtNV.normalize();
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[0] -= vtMV * 0.5 * dDn;
|
|
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
ptGe[2] -= vtNV * 0.5 * dDn2;
|
|
|
|
AcGeLine3d ln1(ptGe[0], vtMaj);
|
|
AcGeLine3d ln2(ptGe[2], vtMin);
|
|
ln1.intersectWith(ln2, ptGe[1]);
|
|
|
|
ptGe[3] = ptGe[2] + vtNV * dDn2;
|
|
ptGe[4] = ptGe[3] - vtMin * dLx;
|
|
|
|
ptGe[6] = ptGe[0] + vtMV * dDn;
|
|
ptGe[5] = ptGe[6] - vtMaj * dLx;
|
|
|
|
ptGe[7] = ptGe[0];
|
|
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
AcDbPolyline *pPl = NULL;
|
|
if (!bHide)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 8);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AcGePoint3d *ptGe2 = ptGe;
|
|
pPl = FormatPolyline(ptGe2, 3);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
AcGePoint3d *ptGe3 = ptGe;
|
|
ptGe3 += 3;//->3
|
|
|
|
pPl = FormatPolyline(ptGe3, 4);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[1] = ptMid;
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 3);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
|
|
//vtZ 方向为 userinf
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee2d(AcGiDraw &dc) const
|
|
{
|
|
int nTeeStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_TEESTYLE, nTeeStyle);
|
|
|
|
int nStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);
|
|
|
|
//double dSingleW = 0.0;
|
|
//m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);
|
|
|
|
nStyle = 2;//双线
|
|
|
|
switch (nStyle)
|
|
{
|
|
case 0://单线
|
|
case 1://单线
|
|
{
|
|
//暂不绘制单线
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
switch (nTeeStyle)
|
|
{
|
|
case 0: //水平三通 =||=
|
|
{
|
|
DrawIncline2Tee2d0(dc);
|
|
break;
|
|
}
|
|
case 1: //上垂直三通 [ || ]
|
|
case 2: //下垂直三通
|
|
case 3: //上边垂直三通
|
|
case 4: //下边垂直三通
|
|
{
|
|
DrawIncline2Tee2d3(dc);
|
|
break;
|
|
}
|
|
case 5: //下角垂直三通
|
|
case 6: //上角垂直三通
|
|
{
|
|
DrawIncline2Tee2d5(dc);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrIncline2Tee2d(AcGiDraw &dc) const
|
|
{
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
|
|
double dThick = 0.35, dLx = 50.0, dH = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
dH = dParam.dSize[1];// H
|
|
dDn2 = dParam.dSize[3];//分支宽度
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
|
|
double dL = dDn * dRatio;
|
|
//double dL = GetElbowL(&dParam);
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
|
|
int nStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);
|
|
|
|
double dSingleW = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);
|
|
|
|
nStyle = 2;//双线
|
|
|
|
AcGePoint3d ptGe[10],ptGeL[10];
|
|
switch (nStyle)
|
|
{
|
|
case 0://单线
|
|
case 1://单线
|
|
{
|
|
//暂不绘制单线
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
//如果是俯视图
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//电缆沟水平
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[0] -= vtMin * dDn * 0.5;
|
|
arPts.append(ptGe[0]);
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
|
|
arPts.append(ptGe[1]);
|
|
|
|
ptGe[2] = ptGe[1] + vtMin * dDn;
|
|
arPts.append(ptGe[2]);
|
|
|
|
ptGe[3] = ptGe[2] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
arPts.append(ptGe[3]);
|
|
//电缆沟不画倒角线
|
|
//InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
|
|
arPts.append(ptGe[4]);
|
|
|
|
ptGe[5] = ptGe[4] - vtMaj * dDn2;
|
|
arPts.append(ptGe[5]);
|
|
|
|
ptGe[6] = ptGe[3] - vtMaj * dDn2;
|
|
ptGe[7] = ptGe[0] + vtMin * dDn;
|
|
arPts.append(ptGe[6]);
|
|
//InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
|
|
arPts.append(ptGe[7]);
|
|
|
|
ptGe[8] = ptGe[0];
|
|
arPts.append(ptGe[8]);
|
|
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
AcDbPolyline *pPl = NULL;
|
|
if (bHide)
|
|
{
|
|
AcDbVoidPtrArray arPls;
|
|
AcGePoint3d *ptGe2 = arPts.asArrayPtr();
|
|
pPl = FormatPolyline(ptGe2, 2);
|
|
if (pPl != NULL)
|
|
arPls.append(pPl);
|
|
|
|
ptGe2 += 2;
|
|
pPl = FormatPolyline(ptGe2, 3);
|
|
if (pPl != NULL)
|
|
arPls.append(pPl);
|
|
|
|
ptGe2 += 3;
|
|
pPl = FormatPolyline(ptGe2, 3);
|
|
if (pPl != NULL)
|
|
arPls.append(pPl);
|
|
|
|
for (int k = 0; k < arPls.length(); k++)
|
|
{
|
|
pPl = (AcDbPolyline *)arPls.at(k);
|
|
pPl->setLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pPl = FormatPolyline(arPts.asArrayPtr(), arPts.length());
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[1] = ptMid + vtMin * (dL + dLx);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawCross2d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacCrossType eTeeType = AecHvac::eOrthoCross;
|
|
m_mapSpecXData.GetAt(HCRS_Type, (int&)eTeeType);
|
|
|
|
switch(eTeeType)
|
|
{
|
|
case AecHvac::eInterCross://内斜线四通
|
|
{
|
|
DrawInterCross2d(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrCross2d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacCrossType eTeeType = AecHvac::eOrthoCross;
|
|
m_mapSpecXData.GetAt(HCRS_Type, (int &)eTeeType);
|
|
|
|
switch (eTeeType)
|
|
{
|
|
case AecHvac::eInterCross://内斜线四通
|
|
{
|
|
DrawTrInterCross2d(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawInterCross2d(AcGiDraw &dc) const
|
|
{
|
|
AcGeVector3d vtMaj,vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0,dRatio = 1.0,dDn2 = 0;
|
|
double dThick = 0.35,dLx = 50.0,dH = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
dDn2 = dParam.dSize[3];//支宽
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
dH = dParam.dSize[1];//H
|
|
double dL = dDn * dRatio;
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
|
|
int nStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);
|
|
|
|
double dSingleW = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);
|
|
|
|
nStyle = 2;//双线
|
|
|
|
AcGePoint3d ptGe[12];
|
|
switch (nStyle)
|
|
{
|
|
case 0://单线
|
|
case 1://单线
|
|
{
|
|
//暂不绘制单线
|
|
break;
|
|
}
|
|
case 2://双线
|
|
{
|
|
//如果是俯视图
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//水平
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[0] -= vtMin * dDn * 0.5;
|
|
arPts.append(ptGe[0]);
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[2] = ptGe[1] - vtMin * (dL + dLx - 0.5 * dDn);
|
|
|
|
InsertL2Point(ptGe[0],ptGe[1],ptGe[2],dLx,arPts);
|
|
arPts.append(ptGe[2]);
|
|
|
|
ptGe[3] = ptGe[2] + vtMaj * dDn2;
|
|
arPts.append(ptGe[3]);
|
|
|
|
ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
ptGe[5] = ptGe[4] + vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
InsertL2Point(ptGe[3],ptGe[4],ptGe[5],dLx,arPts);
|
|
arPts.append(ptGe[5]);
|
|
|
|
ptGe[6] = ptGe[5] + vtMin * dDn;
|
|
arPts.append(ptGe[6]);
|
|
|
|
ptGe[7] = ptGe[6] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[8] = ptGe[7] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
InsertL2Point(ptGe[6],ptGe[7],ptGe[8],dLx,arPts);
|
|
arPts.append(ptGe[8]);
|
|
|
|
ptGe[9] = ptGe[8] - vtMaj * dDn2;
|
|
arPts.append(ptGe[9]);
|
|
|
|
ptGe[10] = ptGe[9] - vtMin * (dL + dLx - 0.5 * dDn);
|
|
ptGe[11] = ptGe[10] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
InsertL2Point(ptGe[9],ptGe[10],ptGe[11],dLx,arPts);
|
|
arPts.append(ptGe[11]);
|
|
arPts.append(ptGe[0]);
|
|
|
|
AcDbPolyline *pPl = NULL;
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
if (bHide)
|
|
{
|
|
AcDbVoidPtrArray arPls;
|
|
|
|
AcGePoint3d *ptGe2 = arPts.asArrayPtr();
|
|
pPl = FormatPolyline(ptGe2, 4);
|
|
if (pPl != NULL)
|
|
{
|
|
arPls.append(pPl);
|
|
}
|
|
|
|
ptGe2 += 4;
|
|
pPl = FormatPolyline(ptGe2, 4);
|
|
if (pPl != NULL)
|
|
{
|
|
arPls.append(pPl);
|
|
}
|
|
|
|
ptGe2 += 4;
|
|
pPl = FormatPolyline(ptGe2, 4);
|
|
if (pPl != NULL)
|
|
{
|
|
arPls.append(pPl);
|
|
}
|
|
|
|
ptGe2 += 4;
|
|
pPl = FormatPolyline(ptGe2, 4);
|
|
if (pPl != NULL)
|
|
{
|
|
arPls.append(pPl);
|
|
}
|
|
|
|
for (int k = 0;k < arPls.length();k++)
|
|
{
|
|
pPl = (AcDbPolyline*)arPls.at(k);
|
|
pPl->setLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pPl = FormatPolyline(arPts.asArrayPtr(),arPts.length());
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe,2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[1] = ptMid + vtMin * (dL + dLx);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe,2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline* pPl = NULL;
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(AcGePoint3d::kOrigin,vtNorm);
|
|
if (ln3d.isParallelTo(AcGePlane::kXYPlane))//竖放
|
|
{
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrInterCross2d(AcGiDraw &dc) const
|
|
{
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dDn2 = 0;
|
|
double dThick = 0.35, dLx = 50.0, dH = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
dDn2 = dParam.dSize[3];//支宽
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
dH = dParam.dSize[1];//H
|
|
double dL = dDn * dRatio;
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
|
|
int nStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);
|
|
|
|
double dSingleW = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);
|
|
|
|
nStyle = 2;//双线
|
|
|
|
AcGePoint3d ptGe[12];
|
|
switch (nStyle)
|
|
{
|
|
case 0://单线
|
|
case 1://单线
|
|
{
|
|
//暂不绘制单线
|
|
break;
|
|
}
|
|
case 2://双线
|
|
{
|
|
//如果是俯视图
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//电缆沟水平
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[0] -= vtMin * dDn * 0.5;
|
|
arPts.append(ptGe[0]);
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[2] = ptGe[1] - vtMin * (dL + dLx - 0.5 * dDn);
|
|
|
|
//电缆沟不画倒角线
|
|
arPts.append(ptGe[1]);
|
|
//InsertL2Point(ptGe[0], ptGe[1], ptGe[2], dLx, arPts);
|
|
arPts.append(ptGe[2]);
|
|
|
|
ptGe[3] = ptGe[2] + vtMaj * dDn2;
|
|
arPts.append(ptGe[3]);
|
|
|
|
ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
ptGe[5] = ptGe[4] + vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
|
|
//电缆沟不画倒角线
|
|
arPts.append(ptGe[4]);
|
|
//InsertL2Point(ptGe[3], ptGe[4], ptGe[5], dLx, arPts);
|
|
arPts.append(ptGe[5]);
|
|
|
|
ptGe[6] = ptGe[5] + vtMin * dDn;
|
|
arPts.append(ptGe[6]);
|
|
|
|
ptGe[7] = ptGe[6] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[8] = ptGe[7] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
|
|
//电缆沟不画倒角线
|
|
arPts.append(ptGe[7]);
|
|
//InsertL2Point(ptGe[6], ptGe[7], ptGe[8], dLx, arPts);
|
|
arPts.append(ptGe[8]);
|
|
|
|
ptGe[9] = ptGe[8] - vtMaj * dDn2;
|
|
arPts.append(ptGe[9]);
|
|
|
|
ptGe[10] = ptGe[9] - vtMin * (dL + dLx - 0.5 * dDn);
|
|
ptGe[11] = ptGe[10] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
|
|
//电缆沟不画倒角线
|
|
arPts.append(ptGe[10]);
|
|
//InsertL2Point(ptGe[9], ptGe[10], ptGe[11], dLx, arPts);
|
|
|
|
arPts.append(ptGe[11]);
|
|
arPts.append(ptGe[0]);
|
|
|
|
AcDbPolyline *pPl = NULL;
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
if (bHide)
|
|
{
|
|
AcDbVoidPtrArray arPls;
|
|
|
|
AcGePoint3d *ptGe2 = arPts.asArrayPtr();
|
|
pPl = FormatPolyline(ptGe2, 3);
|
|
if (pPl != NULL)
|
|
{
|
|
arPls.append(pPl);
|
|
}
|
|
|
|
ptGe2 += 3;
|
|
pPl = FormatPolyline(ptGe2, 3);
|
|
if (pPl != NULL)
|
|
{
|
|
arPls.append(pPl);
|
|
}
|
|
|
|
ptGe2 += 3;
|
|
pPl = FormatPolyline(ptGe2, 3);
|
|
if (pPl != NULL)
|
|
{
|
|
arPls.append(pPl);
|
|
}
|
|
|
|
ptGe2 += 3;
|
|
pPl = FormatPolyline(ptGe2, 3);
|
|
if (pPl != NULL)
|
|
{
|
|
arPls.append(pPl);
|
|
}
|
|
|
|
for (int k = 0; k < arPls.length(); k++)
|
|
{
|
|
pPl = (AcDbPolyline *)arPls.at(k);
|
|
pPl->setLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pPl = FormatPolyline(arPts.asArrayPtr(), arPts.length());
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[1] = ptMid + vtMin * (dL + dLx);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawReduce2d(AcGiDraw &dc) const
|
|
{
|
|
AcGeVector3d vtMaj,vtMin,vtNorm(0,0,1);
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0,dRatio = 1.0,dL = 0.0,dLx1 = 0,dLx2 = 0;
|
|
double dThick = 0.35,dH = 0.0,dW1 = 0.0,dt = 0.0,dL3 = 0;
|
|
|
|
int nEcCen = 0;//偏心
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
m_mapSpecXData.GetAt(KEY_L,dL);
|
|
m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
|
|
m_mapSpecXData.GetAt(KEY_ECCEN,nEcCen);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam,dParam2;
|
|
GetDuctParam(dParam);
|
|
memcpy(&dParam2, &dParam, sizeof(AecHvac::DuctParam));
|
|
dParam2.dSize[0] = dParam.dSize[3];
|
|
dLx1 = GetElbowLx(&dParam2);
|
|
dLx2 = GetElbowLx(&dParam);
|
|
|
|
dDn = dParam.dSize[0];//W H
|
|
dH = dParam.dSize[1];//末端
|
|
dt = dParam.dSize[2];//thick
|
|
dW1 = dParam.dSize[3];//开始端
|
|
dL3 = dL / 3.0;
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
vtNorm.normalize();
|
|
|
|
AcGeVector3d vtW = vtMaj;
|
|
vtW.rotateBy(PI / 2.0,vtNorm);
|
|
vtW.normalize();
|
|
|
|
int nStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);
|
|
|
|
double dSingleW = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);
|
|
|
|
AcGeLine3d ln(AcGePoint3d::kOrigin,vtNorm);
|
|
|
|
nStyle = 2;//双线
|
|
AcGePoint3d ptGe[10],ptS,ptE,*pptGe = NULL;
|
|
int nPoints = 0,nS = 0,nE = 0;
|
|
|
|
switch (nStyle)
|
|
{
|
|
case 0://单线
|
|
case 1://单线
|
|
{
|
|
//暂不绘制单线
|
|
break;
|
|
}
|
|
case 2://双线
|
|
{
|
|
if (ln.isPerpendicularTo(AcGePlane::kXYPlane))//水平放置
|
|
{
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * 0.5 * dL;
|
|
ptGe[0] += vtW * 0.5 * dW1;
|
|
|
|
if (nEcCen == 0)
|
|
{
|
|
ptGe[3] = ptMid;
|
|
ptGe[3] += vtMaj * 0.5 * dL;
|
|
ptGe[3] += vtW * 0.5 * dDn;
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * dL3;
|
|
ptGe[2] = ptGe[3] - vtMaj * dL3;
|
|
|
|
ptGe[4] = ptGe[3] - vtW * dDn;
|
|
ptGe[5] = ptGe[2] - vtW * dDn;
|
|
|
|
ptGe[6] = ptGe[1] - vtW * dW1;
|
|
ptGe[7] = ptGe[0] - vtW * dW1;
|
|
ptGe[8] = ptGe[0];
|
|
|
|
nPoints = 9;
|
|
nS = 4;
|
|
nE = 4;
|
|
|
|
ptS = MidPoint(ptGe[0], ptGe[7]);
|
|
ptE = MidPoint(ptGe[3], ptGe[4]);
|
|
}
|
|
else if (nEcCen == 1)
|
|
{
|
|
ptGe[1] = ptGe[0] + vtMaj * dL;
|
|
|
|
ptGe[2] = ptGe[1] - vtW * dDn;
|
|
ptGe[3] = ptGe[2] - vtMaj * dL3;
|
|
|
|
ptGe[5] = ptGe[0] - vtW * dW1;
|
|
ptGe[4] = ptGe[5] + vtMaj * dL3;
|
|
|
|
ptGe[6] = ptGe[0];
|
|
|
|
nPoints = 7;
|
|
nS = 2;
|
|
nE = 4;
|
|
|
|
ptS = MidPoint(ptGe[0], ptGe[5]);
|
|
ptE = MidPoint(ptGe[1], ptGe[2]);
|
|
}
|
|
else if (nEcCen == 2)
|
|
{
|
|
ptGe[3] = ptMid;
|
|
ptGe[3] -= vtMaj * 0.5 * dL;
|
|
ptGe[3] -= vtW * 0.5 * dW1;
|
|
ptGe[3] += vtMaj * dL;
|
|
ptGe[3] += vtW * dDn;
|
|
|
|
ptGe[2] = ptGe[3] - vtMaj * dL3;
|
|
ptGe[1] = ptGe[0] + vtMaj * dL3;
|
|
|
|
ptGe[4] = ptGe[3] - vtW * dDn;
|
|
ptGe[5] = ptGe[0] - vtW * dW1;
|
|
|
|
ptGe[6] = ptGe[0];
|
|
|
|
nPoints = 7;
|
|
nS = 4;
|
|
nE = 2;
|
|
|
|
ptS = MidPoint(ptGe[0], ptGe[5]);
|
|
ptE = MidPoint(ptGe[3], ptGe[4]);
|
|
}
|
|
|
|
AcDbPolyline *pPl = NULL;
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
if (bHide)//隐藏两头端线
|
|
{
|
|
pPl = FormatPolyline(ptGe, nS);
|
|
if (pPl != NULL)
|
|
{
|
|
dc.SetLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
pptGe = ptGe;
|
|
pptGe += nS;
|
|
pPl = FormatPolyline(pptGe, nE);
|
|
if (pPl != NULL)
|
|
{
|
|
dc.SetLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pPl = FormatPolyline(ptGe,nPoints);
|
|
if (pPl != NULL)
|
|
{
|
|
dc.SetLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptS;
|
|
ptGe[1] = ptE;
|
|
|
|
//中心线
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe,2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( ln.isParallelTo(AcGePlane::kXYPlane))//垂直放置 绘制 []形状
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrReduce2d(AcGiDraw &dc) const
|
|
{
|
|
AcGeVector3d vtMaj, vtMin, vtNorm(0, 0, 1);
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dL = 0.0;
|
|
double dThick = 0.35, dH = 0.0, dW1 = 0.0, dt = 0.0;
|
|
|
|
int nEcCen = 0;//偏心
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
m_mapSpecXData.GetAt(KEY_L, dL);
|
|
m_mapSpecXData.GetAt(KEY_NORMAL, vtNorm);
|
|
m_mapSpecXData.GetAt(KEY_ECCEN, nEcCen);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//W H
|
|
dH = dParam.dSize[1];//末端
|
|
dt = dParam.dSize[2];//thick
|
|
dW1 = dParam.dSize[3];//开始端
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
vtNorm.normalize();
|
|
|
|
AcGeVector3d vtW = vtMaj;
|
|
vtW.rotateBy(PI / 2.0, vtNorm);
|
|
vtW.normalize();
|
|
|
|
int nStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);
|
|
|
|
double dSingleW = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);
|
|
|
|
AcGeLine3d ln(AcGePoint3d::kOrigin, vtNorm);
|
|
|
|
nStyle = 2;//双线
|
|
AcGePoint3d ptGe[10];
|
|
switch (nStyle)
|
|
{
|
|
case 0://单线
|
|
case 1://单线
|
|
{
|
|
//暂不绘制单线
|
|
break;
|
|
}
|
|
case 2://双线
|
|
{
|
|
if (ln.isPerpendicularTo(AcGePlane::kXYPlane))//水平放置
|
|
{
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * 0.5 * dL;
|
|
ptGe[0] += vtW * 0.5 * dW1;
|
|
|
|
if (nEcCen == 0)
|
|
{
|
|
ptGe[1] = ptMid;
|
|
ptGe[1] += vtMaj * 0.5 * dL;
|
|
ptGe[1] += vtW * 0.5 * dDn;
|
|
}
|
|
else if (nEcCen == 1)
|
|
{
|
|
ptGe[1] = ptGe[0] + vtMaj * dL;
|
|
}
|
|
else if (nEcCen == 2)
|
|
{
|
|
ptGe[1] = ptMid;
|
|
ptGe[1] -= vtMaj * 0.5 * dL;
|
|
ptGe[1] -= vtW * 0.5 * dW1;
|
|
ptGe[1] += vtMaj * dL;
|
|
ptGe[1] += vtW * dDn;
|
|
}
|
|
|
|
ptGe[2] = ptGe[1] - vtW * dDn;
|
|
ptGe[3] = ptGe[0] - vtW * dW1;
|
|
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline *pPl = NULL;
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
if (bHide)
|
|
{
|
|
AcGePoint3d *ptGe2 = ptGe;
|
|
pPl = FormatPolyline(ptGe2, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
dc.SetLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
ptGe2 += 2;
|
|
pPl = FormatPolyline(ptGe2, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
dc.SetLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
dc.SetLayer(layerId());
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = MidPoint(ptGe[0], ptGe[3]);
|
|
ptGe[1] = MidPoint(ptGe[1], ptGe[2]);
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawOffset2d(AcGiDraw &dc) const
|
|
{
|
|
//两个弯头,且水平放置,或垂直放置
|
|
//90 < A < 180.0 乙字弯角度
|
|
|
|
assertReadEnabled();
|
|
|
|
AcGeVector3d vtMaj,vtMin,vtNorm,vtOffset;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0,dRatio = 1.0,dSweepAngle = PI / 2.0;
|
|
double dThick = 0.35,dLx = 50.0,dL = 0.0,dW = 0.0;
|
|
double dOffsetH = 0.0;//偏西距离
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);//进口方向
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);//出口方向
|
|
m_mapSpecXData.GetAt(KEY_OFFSETDIR,vtOffset);//偏移方向
|
|
//vtMaj == vtMin
|
|
|
|
m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);//中间点
|
|
m_mapSpecXData.GetAt(KEY_Offset,dOffsetH);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
double dH = dParam.dSize[1];//H
|
|
double dR = dDn * dRatio;
|
|
dW = dParam.dSize[1];//
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
vtNorm.normalize();
|
|
vtOffset.normalize();
|
|
|
|
//偏移方向的反方向
|
|
AcGeVector3d vtV = vtOffset;//Maj->Min的方向
|
|
vtV = vtV.orthoProject(vtMaj);//MAKE SURE
|
|
vtV.negate();
|
|
vtV.normalize();
|
|
|
|
if (dOffsetH < 1.e-6)
|
|
{
|
|
acutPrintf(_T("\nOffset dist error!"));
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//乙字弯角度 90 < A < 180
|
|
if ( ( dSweepAngle - 90.0 ) > 1.e-10 && (dSweepAngle - 180.0) < 1.e-10)
|
|
{
|
|
//转化为弧度
|
|
dSweepAngle *= PI / 180.0;
|
|
|
|
double dChrodx = dR * tan(dSweepAngle * 0.5);
|
|
|
|
//斜段总桥架长度
|
|
double dLseg = dOffsetH / sin(dSweepAngle);//180-a
|
|
|
|
//投影到maj方向上 水平总长
|
|
double dL = dOffsetH / fabs(tan(dSweepAngle));//180-a
|
|
dL += dChrodx * 2.0;
|
|
|
|
//伞心中最大对角线长
|
|
double dAL = sqrt(dR * dR + dChrodx * dChrodx);
|
|
|
|
AcGeLine3d ln(AcGePoint3d::kOrigin,vtNorm);
|
|
if (ln.isParallelTo(AcGePlane::kXYPlane))//垂直桥架的Z字弯头
|
|
{
|
|
//绘制水平投影即可
|
|
AcGePoint3d ptGe[5];
|
|
|
|
ptMid.z = 0.0;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * 0.5 * dL;
|
|
ptGe[0] += vtNorm * 0.5 * dDn;
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * dL;
|
|
ptGe[2] = ptGe[1] - vtNorm * dDn;
|
|
ptGe[3] = ptGe[0] - vtNorm * dDn;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
|
|
//绘制外弧度界限 中心位置投影示意
|
|
double dAX = dChrodx;
|
|
AcGePoint3d ptGeA[4];
|
|
|
|
ptGeA[0] = ptGe[0] + vtMaj * dAX;
|
|
ptGeA[1] = ptGe[3] + vtMaj * dAX;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeA,2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
ptGeA[2] = ptGe[1] - vtMaj * dAX;
|
|
ptGeA[3] = ptGe[2] - vtMaj * dAX;
|
|
|
|
ptGeA[0] = ptGeA[2];
|
|
ptGeA[1] = ptGeA[3];
|
|
pPl = FormatPolyline(ptGeA,2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else if (ln.isPerpendicularTo(AcGePlane::kXYPlane))//水平桥架的Z字弯头
|
|
{
|
|
AcGePoint3d ptGe[4];
|
|
|
|
ptGe[0] = ptMid - vtMaj * 0.5 * dL;
|
|
ptGe[0] += vtV * 0.5 * dOffsetH;
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * dChrodx;
|
|
|
|
AcGeVector3d vtMidL = ptMid - ptGe[1];
|
|
vtMidL.normalize();
|
|
ptGe[2] = ptGe[1] + vtMidL * dLseg;
|
|
|
|
ptGe[3] = ptGe[2] + vtMin * dChrodx;
|
|
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGe,4);
|
|
if (pPl != NULL)
|
|
{
|
|
AcDbVoidPtrArray arOff1,arOff2;
|
|
pPl->getOffsetCurves( dDn * 0.5,arOff1);
|
|
pPl->getOffsetCurves(-dDn * 0.5,arOff2);
|
|
|
|
if (arOff1.length() == 1 && arOff2.length() == 1)
|
|
{
|
|
AcDbCurve* pCurve1 = (AcDbCurve*)arOff1.first();
|
|
AcDbCurve* pCurve2 = (AcDbCurve*)arOff2.last();
|
|
|
|
if (pCurve1 != NULL && pCurve2 != NULL)
|
|
{
|
|
pCurve1->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pCurve1);
|
|
Add2DBuffer(pCurve1);
|
|
|
|
pCurve2->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pCurve2);
|
|
Add2DBuffer(pCurve2);
|
|
|
|
AcDbLine *pLn = NULL;
|
|
if (!bHide)
|
|
{
|
|
pCurve1->getStartPoint(ptGe[0]);
|
|
pCurve2->getStartPoint(ptGe[1]);
|
|
|
|
pLn = new AcDbLine(ptGe[0],ptGe[1]);
|
|
if (pLn != NULL)
|
|
{
|
|
pLn->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
|
|
pCurve1->getEndPoint(ptGe[0]);
|
|
pCurve2->getEndPoint(ptGe[1]);
|
|
|
|
pLn = new AcDbLine(ptGe[0],ptGe[1]);
|
|
if (pLn != NULL)
|
|
{
|
|
pLn->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//删除中心线
|
|
delete pPl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//...其他斜方向不画
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrOffset2d(AcGiDraw &dc) const
|
|
{
|
|
//两个弯头,且水平放置,或垂直放置
|
|
//90 < A < 180.0 乙字弯角度
|
|
|
|
assertReadEnabled();
|
|
|
|
AcGeVector3d vtMaj, vtMin, vtNorm, vtOffset;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dSweepAngle = PI / 2.0;
|
|
double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0;
|
|
double dOffsetH = 0.0;//偏西距离
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);//进口方向
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);//出口方向
|
|
m_mapSpecXData.GetAt(KEY_OFFSETDIR, vtOffset);//偏移方向
|
|
//vtMaj == vtMin
|
|
|
|
m_mapSpecXData.GetAt(KEY_NORMAL, vtNorm);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);//中间点
|
|
m_mapSpecXData.GetAt(KEY_Offset, dOffsetH);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG, dSweepAngle);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
double dH = dParam.dSize[1];//H
|
|
double dR = dDn * dRatio;
|
|
dW = dParam.dSize[1];//
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
vtNorm.normalize();
|
|
vtOffset.normalize();
|
|
|
|
//偏移方向的反方向
|
|
AcGeVector3d vtV = vtOffset;//Maj->Min的方向
|
|
vtV = vtV.orthoProject(vtMaj);//MAKE SURE
|
|
vtV.negate();
|
|
vtV.normalize();
|
|
|
|
if (dOffsetH < 1.e-6)
|
|
{
|
|
acutPrintf(_T("\nOffset dist error!"));
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//乙字弯角度 90 < A < 180
|
|
if ((dSweepAngle - 90.0) > 1.e-10 && (dSweepAngle - 180.0) < 1.e-10)
|
|
{
|
|
//转化为弧度
|
|
dSweepAngle *= PI / 180.0;
|
|
|
|
double dChrodx = dR * tan(dSweepAngle * 0.5);
|
|
|
|
//斜段总桥架长度
|
|
double dLseg = dOffsetH / sin(dSweepAngle);//180-a
|
|
|
|
//投影到maj方向上 水平总长
|
|
double dL = dOffsetH / fabs(tan(dSweepAngle));//180-a
|
|
dL += dChrodx * 2.0;
|
|
|
|
//伞心中最大对角线长
|
|
double dAL = sqrt(dR * dR + dChrodx * dChrodx);
|
|
|
|
AcGeLine3d ln(AcGePoint3d::kOrigin, vtNorm);
|
|
|
|
if (ln.isPerpendicularTo(AcGePlane::kXYPlane))//电缆沟水平
|
|
{
|
|
AcGePoint3d ptGe[4];
|
|
|
|
ptGe[0] = ptMid - vtMaj * 0.5 * dL;
|
|
ptGe[0] += vtV * 0.5 * dOffsetH;
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * dChrodx;
|
|
|
|
AcGeVector3d vtMidL = ptMid - ptGe[1];
|
|
vtMidL.normalize();
|
|
ptGe[2] = ptGe[1] + vtMidL * dLseg;
|
|
|
|
ptGe[3] = ptGe[2] + vtMin * dChrodx;
|
|
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
AcDbPolyline *pPl = FormatPolyline(ptGe, 4);
|
|
if (pPl != NULL)
|
|
{
|
|
AcDbVoidPtrArray arOff1, arOff2;
|
|
pPl->getOffsetCurves(dDn * 0.5, arOff1);
|
|
pPl->getOffsetCurves(-dDn * 0.5, arOff2);
|
|
|
|
if (arOff1.length() == 1 && arOff2.length() == 1)
|
|
{
|
|
AcDbCurve *pCurve1 = (AcDbCurve *)arOff1.first();
|
|
AcDbCurve *pCurve2 = (AcDbCurve *)arOff2.last();
|
|
|
|
if (pCurve1 != NULL && pCurve2 != NULL)
|
|
{
|
|
pCurve1->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pCurve1);
|
|
Add2DBuffer(pCurve1);
|
|
|
|
pCurve2->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pCurve2);
|
|
Add2DBuffer(pCurve2);
|
|
|
|
AcDbLine *pLn = NULL;
|
|
if (!bHide)
|
|
{
|
|
pCurve1->getStartPoint(ptGe[0]);
|
|
pCurve2->getStartPoint(ptGe[1]);
|
|
|
|
pLn = new AcDbLine(ptGe[0], ptGe[1]);
|
|
if (pLn != NULL)
|
|
{
|
|
pLn->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
|
|
pCurve1->getEndPoint(ptGe[0]);
|
|
pCurve2->getEndPoint(ptGe[1]);
|
|
|
|
pLn = new AcDbLine(ptGe[0], ptGe[1]);
|
|
if (pLn != NULL)
|
|
{
|
|
pLn->setLayer(m_idDoubleLayer);
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//删除中心线
|
|
delete pPl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//...其他斜方向不画
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
int AecDbEcFitting::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecDbObjXDataMap xData;
|
|
|
|
AcDbEntity* pEnt = NULL,*pEntCln = NULL;
|
|
const AcDbVoidPtrArray &ar2D = Get2DBuffer();
|
|
for (int i = 0;i < ar2D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar2D.at(i);
|
|
pEntCln = (AcDbEntity*)pEnt->clone();
|
|
|
|
if (xData.Read(pEnt,BIMDATA_APP))
|
|
{
|
|
xData.SetAt(KEY_ID,m_sGUID);
|
|
xData.Write(pEntCln,BIMDATA_APP);
|
|
}
|
|
arEntPtrs.append(pEntCln);
|
|
}
|
|
return arEntPtrs.length();
|
|
}
|
|
|
|
int AecDbEcFitting::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs,bool bWriteBimInfo) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbEntity* pEnt = NULL,*pEntClone = NULL;
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0;i < ar3D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar3D.at(i);
|
|
pEntClone = (AcDbEntity*)pEnt->clone();
|
|
|
|
int nColor = 0;
|
|
if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
|
|
{
|
|
pEntClone->setColorIndex(nColor);
|
|
}
|
|
else
|
|
{
|
|
pEntClone->setColorIndex(colorIndex());
|
|
}
|
|
|
|
pEntClone->setLayer(layerId());
|
|
if (bWriteBimInfo)
|
|
{
|
|
m_mapSpecXData.Write(pEntClone,_T("BIMDATA"));
|
|
}
|
|
arEntPtrs.append(pEntClone);
|
|
}
|
|
return arEntPtrs.length();
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//管线系统屏蔽掉
|
|
if ( dc.IsDragging() )
|
|
{
|
|
//return Acad::eOk;
|
|
}
|
|
|
|
//图层
|
|
AcDbObjectId idLay = dc.GetLayerId();
|
|
dc.SetLayer(layerId());
|
|
//dc.SetSelectionMarker(1);
|
|
|
|
int nCrBk = dc.GetColor();
|
|
int nColor = nCrBk;
|
|
if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
|
|
{
|
|
dc.SetColor(nColor);
|
|
}
|
|
|
|
if (IsActive())
|
|
{
|
|
dc.SetColor(kMagenta);
|
|
}
|
|
|
|
if (Has3DBuffer())
|
|
{
|
|
AcDbEntity* pSubEnt = NULL;
|
|
AcDbEntity* pEnt = NULL;
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0;i < ar3D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar3D.at(i);
|
|
if (IsActive())
|
|
{
|
|
pSubEnt = pEnt;
|
|
pEnt->setColorIndex(kMagenta);
|
|
}
|
|
else
|
|
{
|
|
pEnt->setColorIndex(nColor);
|
|
}
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
|
|
dc.SetLayer(idLay);
|
|
dc.SetColor(nCrBk);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
int nApp = 7;
|
|
m_mapSpecXData.GetAt(KEY_APP, nApp);
|
|
|
|
WPipe::EApp eApp = (WPipe::EApp)nApp;
|
|
switch (eApp)
|
|
{
|
|
case WPipe::eBridge:
|
|
{
|
|
DrawBridge3D(dc);
|
|
break;
|
|
}
|
|
case WPipe::eTrench:
|
|
{
|
|
DrawTrech3D(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
DrawUserInf3d(dc);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
extern AcDbRegion *CreateRegion(const AcGePoint3d *pptGe, int nPoints, const AcGeVector3d &vtNorm, double dt);
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::BoolSubtractUserInf3d(AecDbX3dPart& part) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcCmTransparency tr = transparency();
|
|
|
|
double dt = 0.0;
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dt);
|
|
|
|
AcGeVector3d vtDirThick;
|
|
AecUserInterface inf2;
|
|
AcDbLine lnPath;
|
|
AcDbRegion *pRegion = NULL;
|
|
for (int i = 0; i < m_arUserInfs.length(); i++)
|
|
{
|
|
const AecUserInterface &inf = m_arUserInfs.at(i);
|
|
memcpy(&inf2, &inf, sizeof(AecUserInterface));
|
|
|
|
vtDirThick = inf.vtDir;
|
|
vtDirThick.normalize();
|
|
vtDirThick *= 2.0 *dt;
|
|
|
|
lnPath.setStartPoint(inf.ptGe[0] - vtDirThick);
|
|
lnPath.setEndPoint(inf.ptGe[0] + vtDirThick);
|
|
|
|
for (int ii = 0;ii < inf2.nPoints;ii++)
|
|
{
|
|
inf2.ptGe[ii] -= vtDirThick;
|
|
}
|
|
|
|
if (inf.nPoints >= 3) //多边形
|
|
{
|
|
pRegion = CreateRegion(inf2.ptGe, inf2.nPoints, inf2.vtDir, 0);
|
|
if (pRegion != NULL)
|
|
{
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegion, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop, AcDb::kBoolSubtract);
|
|
}
|
|
}
|
|
else if (inf.nPoints == 2)//圆
|
|
{
|
|
pRegion = CreateRegion(inf2.ptGe, inf2.nPoints, inf2.vtDir, 0);
|
|
if (pRegion != NULL)
|
|
{
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegion, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop, AcDb::kBoolSubtract);
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawUserInf3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcCmTransparency tr = transparency();
|
|
|
|
double dt = 0.0;
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dt);
|
|
|
|
AcDbLine lnPath;
|
|
AcDbRegion *pRegion = NULL;
|
|
for (int i = 0; i < m_arUserInfs.length(); i++)
|
|
{
|
|
const AecUserInterface &inf = m_arUserInfs.at(i);
|
|
|
|
lnPath.setStartPoint(inf.ptGe[0]);
|
|
lnPath.setEndPoint(inf.ptGe[0] + inf.vtDir);
|
|
|
|
AecDbX3dPart part;
|
|
if (inf.nPoints >= 3) //多边形
|
|
{
|
|
pRegion = CreateRegion(inf.ptGe, inf.nPoints, inf.vtDir, dt);
|
|
if (pRegion != NULL)
|
|
{
|
|
//CoreTools::AddToModelSpace(pRegion);
|
|
//CoreTools::CloneAndAddToModelSpace(&lnPath);
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegion, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop);
|
|
}
|
|
}
|
|
else if (inf.nPoints == 2)//圆
|
|
{
|
|
pRegion = CreateRegion(inf.ptGe, inf.nPoints, inf.vtDir, dt);
|
|
if (pRegion != NULL)
|
|
{
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegion, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop);
|
|
}
|
|
}
|
|
|
|
part.Create();
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawElbow3d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
|
|
m_mapSpecXData.GetAt(HELB_Type, (int&)eElbowType);
|
|
|
|
switch(eElbowType)
|
|
{
|
|
case AecHvac::eIncline://内斜线方式
|
|
{
|
|
DrawIncline3d(dc);
|
|
break;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrElbow3d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
|
|
m_mapSpecXData.GetAt(HELB_Type, (int &)eElbowType);
|
|
|
|
switch (eElbowType)
|
|
{
|
|
case AecHvac::eIncline://内斜线方式
|
|
{
|
|
DrawTrIncline3d(dc);
|
|
break;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTee3d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacTeeType eTeeType = AecHvac::eTShapeBranch;
|
|
m_mapSpecXData.GetAt(HTEE_Type, (int&)eTeeType);
|
|
|
|
switch(eTeeType)
|
|
{
|
|
case AecHvac::eIncline2Branch://内斜线
|
|
{
|
|
DrawIncline2Tee3d(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrTee3d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacTeeType eTeeType = AecHvac::eTShapeBranch;
|
|
m_mapSpecXData.GetAt(HTEE_Type, (int &)eTeeType);
|
|
|
|
switch (eTeeType)
|
|
{
|
|
case AecHvac::eIncline2Branch://内斜线
|
|
{
|
|
DrawTrIncline2Tee3d(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee3d0(AcGiDraw &dc) const
|
|
{
|
|
AcCmTransparency tr = transparency();
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
|
|
double dThick = 0.35, dLx = 50.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn += 2.0 * dParam.dSize[2];
|
|
|
|
dDn2 = dParam.dSize[3];
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn2 += 2.0 * dParam.dSize[2];
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
|
|
double dL = dDn * dRatio;
|
|
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
{
|
|
if (dDn - dL > 1.e-6)
|
|
{
|
|
dL = __min(dDn, dDn2);
|
|
}
|
|
}
|
|
|
|
double dH = dParam.dSize[1];//
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(AcGePoint3d::kOrigin, vtNorm);
|
|
if (ln3d.isParallelTo(AcGePlane::kXYPlane))
|
|
{
|
|
double dTmp = dH;
|
|
dH = dDn;
|
|
dDn = dTmp;
|
|
}
|
|
|
|
AcGePoint3d ptGe[10];
|
|
AcGePoint3dArray arPts;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[0] -= vtMin * dDn * 0.5;
|
|
arPts.append(ptGe[0]);
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
|
|
arPts.append(ptGe[1]);
|
|
|
|
ptGe[2] = ptGe[1] + vtMin * dDn;
|
|
arPts.append(ptGe[2]);
|
|
|
|
ptGe[3] = ptGe[2] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
|
|
InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
|
|
arPts.append(ptGe[4]);
|
|
|
|
ptGe[5] = ptGe[4] - vtMaj * dDn2;
|
|
arPts.append(ptGe[5]);
|
|
|
|
ptGe[6] = ptGe[3] - vtMaj * dDn2;
|
|
ptGe[7] = ptGe[0] + vtMin * dDn;
|
|
InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
|
|
arPts.append(ptGe[7]);
|
|
|
|
ptGe[8] = ptGe[0];
|
|
arPts.append(ptGe[8]);
|
|
|
|
AcGePoint3d ptFr, ptTo;
|
|
AcDbLine lnPath;
|
|
AcDbRegion *pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(), arPts.length());
|
|
if (pRegOut != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dH;//H
|
|
ptTo = ptMid + vtNorm * 0.5 * dH;//H
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
AcGeMatrix3d xform;
|
|
AcGeVector3d vt = vtNorm * 0.5 * dH;
|
|
xform.setToTranslation(vt);
|
|
pRegOut->transformBy(xform);
|
|
|
|
AecDbX3dPart part;
|
|
|
|
AcDbX3dSolid *pX3dSolidOut = new AcDbX3dSolid;
|
|
pX3dSolidOut->CreateExtrude(pRegOut, lnPath);
|
|
part.AddX3dSolid(pX3dSolidOut);
|
|
|
|
OffsetPoint(ptGe[0], ptGe[7], dThick);
|
|
OffsetPoint(ptGe[1], ptGe[2], dThick);
|
|
OffsetPoint(ptGe[4], ptGe[5], dThick);
|
|
|
|
AcGePoint3d ptTemp = ptMid;
|
|
OffsetPoint(ptGe[6], ptTemp, dThick * 1.41421356);
|
|
|
|
ptTemp = ptMid;
|
|
OffsetPoint(ptGe[3], ptTemp, dThick * 1.41421356);
|
|
|
|
arPts.removeAll();
|
|
arPts.append(ptGe[0]);
|
|
arPts.append(ptGe[1]);
|
|
arPts.append(ptGe[2]);
|
|
|
|
InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
|
|
arPts.append(ptGe[4]);
|
|
|
|
arPts.append(ptGe[5]);
|
|
InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
|
|
arPts.append(ptGe[7]);
|
|
|
|
ptGe[8] = ptGe[0];
|
|
arPts.append(ptGe[8]);
|
|
|
|
AcDbRegion *pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(), arPts.length());
|
|
if (pRegIn != NULL)
|
|
{
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
|
|
!dParam.m_bCover)
|
|
{
|
|
//水平放置,不带盖子时
|
|
AcGeVector3d vtRegNorm;
|
|
pRegIn->getNormal(vtRegNorm);
|
|
|
|
ptFr = ptMid - vtRegNorm * 0.5 * dH;
|
|
ptTo = ptMid + vtRegNorm * 0.5 * (dH - 2.0 * dThick);//H
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtRegNorm * 0.5 * dH;
|
|
}
|
|
else
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * (dH - 2.0 * dThick);//H
|
|
ptTo = ptMid + vtNorm * 0.5 * (dH - 2.0 * dThick);//H
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtNorm * 0.5 * (dH - 2.0 * dThick);
|
|
}
|
|
|
|
xform.setToTranslation(vt);
|
|
pRegIn->transformBy(xform);
|
|
|
|
AcDbX3dSolid *pX3dSolidIn = new AcDbX3dSolid;
|
|
pX3dSolidIn->CreateExtrude(pRegIn, lnPath);
|
|
part.AddX3dSolid(pX3dSolidIn, AcDb::kBoolSubtract);
|
|
|
|
BoolSubtractUserInf3d(part);
|
|
part.Create();
|
|
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
delete pRegIn;
|
|
}
|
|
delete pRegOut;
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee3d3(AcGiDraw &dc) const
|
|
{
|
|
AcCmTransparency tr = transparency();
|
|
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
|
|
double dThick = 0.35, dLx = 50.0, dH = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
dH = dParam.dSize[1];// H
|
|
dDn2 = dParam.dSize[3];//分支宽度
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
|
|
double dL = dDn * dRatio;
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
vtNorm.normalize();
|
|
|
|
AcGePoint3d ptGe[5],ptGeI[5], ptFr,ptTo;
|
|
|
|
AcGeVector3d vtX, vtZ, vtY;
|
|
if (vtMin.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtZ = vtMin;
|
|
vtX = vtMaj;
|
|
}
|
|
if (vtMaj.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtZ = vtMaj;
|
|
vtX = vtMin;
|
|
}
|
|
vtY = vtX;
|
|
vtY.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
|
|
AcGeLine3d ln(ptMid, vtX);
|
|
if (ln.isParallelTo(AcGePlane::kXYPlane))
|
|
{
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtX * (dL + dLx);
|
|
ptGe[0] += vtY * 0.5 * dDn;
|
|
|
|
ptGe[1] = ptGe[0] + vtX * 2.0 * (dL + dLx);
|
|
ptGe[2] = ptGe[1] - vtY * dDn;
|
|
ptGe[3] = ptGe[0] - vtY * dDn;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 5);
|
|
|
|
OffsetPoint(ptGeI[0], ptGeI[3], dThick);
|
|
OffsetPoint(ptGeI[1], ptGeI[2], dThick);
|
|
ptGeI[4] = ptGeI[0];
|
|
|
|
AcDbLine lnPath;
|
|
AcDbRegion *pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegOut != NULL)
|
|
{
|
|
ptFr = ptMid - vtMin * 0.5 * dH;//W
|
|
ptTo = ptMid + vtMin * 0.5 * dH;//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
AcGeMatrix3d xform;
|
|
AcGeVector3d vt = vtMin * 0.5 * dH;
|
|
xform.setToTranslation(vt);
|
|
pRegOut->transformBy(xform);
|
|
|
|
AecDbX3dPart part;
|
|
AcDbX3dSolid *pX3dSolidOut = new AcDbX3dSolid;
|
|
pX3dSolidOut->CreateExtrude(pRegOut, lnPath);
|
|
part.AddX3dSolid(pX3dSolidOut);
|
|
|
|
AcDbRegion *pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 5);
|
|
if (pRegIn != NULL)
|
|
{
|
|
if (vtMin.isParallelTo(AcGeVector3d::kZAxis) &&
|
|
!dParam.m_bCover)
|
|
{
|
|
//水平放置,不带盖子时
|
|
AcGeVector3d vtRegNorm;
|
|
pRegIn->getNormal(vtRegNorm);
|
|
|
|
ptFr = ptMid - vtRegNorm * 0.5 * dH;
|
|
ptTo = ptMid + vtRegNorm * 0.5 * (dH - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtRegNorm * 0.5 * dH;
|
|
}
|
|
else
|
|
{
|
|
ptFr = ptMid - vtMin * 0.5 * (dH - 2.0 * dThick);//W
|
|
ptTo = ptMid + vtMin * 0.5 * (dH - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtMin * 0.5 * (dH - 2.0 * dThick);
|
|
}
|
|
|
|
xform.setToTranslation(vt);
|
|
pRegIn->transformBy(xform);
|
|
|
|
AcDbX3dSolid *pX3dSolidIn = new AcDbX3dSolid;
|
|
pX3dSolidIn->CreateExtrude(pRegIn, lnPath);
|
|
part.AddX3dSolid(pX3dSolidIn, AcDb::kBoolSubtract);
|
|
|
|
BoolSubtractUserInf3d(part);
|
|
part.Create();
|
|
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
delete pRegIn;
|
|
}
|
|
delete pRegOut;
|
|
}
|
|
|
|
//Z方向
|
|
//调用 drawuserinf3d
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee3d5(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcCmTransparency tr = transparency();
|
|
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dSweepAngle = PI / 2.0, dH = 0;
|
|
double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0, dDn2 = 0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG, dSweepAngle);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
int nElbowStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_ELBOWSTYLE, nElbowStyle);
|
|
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
vtNorm.normalize();
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
|
|
AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
|
|
AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
|
|
vtMV.normalize();
|
|
vtNV.normalize();
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[3];
|
|
dDn2 = dParam.dSize[0];//末端
|
|
if (dDn < 1.e-6) dDn = dDn2;
|
|
|
|
dW = dParam.dSize[1];
|
|
dH = dW;
|
|
//dL = dDn * dRatio + dLx;
|
|
dL = GetElbowL(&dParam);
|
|
dL += dLx;//三通长度
|
|
|
|
AcGePoint3d ptGe[8], ptFr, ptTo, ptTmp, ptGeI[8], ptGeU[8], ptGeUI[8];
|
|
AcDbLine lnPath;
|
|
AecDbX3dPart part;
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//水平放置
|
|
{
|
|
//OUT
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[0] -= vtMV * 0.5 * dDn;
|
|
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
ptGe[2] -= vtNV * 0.5 * dDn2;
|
|
|
|
AcGeLine3d ln1(ptGe[0], vtMaj);
|
|
AcGeLine3d ln2(ptGe[2], vtMin);
|
|
ln1.intersectWith(ln2, ptGe[1]);
|
|
|
|
ptGe[3] = ptGe[2] + vtNV * dDn2;
|
|
ptGe[4] = ptGe[3] - vtMin * dLx;
|
|
|
|
ptGe[6] = ptGe[0] + vtMV * dDn;
|
|
ptGe[5] = ptGe[6] - vtMaj * dLx;
|
|
|
|
ptGe[7] = ptGe[0];
|
|
|
|
//In
|
|
AcGePoint3d ptTmp;
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 8);
|
|
OffsetPoint(ptGeI[0], ptGeI[6], dThick);
|
|
|
|
ptTmp = ptGeI[0];
|
|
OffsetPoint(ptTmp, ptGeI[1], dThick);
|
|
|
|
OffsetPoint(ptGeI[2], ptGeI[3], dThick);
|
|
|
|
ptGeI[5] = ptGeI[6] - vtMaj * (dLx + dThick);//大约
|
|
ptGeI[4] = ptGeI[3] - vtMin * (dLx + dThick);//大约
|
|
ptGeI[7] = ptGeI[0];
|
|
|
|
AcDbLine lnPath;
|
|
AcDbRegion *pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 8);
|
|
if (pRegOut != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dW;//W
|
|
ptTo = ptMid + vtNorm * 0.5 * dW;//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
AcGeMatrix3d xform;
|
|
AcGeVector3d vt = vtNorm * 0.5 * dW;
|
|
xform.setToTranslation(vt);
|
|
pRegOut->transformBy(xform);
|
|
|
|
AecDbX3dPart part;
|
|
AcDbX3dSolid *pX3dSolidOut = new AcDbX3dSolid;
|
|
pX3dSolidOut->CreateExtrude(pRegOut, lnPath);
|
|
part.AddX3dSolid(pX3dSolidOut);
|
|
|
|
AcDbRegion *pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 8);
|
|
if (pRegIn != NULL)
|
|
{
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
|
|
!dParam.m_bCover)
|
|
{
|
|
//水平放置,不带盖子时
|
|
AcGeVector3d vtRegNorm;
|
|
pRegIn->getNormal(vtRegNorm);
|
|
|
|
ptFr = ptMid - vtRegNorm * 0.5 * dW;
|
|
ptTo = ptMid + vtRegNorm * 0.5 * (dW - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtRegNorm * 0.5 * dW;
|
|
}
|
|
else
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * (dW - 2.0 * dThick);//W
|
|
ptTo = ptMid + vtNorm * 0.5 * (dW - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtNorm * 0.5 * (dW - 2.0 * dThick);
|
|
}
|
|
|
|
xform.setToTranslation(vt);
|
|
pRegIn->transformBy(xform);
|
|
|
|
AcDbX3dSolid *pX3dSolidIn = new AcDbX3dSolid;
|
|
pX3dSolidIn->CreateExtrude(pRegIn, lnPath);
|
|
part.AddX3dSolid(pX3dSolidIn, AcDb::kBoolSubtract);
|
|
|
|
BoolSubtractUserInf3d(part);
|
|
part.Create();
|
|
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
delete pRegIn;
|
|
}
|
|
delete pRegOut;
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
AcGePoint3dArray arPts;
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
arPts.append(ptGe[i]);
|
|
}
|
|
AcDb3dPolyline *pPl3d = Format3dPolyline(arPts);
|
|
if (pPl3d != NULL)
|
|
{
|
|
dc.DrawEntity(pPl3d);
|
|
Add3DBuffer(pPl3d);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Z方向
|
|
//调用 drawuserinf3d
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee3d(AcGiDraw &dc) const
|
|
{
|
|
int nTeeStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_TEESTYLE, nTeeStyle);
|
|
|
|
switch (nTeeStyle)
|
|
{
|
|
case 0: //标准 =||=
|
|
{
|
|
DrawIncline2Tee3d0(dc);
|
|
break;
|
|
}
|
|
case 1: //上下 垂直三通 [ || ]
|
|
case 2: //上边垂直三通
|
|
case 3: //下边垂直三通
|
|
{
|
|
DrawIncline2Tee3d3(dc);
|
|
break;
|
|
}
|
|
case 4: //上边垂直三通
|
|
case 5: //下角垂直三通
|
|
{
|
|
DrawIncline2Tee3d5(dc);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrIncline2Tee3d(AcGiDraw &dc) const
|
|
{
|
|
AcCmTransparency tr = transparency();
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
|
|
double dThick = 0.35, dLx = 50.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
DlgData data;
|
|
memset(&data, 0, sizeof(DlgData));
|
|
GetDlgData(data, 0);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
double dL = dDn * dRatio;//不变
|
|
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn += 2.0 * dParam.dSize[2];
|
|
|
|
dDn2 = dParam.dSize[3];
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn2 += 2.0 * dParam.dSize[2];
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
|
|
double dH = dParam.dSize[1];//
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//一律向下
|
|
vtNorm.set(0, 0, -1);
|
|
|
|
AcGePoint3d ptGe[10],ptGeW[10];
|
|
AcGePoint3dArray arPts;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[0] -= vtMin * dDn * 0.5;
|
|
arPts.append(ptGe[0]);
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
|
|
arPts.append(ptGe[1]);
|
|
|
|
ptGe[2] = ptGe[1] + vtMin * dDn;
|
|
arPts.append(ptGe[2]);
|
|
|
|
ptGe[3] = ptGe[2] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
|
|
//电缆沟不需要倒角
|
|
arPts.append(ptGe[3]);
|
|
//InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
|
|
arPts.append(ptGe[4]);
|
|
|
|
ptGe[5] = ptGe[4] - vtMaj * dDn2;
|
|
arPts.append(ptGe[5]);
|
|
|
|
ptGe[6] = ptGe[3] - vtMaj * dDn2;
|
|
ptGe[7] = ptGe[0] + vtMin * dDn;
|
|
arPts.append(ptGe[6]);
|
|
//InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
|
|
arPts.append(ptGe[7]);
|
|
|
|
ptGe[8] = ptGe[0];
|
|
arPts.append(ptGe[8]);
|
|
|
|
AecDbX3dPart part;
|
|
AcGePoint3d ptFr, ptTo;
|
|
AcDbLine lnPath;
|
|
|
|
//顶板
|
|
AcDbRegion *pRegTop = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(), arPts.length());
|
|
if (pRegTop != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dH;//H
|
|
ptTo = ptFr + vtNorm * data.m_dk;//k
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegTop);
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegTop, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop);
|
|
}
|
|
|
|
//墙 vtMaj 直
|
|
ptGeW[0] = ptGe[0]; ptGeW[1] = ptGe[1];
|
|
ptGeW[2] = ptGeW[1] + vtMin * data.m_dt;
|
|
ptGeW[3] = ptGeW[0] + vtMin * data.m_dt;
|
|
ptGeW[4] = ptGeW[0];
|
|
AcDbRegion *pRegWall = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeW,5);
|
|
if (pRegWall != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall);
|
|
AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
|
|
pX3dWall1->CreateExtrude(pRegWall, lnPath);
|
|
part.AddX3dSolid(pX3dWall1);
|
|
}
|
|
|
|
//墙 vtMin 右
|
|
ptGeW[0] = ptGe[2]; ptGeW[1] = ptGe[3];
|
|
ptGeW[2] = ptGe[4];
|
|
ptGeW[3] = ptGeW[2] - vtMaj * data.m_dt;
|
|
ptGeW[5] = ptGeW[0] - vtMin * data.m_dt;
|
|
ptGeW[4] = GetIntersectPt(ptGeW[3], vtMin, ptGeW[5], vtMaj);
|
|
ptGeW[6] = ptGeW[0];
|
|
AcDbRegion *pRegWallR = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeW, 7);
|
|
if (pRegWallR != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWallR);
|
|
AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
|
|
pX3dWall1->CreateExtrude(pRegWallR, lnPath);
|
|
part.AddX3dSolid(pX3dWall1);
|
|
}
|
|
|
|
//墙 vtMin 左
|
|
ptGeW[0] = ptGe[5]; ptGeW[1] = ptGe[6];
|
|
ptGeW[2] = ptGe[7];
|
|
ptGeW[3] = ptGeW[2] - vtMin * data.m_dt;
|
|
ptGeW[5] = ptGeW[0] + vtMaj * data.m_dt;
|
|
ptGeW[4] = GetIntersectPt(ptGeW[3], vtMaj, ptGeW[5], vtMin);
|
|
ptGeW[6] = ptGeW[0];
|
|
AcDbRegion *pRegWallL = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeW, 7);
|
|
if (pRegWallL != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWallL);
|
|
AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
|
|
pX3dWall1->CreateExtrude(pRegWallL, lnPath);
|
|
part.AddX3dSolid(pX3dWall1);
|
|
}
|
|
|
|
DlgData data2;
|
|
memset(&data2, 0, sizeof(DlgData));
|
|
GetDlgData(data2, 1);
|
|
|
|
if (data2.m_dd < 1.e-6)
|
|
data2.m_dd = data.m_dd;
|
|
|
|
//底板
|
|
arPts.removeAll();
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[0] -= vtMin * 0.5 * data.m_dd;
|
|
arPts.append(ptGe[0]);
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
|
|
arPts.append(ptGe[1]);
|
|
|
|
ptGe[2] = ptGe[1] + vtMin * data.m_dd;
|
|
arPts.append(ptGe[2]);
|
|
|
|
ptGe[3] = ptGe[2] - vtMaj * (dL + dLx - 0.5 * data2.m_dd);
|
|
ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * data.m_dd);
|
|
|
|
//电缆沟不需要倒角
|
|
arPts.append(ptGe[3]);
|
|
//InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
|
|
arPts.append(ptGe[4]);
|
|
|
|
ptGe[5] = ptGe[4] - vtMaj * data2.m_dd;
|
|
arPts.append(ptGe[5]);
|
|
|
|
ptGe[6] = ptGe[3] - vtMaj * data2.m_dd;
|
|
ptGe[7] = ptGe[0] + vtMin * data.m_dd;
|
|
arPts.append(ptGe[6]);
|
|
//InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
|
|
arPts.append(ptGe[7]);
|
|
|
|
ptGe[8] = ptGe[0];
|
|
arPts.append(ptGe[8]);
|
|
|
|
AcDbRegion *pRegBom = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(), arPts.length());
|
|
if (pRegBom != NULL)
|
|
{
|
|
ptFr = ptMid + vtNorm * 0.5 * dH;//H
|
|
ptTo = ptFr - vtNorm * data.m_db;//H
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegBom);
|
|
AcDbX3dSolid *pX3dSlabB = new AcDbX3dSolid;
|
|
pX3dSlabB->CreateExtrude(pRegBom, lnPath);
|
|
part.AddX3dSolid(pX3dSlabB);
|
|
}
|
|
|
|
part.Create();
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawCross3d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacCrossType eTeeType = AecHvac::eOrthoCross;
|
|
m_mapSpecXData.GetAt(HCRS_Type, (int&)eTeeType);
|
|
|
|
switch(eTeeType)
|
|
{
|
|
case AecHvac::eInterCross://内斜线四通
|
|
{
|
|
DrawInterCross3d(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrCross3d(AcGiDraw &dc) const
|
|
{
|
|
//外直角,内斜线方式
|
|
//内外圆弧的方式2种
|
|
AecHvac::HvacCrossType eTeeType = AecHvac::eOrthoCross;
|
|
m_mapSpecXData.GetAt(HCRS_Type, (int &)eTeeType);
|
|
|
|
switch (eTeeType)
|
|
{
|
|
case AecHvac::eInterCross://内斜线四通
|
|
{
|
|
DrawTrInterCross3d(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawInterCross3d(AcGiDraw &dc) const
|
|
{
|
|
AcCmTransparency tr = transparency();
|
|
AcGeVector3d vtMaj,vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0,dRatio = 1.0,dDn2 = 0;
|
|
double dThick = 0.35,dLx = 50.0,dH = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn += 2.0 * dParam.dSize[2];
|
|
|
|
dDn2 = dParam.dSize[3];
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn2 += 2.0 * dParam.dSize[2];
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
dH = dParam.dSize[1];
|
|
double dL = dDn * dRatio;
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
{
|
|
if (dDn - dL > 1.e-6)
|
|
{
|
|
dL = __min(dDn, dDn2);
|
|
}
|
|
}
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
|
|
|
|
/* 2 3
|
|
| |
|
|
0___| 4 |___5
|
|
1
|
|
___10 7 ___6
|
|
11 | |
|
|
9 | |8
|
|
*/
|
|
|
|
AcGePoint3d ptGe[13];
|
|
AcGePoint3dArray arPts;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[0] -= vtMin * dDn * 0.5;
|
|
arPts.append(ptGe[0]);
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[2] = ptGe[1] - vtMin * (dL + dLx - 0.5 * dDn);
|
|
|
|
InsertL2Point(ptGe[0],ptGe[1],ptGe[2],dLx,arPts);
|
|
arPts.append(ptGe[2]);
|
|
|
|
ptGe[3] = ptGe[2] + vtMaj * dDn2;
|
|
arPts.append(ptGe[3]);
|
|
|
|
ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
ptGe[5] = ptGe[4] + vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
InsertL2Point(ptGe[3],ptGe[4],ptGe[5],dLx,arPts);
|
|
arPts.append(ptGe[5]);
|
|
|
|
ptGe[6] = ptGe[5] + vtMin * dDn;
|
|
arPts.append(ptGe[6]);
|
|
|
|
ptGe[7] = ptGe[6] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[8] = ptGe[7] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
InsertL2Point(ptGe[6],ptGe[7],ptGe[8],dLx,arPts);
|
|
arPts.append(ptGe[8]);
|
|
|
|
ptGe[9] = ptGe[8] - vtMaj * dDn2;
|
|
arPts.append(ptGe[9]);
|
|
|
|
ptGe[10] = ptGe[9] - vtMin * (dL + dLx - 0.5 * dDn);
|
|
ptGe[11] = ptGe[10] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
InsertL2Point(ptGe[9],ptGe[10],ptGe[11],dLx,arPts);
|
|
arPts.append(ptGe[11]);
|
|
arPts.append(ptGe[0]);
|
|
|
|
//TEST
|
|
/*AcDbPolyline* pPlOut = FormatPolyline(arPts.asArrayPtr(),arPts.length());
|
|
if (pPlOut != NULL)
|
|
{
|
|
pPlOut->setColorIndex(1);
|
|
AddToModelSpace(pPlOut);
|
|
}*/
|
|
|
|
AcGePoint3d ptFr,ptTo;
|
|
AcDbLine lnPath;
|
|
AcDbRegion* pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(),arPts.length());
|
|
if (pRegOut != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dH;//W
|
|
ptTo = ptMid + vtNorm * 0.5 * dH;//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
AcGeMatrix3d xform;
|
|
AcGeVector3d vt = vtNorm * 0.5 * dH;
|
|
xform.setToTranslation(vt);
|
|
pRegOut->transformBy(xform);
|
|
|
|
AecDbX3dPart part;
|
|
|
|
AcDbX3dSolid* pX3dSolidOut = new AcDbX3dSolid;
|
|
pX3dSolidOut->CreateExtrude(pRegOut,lnPath);
|
|
part.AddX3dSolid(pX3dSolidOut);
|
|
|
|
OffsetPoint(ptGe[0],ptGe[11],dThick);
|
|
OffsetPoint(ptGe[2],ptGe[3],dThick);
|
|
OffsetPoint(ptGe[5],ptGe[6],dThick);
|
|
OffsetPoint(ptGe[8],ptGe[9],dThick);
|
|
|
|
AcGePoint3d ptTemp = ptMid;
|
|
OffsetPoint(ptGe[1],ptTemp,dThick * 1.41421356);
|
|
|
|
ptTemp = ptMid;
|
|
OffsetPoint(ptGe[4],ptTemp,dThick * 1.41421356);
|
|
|
|
ptTemp = ptMid;
|
|
OffsetPoint(ptGe[7],ptTemp,dThick * 1.41421356);
|
|
|
|
ptTemp = ptMid;
|
|
OffsetPoint(ptGe[10],ptTemp,dThick * 1.41421356);
|
|
|
|
arPts.removeAll();
|
|
|
|
arPts.append(ptGe[0]);
|
|
InsertL2Point(ptGe[0],ptGe[1],ptGe[2],dLx,arPts);
|
|
arPts.append(ptGe[2]);
|
|
|
|
arPts.append(ptGe[3]);
|
|
InsertL2Point(ptGe[3],ptGe[4],ptGe[5],dLx,arPts);
|
|
arPts.append(ptGe[5]);
|
|
|
|
arPts.append(ptGe[6]);
|
|
InsertL2Point(ptGe[6],ptGe[7],ptGe[8],dLx,arPts);
|
|
arPts.append(ptGe[8]);
|
|
|
|
arPts.append(ptGe[9]);
|
|
InsertL2Point(ptGe[9],ptGe[10],ptGe[11],dLx,arPts);
|
|
arPts.append(ptGe[11]);
|
|
arPts.append(ptGe[0]);
|
|
|
|
|
|
AcDbRegion* pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(),arPts.length());
|
|
if (pRegIn != NULL)
|
|
{
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
|
|
!dParam.m_bCover)
|
|
{
|
|
//水平放置,不带盖子时
|
|
AcGeVector3d vtRegNorm;
|
|
pRegIn->getNormal(vtRegNorm);
|
|
|
|
ptFr = ptMid - vtRegNorm * 0.5 * dH;
|
|
ptTo = ptMid + vtRegNorm * 0.5 * (dH - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtRegNorm * 0.5 * dH;
|
|
}
|
|
else
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * (dH - 2.0 * dThick);//W
|
|
ptTo = ptMid + vtNorm * 0.5 * (dH - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtNorm * 0.5 * (dH - 2.0 * dThick);
|
|
}
|
|
|
|
xform.setToTranslation(vt);
|
|
pRegIn->transformBy(xform);
|
|
|
|
AcDbX3dSolid* pX3dSolidIn = new AcDbX3dSolid;
|
|
pX3dSolidIn->CreateExtrude(pRegIn,lnPath);
|
|
part.AddX3dSolid(pX3dSolidIn,AcDb::kBoolSubtract);
|
|
|
|
BoolSubtractUserInf3d(part);
|
|
part.Create();
|
|
|
|
AcDb3dSolid* pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
delete pRegIn;
|
|
}
|
|
delete pRegOut;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
static AcDbRegion* MakeCornerWallRegion(AcGePoint3d* pptGe,int nFr,double dt)
|
|
{
|
|
assert(pptGe != NULL);
|
|
AcGePoint3d ptGe[8];
|
|
AcGeVector3d vt1 = pptGe[nFr + 1] - pptGe[nFr + 0];
|
|
AcGeVector3d vt2 = pptGe[nFr + 1] - pptGe[nFr + 2];
|
|
vt1.normalize(); vt2.normalize();
|
|
|
|
ptGe[0] = pptGe[nFr+0];
|
|
ptGe[1] = pptGe[nFr+1];
|
|
ptGe[2] = pptGe[nFr+2];
|
|
|
|
ptGe[3] = ptGe[2] + vt1 * dt;
|
|
ptGe[5] = ptGe[0] + vt2 * dt;
|
|
ptGe[4] = GetIntersectPt(ptGe[3], vt2, ptGe[5], vt1);
|
|
ptGe[6] = ptGe[0];
|
|
|
|
AcDbRegion *pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 7);
|
|
return pReg;
|
|
}
|
|
|
|
static void OffsetPoint(AcGePoint3d * pptGe, int nFr, double dOff1, double dOff2)
|
|
{
|
|
assert(pptGe != NULL);
|
|
AcGeVector3d vt1 = pptGe[nFr + 1] - pptGe[nFr + 0];
|
|
AcGeVector3d vt2 = pptGe[nFr + 1] - pptGe[nFr + 2];
|
|
vt1.normalize(); vt2.normalize();
|
|
|
|
pptGe[nFr + 0] -= vt2 * dOff1;
|
|
pptGe[nFr + 2] -= vt1 * dOff2;
|
|
pptGe[nFr + 1] = GetIntersectPt(pptGe[nFr + 0], vt1, pptGe[nFr + 2], vt2);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrInterCross3d(AcGiDraw &dc) const
|
|
{
|
|
AcCmTransparency tr = transparency();
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dDn2 = 0;
|
|
double dThick = 0.35, dLx = 50.0, dH = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
DlgData data;
|
|
memset(&data, 0, sizeof(DlgData));
|
|
GetDlgData(data, 0);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
double dL = dDn * dRatio;
|
|
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn += 2.0 * dParam.dSize[2];
|
|
|
|
dDn2 = dParam.dSize[3];
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn2 += 2.0 * dParam.dSize[2];
|
|
|
|
if (dDn2 < 1.e-6)
|
|
dDn2 = dDn;
|
|
dH = dParam.dSize[1];
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//一律向下
|
|
vtNorm.set(0, 0, -1);
|
|
|
|
/* 2 3
|
|
| |
|
|
0___| 4 |___5
|
|
1
|
|
___10 7 ___6
|
|
11 | |
|
|
9 | |8
|
|
*/
|
|
|
|
AcGePoint3d ptGe[13],ptGeI[8];
|
|
AcGePoint3dArray arPts;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * (dL + dLx);
|
|
ptGe[0] -= vtMin * dDn * 0.5;
|
|
arPts.append(ptGe[0]);
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[2] = ptGe[1] - vtMin * (dL + dLx - 0.5 * dDn);
|
|
|
|
//电缆沟不需要倒角
|
|
arPts.append(ptGe[1]);
|
|
//InsertL2Point(ptGe[0], ptGe[1], ptGe[2], dLx, arPts);
|
|
arPts.append(ptGe[2]);
|
|
|
|
ptGe[3] = ptGe[2] + vtMaj * dDn2;
|
|
arPts.append(ptGe[3]);
|
|
|
|
ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
ptGe[5] = ptGe[4] + vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
|
|
//电缆沟不需要倒角
|
|
arPts.append(ptGe[4]);
|
|
//InsertL2Point(ptGe[3], ptGe[4], ptGe[5], dLx, arPts);
|
|
arPts.append(ptGe[5]);
|
|
|
|
ptGe[6] = ptGe[5] + vtMin * dDn;
|
|
arPts.append(ptGe[6]);
|
|
|
|
ptGe[7] = ptGe[6] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
ptGe[8] = ptGe[7] + vtMin * (dL + dLx - 0.5 * dDn);
|
|
//电缆沟不需要倒角
|
|
arPts.append(ptGe[7]);
|
|
//InsertL2Point(ptGe[6], ptGe[7], ptGe[8], dLx, arPts);
|
|
arPts.append(ptGe[8]);
|
|
|
|
ptGe[9] = ptGe[8] - vtMaj * dDn2;
|
|
arPts.append(ptGe[9]);
|
|
|
|
ptGe[10] = ptGe[9] - vtMin * (dL + dLx - 0.5 * dDn);
|
|
ptGe[11] = ptGe[10] - vtMaj * (dL + dLx - 0.5 * dDn2);
|
|
|
|
//电缆沟不需要倒角
|
|
arPts.append(ptGe[10]);
|
|
//InsertL2Point(ptGe[9], ptGe[10], ptGe[11], dLx, arPts);
|
|
arPts.append(ptGe[11]);
|
|
arPts.append(ptGe[0]);
|
|
|
|
AecDbX3dPart part;
|
|
AcGePoint3d ptFr, ptTo;
|
|
AcDbLine lnPath;
|
|
|
|
//顶板
|
|
AcDbRegion *pRegTop = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(), arPts.length());
|
|
if (pRegTop != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dH;//H
|
|
ptTo = ptFr + vtNorm * data.m_dk;//k
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegTop);
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegTop, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop);
|
|
}
|
|
|
|
//墙体1
|
|
AcDbRegion * pRegWall1 = MakeCornerWallRegion(ptGe,0,data.m_dt);
|
|
if (pRegWall1 != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall1);
|
|
AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
|
|
pX3dWall1->CreateExtrude(pRegWall1, lnPath);
|
|
part.AddX3dSolid(pX3dWall1);
|
|
}
|
|
|
|
//墙体2
|
|
pRegWall1 = MakeCornerWallRegion(ptGe, 3, data.m_dt);
|
|
if (pRegWall1 != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall1);
|
|
AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
|
|
pX3dWall1->CreateExtrude(pRegWall1, lnPath);
|
|
part.AddX3dSolid(pX3dWall1);
|
|
}
|
|
|
|
//墙体3
|
|
pRegWall1 = MakeCornerWallRegion(ptGe, 6, data.m_dt);
|
|
if (pRegWall1 != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall1);
|
|
AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
|
|
pX3dWall1->CreateExtrude(pRegWall1, lnPath);
|
|
part.AddX3dSolid(pX3dWall1);
|
|
}
|
|
|
|
//墙体4
|
|
pRegWall1 = MakeCornerWallRegion(ptGe, 9, data.m_dt);
|
|
if (pRegWall1 != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall1);
|
|
AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
|
|
pX3dWall1->CreateExtrude(pRegWall1, lnPath);
|
|
part.AddX3dSolid(pX3dWall1);
|
|
}
|
|
|
|
DlgData data2;
|
|
memset(&data2, 0, sizeof(DlgData));
|
|
GetDlgData(data2, 1);
|
|
|
|
//底板
|
|
double dOff1 = 0.5 * (data.m_dd - dDn);
|
|
double dOff2 = 0.5 * (data2.m_dd - dDn2);
|
|
|
|
OffsetPoint(ptGe, 0, dOff1,dOff2);
|
|
OffsetPoint(ptGe, 3, dOff2,dOff1);
|
|
OffsetPoint(ptGe, 6, dOff1,dOff2);
|
|
OffsetPoint(ptGe, 9, dOff2,dOff1);
|
|
ptGe[12] = ptGe[0];
|
|
|
|
AcDbRegion *pRegBom = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 13);
|
|
if (pRegBom != NULL)
|
|
{
|
|
ptFr = ptMid + vtNorm * 0.5 * dH;//H
|
|
ptTo = ptFr - vtNorm * data.m_db;//H
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegBom);
|
|
AcDbX3dSolid *pX3dSlabB = new AcDbX3dSolid;
|
|
pX3dSlabB->CreateExtrude(pRegBom, lnPath);
|
|
part.AddX3dSolid(pX3dSlabB);
|
|
}
|
|
|
|
part.Create();
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
DLLIMPEXP AcDbCurve *GetMinOffsetCurve(AcDbCurve *pPl, double dOff);
|
|
Acad::ErrorStatus AecDbEcFitting::DrawReduce3d(AcGiDraw &dc) const
|
|
{
|
|
AcCmTransparency tr = transparency();
|
|
AcGeVector3d vtMaj,vtMin,vtNorm(0,0,1);
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0,dRatio = 1.0,dL = 0.0,dH = 0.0, dL3 = 0;
|
|
double dThick = 0.35,dW = 0.0,dW1 = 0.0,dt = 0.0;
|
|
|
|
int nEcCen = 0;//偏心
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
m_mapSpecXData.GetAt(KEY_L,dL);
|
|
m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
|
|
m_mapSpecXData.GetAt(KEY_ECCEN,nEcCen);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(KEY_L,dL);
|
|
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//W H
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn += 2.0 * dParam.dSize[2];
|
|
|
|
dH = dParam.dSize[1];//末端
|
|
dt = dParam.dSize[2];//thick
|
|
dW1 = dParam.dSize[3];//开始端
|
|
dL3 = dL / 3.0;
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
vtNorm.normalize();
|
|
|
|
AcGeVector3d vtW = vtMaj;
|
|
vtW.rotateBy(PI / 2.0,vtNorm);
|
|
vtW.normalize();
|
|
|
|
int nStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);
|
|
|
|
double dSingleW = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);
|
|
|
|
AcGeLine3d ln(AcGePoint3d::kOrigin,vtNorm);
|
|
AcGePoint3d ptGe[10],ptS,ptE,ptGeI[10];
|
|
int nPoints = 0,nS = 0,nE = 0;
|
|
CUIntArray arOff1, arOff2;
|
|
|
|
if (ln.isPerpendicularTo(AcGePlane::kXYPlane))//水平放置
|
|
{
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * 0.5 * dL;
|
|
ptGe[0] += vtW * 0.5 * dW1;
|
|
|
|
if (nEcCen == 0)
|
|
{
|
|
ptGe[3] = ptMid;
|
|
ptGe[3] += vtMaj * 0.5 * dL;
|
|
ptGe[3] += vtW * 0.5 * dDn;
|
|
|
|
ptGe[1] = ptGe[0] + vtMaj * dL3;
|
|
ptGe[2] = ptGe[3] - vtMaj * dL3;
|
|
|
|
ptGe[4] = ptGe[3] - vtW * dDn;
|
|
ptGe[5] = ptGe[2] - vtW * dDn;
|
|
|
|
ptGe[6] = ptGe[1] - vtW * dW1;
|
|
ptGe[7] = ptGe[0] - vtW * dW1;
|
|
ptGe[8] = ptGe[0];
|
|
|
|
nPoints = 9;
|
|
nS = 4;
|
|
nE = 4;
|
|
|
|
ptS = MidPoint(ptGe[0], ptGe[7]);
|
|
ptE = MidPoint(ptGe[3], ptGe[4]);
|
|
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 10);
|
|
|
|
OffsetPoint(ptGeI[0], ptGeI[7], dThick);
|
|
OffsetPoint(ptGeI[1], ptGeI[6], dThick);
|
|
OffsetPoint(ptGeI[2], ptGeI[5], dThick);
|
|
OffsetPoint(ptGeI[3], ptGeI[4], dThick);
|
|
ptGeI[8] = ptGeI[0];
|
|
}
|
|
else if (nEcCen == 1)
|
|
{
|
|
ptGe[1] = ptGe[0] + vtMaj * dL;
|
|
|
|
ptGe[2] = ptGe[1] - vtW * dDn;
|
|
ptGe[3] = ptGe[2] - vtMaj * dL3;
|
|
|
|
ptGe[5] = ptGe[0] - vtW * dW1;
|
|
ptGe[4] = ptGe[5] + vtMaj * dL3;
|
|
|
|
ptGe[6] = ptGe[0];
|
|
|
|
nPoints = 7;
|
|
nS = 2;
|
|
nE = 4;
|
|
|
|
ptS = MidPoint(ptGe[0], ptGe[5]);
|
|
ptE = MidPoint(ptGe[1], ptGe[2]);
|
|
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 10);
|
|
OffsetPoint(ptGeI[0], ptGeI[5], dThick);
|
|
OffsetPoint(ptGeI[1], ptGeI[2], dThick);
|
|
ptGeI[3] = ptGeI[2] - vtMaj * dL3;
|
|
ptGeI[4] = ptGeI[5] + vtMaj * dL3;
|
|
ptGeI[6] = ptGeI[0];
|
|
}
|
|
else if (nEcCen == 2)
|
|
{
|
|
ptGe[3] = ptMid;
|
|
ptGe[3] -= vtMaj * 0.5 * dL;
|
|
ptGe[3] -= vtW * 0.5 * dW1;
|
|
ptGe[3] += vtMaj * dL;
|
|
ptGe[3] += vtW * dDn;
|
|
|
|
ptGe[2] = ptGe[3] - vtMaj * dL3;
|
|
ptGe[1] = ptGe[0] + vtMaj * dL3;
|
|
|
|
ptGe[4] = ptGe[3] - vtW * dDn;
|
|
ptGe[5] = ptGe[0] - vtW * dW1;
|
|
|
|
ptGe[6] = ptGe[0];
|
|
|
|
nPoints = 7;
|
|
nS = 4;
|
|
nE = 2;
|
|
|
|
ptS = MidPoint(ptGe[0], ptGe[5]);
|
|
ptE = MidPoint(ptGe[3], ptGe[4]);
|
|
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 10);
|
|
OffsetPoint(ptGeI[0], ptGeI[5], dThick);
|
|
OffsetPoint(ptGeI[3], ptGeI[4], dThick);
|
|
ptGeI[2] = ptGeI[3] - vtMaj * dL3;
|
|
ptGeI[1] = ptGeI[0] + vtMaj * dL3;
|
|
ptGeI[6] = ptGeI[0];
|
|
}
|
|
|
|
AcGePoint3d ptFr,ptTo,ptTmp;
|
|
AcDbLine lnPath;
|
|
AcDbRegion* pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe,nPoints);
|
|
if (pRegOut != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dH;//W
|
|
ptTo = ptMid + vtNorm * 0.5 * dH;//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
AcGeMatrix3d xform;
|
|
AcGeVector3d vt = vtNorm * 0.5 * dH;
|
|
xform.setToTranslation(vt);
|
|
pRegOut->transformBy(xform);
|
|
|
|
AecDbX3dPart part;
|
|
AcDbX3dSolid* pX3dSolidOut = new AcDbX3dSolid;
|
|
pX3dSolidOut->CreateExtrude(pRegOut,lnPath);
|
|
part.AddX3dSolid(pX3dSolidOut);
|
|
|
|
AcDbRegion* pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, nPoints);
|
|
if (pRegIn != NULL)
|
|
{
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
|
|
!dParam.m_bCover)
|
|
{
|
|
//水平放置,不带盖子时
|
|
AcGeVector3d vtRegNorm;
|
|
pRegIn->getNormal(vtRegNorm);
|
|
|
|
ptFr = ptMid - vtRegNorm * 0.5 * dW;
|
|
ptTo = ptMid + vtRegNorm * 0.5 * (dW - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtRegNorm * 0.5 * dW;
|
|
}
|
|
else
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * (dH - 2.0 * dThick);//W
|
|
ptTo = ptMid + vtNorm * 0.5 * (dH - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtNorm * 0.5 * (dH - 2.0 * dThick);
|
|
}
|
|
|
|
xform.setToTranslation(vt);
|
|
pRegIn->transformBy(xform);
|
|
|
|
AcDbX3dSolid* pX3dSolidIn = new AcDbX3dSolid;
|
|
pX3dSolidIn->CreateExtrude(pRegIn,lnPath);
|
|
part.AddX3dSolid(pX3dSolidIn,AcDb::kBoolSubtract);
|
|
|
|
BoolSubtractUserInf3d(part);
|
|
part.Create();
|
|
|
|
AcDb3dSolid* pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
delete pRegIn;
|
|
}
|
|
delete pRegOut;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( ln.isParallelTo(AcGePlane::kXYPlane))//垂直放置 绘制 []形状
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrReduce3d(AcGiDraw &dc) const
|
|
{
|
|
AcCmTransparency tr = transparency();
|
|
AcGeVector3d vtMaj, vtMin, vtNorm(0, 0, 1);
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dL = 0.0, dH = 0.0;
|
|
double dThick = 0.35, dW = 0.0, dW1 = 0.0, dt = 0.0;
|
|
|
|
int nEcCen = 0;//偏心
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
m_mapSpecXData.GetAt(KEY_L, dL);
|
|
m_mapSpecXData.GetAt(KEY_NORMAL, vtNorm);
|
|
m_mapSpecXData.GetAt(KEY_ECCEN, nEcCen);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(KEY_L, dL);
|
|
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
DlgData data;
|
|
memset(&data, 0, sizeof(DlgData));
|
|
GetDlgData(data, 0);
|
|
|
|
DlgData data2;
|
|
memset(&data2, 0, sizeof(DlgData));
|
|
GetDlgData(data2, 1);
|
|
|
|
dDn = dParam.dSize[0];//W H
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn += 2.0 * dParam.dSize[2];
|
|
|
|
dH = dParam.dSize[1];//末端
|
|
dW = dH;
|
|
dt = dParam.dSize[2];//thick
|
|
dW1 = dParam.dSize[3];//开始端
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dW1 += 2.0 * dParam.dSize[2];
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
vtNorm.normalize();
|
|
|
|
AcGeVector3d vtW = vtMaj;
|
|
vtW.rotateBy(PI / 2.0, vtNorm);
|
|
vtW.normalize();
|
|
vtNorm.negate();
|
|
|
|
AcGePoint3d ptGe[6], ptGeI[6],ptFr,ptTo;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * 0.5 * dL;
|
|
ptGe[0] += vtW * 0.5 * dW1;
|
|
|
|
ptGe[1] = ptMid;
|
|
ptGe[1] += vtMaj * 0.5 * dL;
|
|
ptGe[1] += vtW * 0.5 * dDn;
|
|
|
|
ptGe[2] = ptGe[1] - vtW * dDn;
|
|
ptGe[3] = ptGe[0] - vtW * dW1;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
//顶板
|
|
AcDbLine lnPath;
|
|
AecDbX3dPart part;
|
|
|
|
//顶板
|
|
AcDbRegion *pRegTop = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegTop != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dH;//H
|
|
ptTo = ptFr + vtNorm * data.m_dk;//k
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegTop);
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegTop, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop);
|
|
}
|
|
|
|
//墙体1
|
|
ptGeI[0] = ptGe[0];
|
|
ptGeI[1] = ptGe[1];
|
|
|
|
ptGeI[2] = ptGeI[1];
|
|
ptGeI[2] -= vtW * data.m_dt;
|
|
|
|
ptGeI[3] = ptGeI[0];
|
|
ptGeI[3] -= vtW * data.m_dt;
|
|
ptGeI[4] = ptGeI[0];
|
|
|
|
AcDbRegion *pRegWall1 = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 5);
|
|
if (pRegWall1 != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall1);
|
|
AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
|
|
pX3dWall1->CreateExtrude(pRegWall1, lnPath);
|
|
part.AddX3dSolid(pX3dWall1);
|
|
}
|
|
|
|
//墙体2
|
|
ptGeI[0] = ptGe[2];
|
|
ptGeI[1] = ptGe[3];
|
|
|
|
ptGeI[2] = ptGeI[1];
|
|
ptGeI[2] += vtW * data.m_dt;
|
|
|
|
ptGeI[3] = ptGeI[0];
|
|
ptGeI[3] += vtW * data.m_dt;
|
|
ptGeI[4] = ptGeI[0];
|
|
|
|
AcDbRegion *pRegWall2 = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 5);
|
|
if (pRegWall2 != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall2);
|
|
AcDbX3dSolid *pX3dWall2 = new AcDbX3dSolid;
|
|
pX3dWall2->CreateExtrude(pRegWall2, lnPath);
|
|
part.AddX3dSolid(pX3dWall2);
|
|
}
|
|
|
|
//底板
|
|
ptGe[0] += 0.5 * (data.m_dd - dW1) * vtW;
|
|
ptGe[1] += 0.5 * (data2.m_dd - dDn) * vtW;
|
|
ptGe[2] -= 0.5 * (data.m_dd - dDn) * vtW;
|
|
ptGe[3] -= 0.5 * (data2.m_dd - dW1) * vtW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbRegion *pRegBom = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegBom != NULL)
|
|
{
|
|
ptFr = ptMid + vtNorm * 0.5 * dH;//H
|
|
ptTo = ptFr - vtNorm * data.m_db;//H
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegBom);
|
|
AcDbX3dSolid *pX3dSlabB = new AcDbX3dSolid;
|
|
pX3dSlabB->CreateExtrude(pRegBom, lnPath);
|
|
part.AddX3dSolid(pX3dSlabB);
|
|
}
|
|
|
|
part.Create();
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawOffset3d(AcGiDraw &dc) const
|
|
{
|
|
//两个弯头,且水平放置,或垂直放置
|
|
//90 < A < 180.0 乙字弯角度
|
|
|
|
AcCmTransparency tr = transparency();
|
|
assertReadEnabled();
|
|
|
|
AcGeVector3d vtMaj,vtMin,vtNorm,vtOffset;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0,dRatio = 1.0,dSweepAngle = PI / 2.0;
|
|
double dThick = 0.35,dLx = 50.0,dL = 0.0,dW = 0.0;
|
|
double dOffsetH = 0.0;//偏西距离
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);//进口方向
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);//出口方向
|
|
m_mapSpecXData.GetAt(KEY_OFFSETDIR,vtOffset);//偏移方向
|
|
//vtMaj == vtMin
|
|
|
|
m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);//中间点
|
|
m_mapSpecXData.GetAt(KEY_Offset,dOffsetH);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
if (dThick < 1.e-6)
|
|
dThick = 5.0;//至少5mm
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn += 2.0 * dParam.dSize[2];
|
|
|
|
double dH = dParam.dSize[1];//H
|
|
double dR = dDn * dRatio;
|
|
dW = dParam.dSize[1];//
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
vtNorm.normalize();
|
|
vtOffset.normalize();
|
|
|
|
//偏移方向的反方向
|
|
AcGeVector3d vtV = vtOffset;//Maj->Min的方向
|
|
vtV = vtV.orthoProject(vtMaj);//MAKE SURE
|
|
vtV.negate();
|
|
vtV.normalize();
|
|
|
|
if (dOffsetH < 1.e-6)
|
|
{
|
|
acutPrintf(_T("\nOffset dist error!"));
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//乙字弯角度 90 < A < 180
|
|
if ( ( dSweepAngle - 90.0 ) > 1.e-10 && (dSweepAngle - 180.0) < 1.e-10)
|
|
{
|
|
//转化为弧度
|
|
dSweepAngle *= PI / 180.0;
|
|
|
|
//玄段长度
|
|
double dChrodx = dR * tan(dSweepAngle * 0.5);
|
|
|
|
//斜段总桥架长度
|
|
double dLseg = dOffsetH / sin(dSweepAngle);//180-a
|
|
|
|
//投影到maj方向上 总长
|
|
double dL = dOffsetH / fabs(tan(dSweepAngle));//180-a
|
|
dL += dChrodx * 2.0;
|
|
|
|
//伞心中最大对角线长
|
|
double dAL = sqrt(dR * dR + dChrodx * dChrodx);
|
|
|
|
AcGePoint3d ptGeCen[4];
|
|
|
|
ptGeCen[0] = ptMid - vtMaj * 0.5 * dL;
|
|
ptGeCen[0] += vtV * 0.5 * dOffsetH;
|
|
|
|
ptGeCen[1] = ptGeCen[0] + vtMaj * dChrodx;
|
|
|
|
AcGeVector3d vtMidL = ptMid - ptGeCen[1];
|
|
vtMidL.normalize();
|
|
ptGeCen[2] = ptGeCen[1] + vtMidL * dLseg;
|
|
ptGeCen[3] = ptGeCen[2] + vtMin * dChrodx;
|
|
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(AcGePoint3d::kOrigin,vtNorm);
|
|
|
|
//确定拉伸方向的尺寸
|
|
double dh = dDn;
|
|
if (ln3d.isParallelTo(AcGePlane::kXYPlane))//和XY面平行,立着放置
|
|
{
|
|
dh = dDn;
|
|
dDn = dParam.dSize[1];
|
|
}
|
|
else if (ln3d.isPerpendicularTo(AcGePlane::kXYPlane))//和XY面垂直,水平放置
|
|
{
|
|
dh = dH;
|
|
}
|
|
else
|
|
{
|
|
//..
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//计算
|
|
AcGeVector3d vt1,vt2,vt3,vt4;
|
|
AcGePoint3d ptGe[10];
|
|
|
|
ptGe[0] = ptGeCen[0];
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
|
|
vt1 = ptGeCen[0] - ptGeCen[1];
|
|
vt2 = ptGeCen[2] - ptGeCen[1];
|
|
vt1.normalize();
|
|
vt2.normalize();
|
|
|
|
vt3 = vt1 + vt2;
|
|
vt3.normalize();
|
|
|
|
double dLA = 0.5 * dDn / sin(dSweepAngle * 0.5);
|
|
vt3 *= dLA;
|
|
vt3.negate();
|
|
|
|
ptGe[1] = ptGeCen[1] + vt3;
|
|
ptGe[2] = ptGe[1] + vtMidL * dLseg;
|
|
|
|
ptGe[3] = ptGeCen[2] + vtMin * dChrodx;
|
|
ptGe[3] += vtV * 0.5 * dDn;
|
|
|
|
ptGe[4] = ptGe[3] - dDn * vtV;
|
|
|
|
vt1 = ptGeCen[1] - ptGeCen[2];
|
|
vt2 = ptGeCen[3] - ptGeCen[2];
|
|
vt1.normalize();
|
|
vt2.normalize();
|
|
|
|
vt4 = vt1 + vt2;
|
|
vt4.normalize();
|
|
vt4 *= dLA;
|
|
vt4.negate();
|
|
|
|
ptGe[5] = ptGeCen[2] + vt4;
|
|
|
|
ptGe[6] = ptGe[5] - vtMidL * dLseg;
|
|
|
|
ptGe[7] = ptGe[0] - vtV * dDn;
|
|
ptGe[8] = ptGe[0];
|
|
|
|
AcGePoint3d ptGeB[9];
|
|
memcpy(ptGeB,ptGe,sizeof(AcGePoint3d) * 9);
|
|
|
|
//A移到顶
|
|
for(int i = 0;i < 9;i++ )
|
|
{
|
|
ptGeB[i] += vtNorm * 0.5 * dh;
|
|
}
|
|
|
|
AcDbLine lnPath;
|
|
AcGePoint3d ptS,ptE;
|
|
ptS = ptMid;
|
|
ptS += vtNorm * 0.5 * dh;
|
|
ptE = ptMid;
|
|
ptE -= vtNorm * 0.5 * dh;
|
|
lnPath.setStartPoint(ptS);
|
|
lnPath.setEndPoint(ptE);
|
|
|
|
AcDbRegion* pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeB,9);
|
|
if (pRegOut != NULL)
|
|
{
|
|
AecDbX3dPart part;
|
|
AcDbX3dSolid* pX3dSolidOut = new AcDbX3dSolid;
|
|
pX3dSolidOut->CreateExtrude(pRegOut,lnPath);
|
|
part.AddX3dSolid(pX3dSolidOut);
|
|
|
|
//根据A,下调一个厚度
|
|
if (dParam.m_bCover)
|
|
{
|
|
for(int i = 0;i < 9;i++)
|
|
{
|
|
ptGeB[i] -= vtNorm * dThick;
|
|
}
|
|
}
|
|
|
|
OffsetPoint(ptGeB[0],ptGeB[7],dThick);
|
|
ptGeB[8] = ptGeB[0];
|
|
|
|
OffsetPoint(ptGeB[3],ptGeB[4],dThick);
|
|
|
|
OffsetPoint(ptGeB[1],ptGeB[6],dThick / sin(dSweepAngle * 0.5) );
|
|
OffsetPoint(ptGeB[2],ptGeB[5],dThick / sin(dSweepAngle * 0.5) );
|
|
|
|
AcDbRegion* pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeB,9);
|
|
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
|
|
!dParam.m_bCover && pRegIn != NULL)
|
|
{
|
|
//水平放置,不带盖子时
|
|
AcGeVector3d vtRegNorm;
|
|
pRegIn->getNormal(vtRegNorm);
|
|
|
|
//水平不带盖子
|
|
ptS = ptMid;
|
|
ptS += vtRegNorm * 0.5 * dh;
|
|
ptE = ptMid;
|
|
ptE -= vtRegNorm * (0.5 * dh - dThick);
|
|
lnPath.setStartPoint(ptS);
|
|
lnPath.setEndPoint(ptE);
|
|
}
|
|
else
|
|
{
|
|
ptS = ptMid;
|
|
ptS += vtNorm * (0.5 * dh - dThick);
|
|
ptE = ptMid;
|
|
ptE -= vtNorm * (0.5 * dh - dThick);
|
|
lnPath.setStartPoint(ptS);
|
|
lnPath.setEndPoint(ptE);
|
|
}
|
|
|
|
if (pRegIn != NULL)
|
|
{
|
|
AcDbX3dSolid* pX3dSolidIn = new AcDbX3dSolid;
|
|
pX3dSolidIn->CreateExtrude(pRegIn,lnPath);
|
|
part.AddX3dSolid(pX3dSolidIn,AcDb::kBoolSubtract);
|
|
|
|
BoolSubtractUserInf3d(part);
|
|
part.Create();
|
|
|
|
AcDb3dSolid* pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
delete pRegIn;
|
|
}
|
|
delete pRegOut;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrOffset3d(AcGiDraw &dc) const
|
|
{
|
|
//两个弯头,且水平放置,或垂直放置
|
|
//90 < A < 180.0 乙字弯角度
|
|
|
|
AcCmTransparency tr = transparency();
|
|
assertReadEnabled();
|
|
|
|
AcGeVector3d vtMaj, vtMin, vtNorm, vtOffset;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dSweepAngle = PI / 2.0;
|
|
double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0;
|
|
double dOffsetH = 0.0;//偏西距离
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);//进口方向
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);//出口方向
|
|
m_mapSpecXData.GetAt(KEY_OFFSETDIR, vtOffset);//偏移方向
|
|
//vtMaj == vtMin
|
|
|
|
m_mapSpecXData.GetAt(KEY_NORMAL, vtNorm);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);//中间点
|
|
m_mapSpecXData.GetAt(KEY_Offset, dOffsetH);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG, dSweepAngle);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
if (dThick < 1.e-6)
|
|
dThick = 5.0;//至少5mm
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
DlgData data;
|
|
memset(&data, 0, sizeof(DlgData));
|
|
GetDlgData(data, 0);
|
|
|
|
dDn = dParam.dSize[0];//D L
|
|
double dR = dDn * dRatio;
|
|
if (dParam.m_app == WPipe::eTrench)
|
|
dDn += 2.0 * dParam.dSize[2];
|
|
|
|
double dH = dParam.dSize[1];//H
|
|
dW = dParam.dSize[1];//
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
vtNorm.normalize();
|
|
vtOffset.normalize();
|
|
|
|
//偏移方向的反方向
|
|
AcGeVector3d vtV = vtOffset;//Maj->Min的方向
|
|
vtV = vtV.orthoProject(vtMaj);//MAKE SURE
|
|
vtV.negate();
|
|
vtV.normalize();
|
|
|
|
if (dOffsetH < 1.e-6)
|
|
{
|
|
acutPrintf(_T("\nOffset dist error!"));
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//乙字弯角度 90 < A < 180
|
|
if ((dSweepAngle - 90.0) > 1.e-10 && (dSweepAngle - 180.0) < 1.e-10)
|
|
{
|
|
//转化为弧度
|
|
dSweepAngle *= PI / 180.0;
|
|
|
|
//玄段长度
|
|
double dChrodx = dR * tan(dSweepAngle * 0.5);
|
|
|
|
//斜段总桥架长度
|
|
double dLseg = dOffsetH / sin(dSweepAngle);//180-a
|
|
|
|
//投影到maj方向上 总长
|
|
double dL = dOffsetH / fabs(tan(dSweepAngle));//180-a
|
|
dL += dChrodx * 2.0;
|
|
|
|
//伞心中最大对角线长
|
|
double dAL = sqrt(dR * dR + dChrodx * dChrodx);
|
|
|
|
AcGePoint3d ptGeCen[4];
|
|
|
|
ptGeCen[0] = ptMid - vtMaj * 0.5 * dL;
|
|
ptGeCen[0] += vtV * 0.5 * dOffsetH;
|
|
|
|
ptGeCen[1] = ptGeCen[0] + vtMaj * dChrodx;
|
|
|
|
AcGeVector3d vtMidL = ptMid - ptGeCen[1];
|
|
vtMidL.normalize();
|
|
ptGeCen[2] = ptGeCen[1] + vtMidL * dLseg;
|
|
ptGeCen[3] = ptGeCen[2] + vtMin * dChrodx;
|
|
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(AcGePoint3d::kOrigin, vtNorm);
|
|
|
|
//确定拉伸方向的尺寸
|
|
double dh = dDn;
|
|
if (ln3d.isPerpendicularTo(AcGePlane::kXYPlane))//和XY面垂直,缆沟水平放置
|
|
{
|
|
dh = dH;
|
|
}
|
|
else
|
|
{
|
|
//..
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//计算
|
|
AcGeVector3d vt1, vt2, vt3, vt4;
|
|
AcGePoint3d ptGe[10];
|
|
|
|
ptGe[0] = ptGeCen[0];
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
|
|
vt1 = ptGeCen[0] - ptGeCen[1];
|
|
vt2 = ptGeCen[2] - ptGeCen[1];
|
|
vt1.normalize();
|
|
vt2.normalize();
|
|
|
|
vt3 = vt1 + vt2;
|
|
vt3.normalize();
|
|
|
|
double dLA = 0.5 * dDn / sin(dSweepAngle * 0.5);
|
|
vt3 *= dLA;
|
|
vt3.negate();
|
|
|
|
ptGe[1] = ptGeCen[1] + vt3;
|
|
ptGe[2] = ptGe[1] + vtMidL * dLseg;
|
|
|
|
ptGe[3] = ptGeCen[2] + vtMin * dChrodx;
|
|
ptGe[3] += vtV * 0.5 * dDn;
|
|
|
|
ptGe[4] = ptGe[3] - dDn * vtV;
|
|
|
|
vt1 = ptGeCen[1] - ptGeCen[2];
|
|
vt2 = ptGeCen[3] - ptGeCen[2];
|
|
vt1.normalize();
|
|
vt2.normalize();
|
|
|
|
vt4 = vt1 + vt2;
|
|
vt4.normalize();
|
|
vt4 *= dLA;
|
|
vt4.negate();
|
|
|
|
ptGe[5] = ptGeCen[2] + vt4;
|
|
|
|
ptGe[6] = ptGe[5] - vtMidL * dLseg;
|
|
|
|
ptGe[7] = ptGe[0] - vtV * dDn;
|
|
ptGe[8] = ptGe[0];
|
|
|
|
//向下
|
|
vtNorm.negate();
|
|
|
|
//顶板
|
|
AecDbX3dPart part;
|
|
AcGePoint3d ptFr, ptTo;
|
|
AcDbLine lnPath;
|
|
|
|
//顶板
|
|
AcDbRegion *pRegTop = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 9);
|
|
if (pRegTop != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dH;//H
|
|
ptTo = ptFr + vtNorm * data.m_dk;//k
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegTop);
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegTop, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop);
|
|
}
|
|
|
|
AcGePoint3d ptGeB[9],ptGeW[9];
|
|
memcpy(ptGeB, ptGe, sizeof(AcGePoint3d) * 9);
|
|
|
|
//侧墙1
|
|
OffsetPoint(ptGeB[0], ptGeB[7], dThick);
|
|
ptGeB[8] = ptGeB[0];
|
|
|
|
OffsetPoint(ptGeB[3], ptGeB[4], dThick);
|
|
|
|
OffsetPoint(ptGeB[1], ptGeB[6], dThick / sin(dSweepAngle * 0.5));
|
|
OffsetPoint(ptGeB[2], ptGeB[5], dThick / sin(dSweepAngle * 0.5));
|
|
|
|
memcpy(ptGeW, ptGe, sizeof(AcGePoint3d) * 9);
|
|
ptGeW[4] = ptGeB[3];
|
|
ptGeW[5] = ptGeB[2];
|
|
ptGeW[6] = ptGeB[1];
|
|
ptGeW[7] = ptGeB[0];
|
|
ptGeW[8] = ptGeW[0];
|
|
|
|
AcDbRegion *pRegWall = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeW, 9);
|
|
if (pRegWall != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall);
|
|
AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
|
|
pX3dWall1->CreateExtrude(pRegWall, lnPath);
|
|
part.AddX3dSolid(pX3dWall1);
|
|
}
|
|
|
|
//侧墙2
|
|
memcpy(ptGeW, ptGe, sizeof(AcGePoint3d) * 9);
|
|
ptGeW[0] = ptGeB[7];
|
|
ptGeW[1] = ptGeB[6];
|
|
ptGeW[2] = ptGeB[5];
|
|
ptGeW[3] = ptGeB[4];
|
|
|
|
ptGeW[4] = ptGe[4];
|
|
ptGeW[5] = ptGe[5];
|
|
ptGeW[6] = ptGe[6];
|
|
ptGeW[7] = ptGe[7];
|
|
ptGeW[8] = ptGeW[0];
|
|
|
|
AcDbRegion *pRegWall2 = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeW, 9);
|
|
if (pRegWall != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall2);
|
|
AcDbX3dSolid *pX3dWall2 = new AcDbX3dSolid;
|
|
pX3dWall2->CreateExtrude(pRegWall2, lnPath);
|
|
part.AddX3dSolid(pX3dWall2);
|
|
}
|
|
|
|
//底板
|
|
memcpy(ptGeB, ptGe, sizeof(AcGePoint3d) * 9);
|
|
dThick = -0.5 * (data.m_dd - dDn);
|
|
|
|
OffsetPoint(ptGeB[7], ptGeB[0], dThick);
|
|
ptGeB[8] = ptGeB[0];
|
|
|
|
OffsetPoint(ptGeB[4], ptGeB[3], dThick);
|
|
|
|
OffsetPoint(ptGeB[6], ptGeB[1], dThick / sin(dSweepAngle * 0.5));
|
|
OffsetPoint(ptGeB[5], ptGeB[2], dThick / sin(dSweepAngle * 0.5));
|
|
|
|
AcDbRegion *pRegBom = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeB, 9);
|
|
if (pRegBom != NULL)
|
|
{
|
|
ptFr = ptMid + vtNorm * 0.5 * dH;//H
|
|
ptTo = ptFr - vtNorm * data.m_db;//H
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegBom);
|
|
AcDbX3dSolid *pX3dSlabB = new AcDbX3dSolid;
|
|
pX3dSlabB->CreateExtrude(pRegBom, lnPath);
|
|
part.AddX3dSolid(pX3dSlabB);
|
|
}
|
|
|
|
part.Create();
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbEcFitting::DrawInfCircle(AcGiDraw &dc,AcDbArc* pArcElbow,double dR,int nStyle) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (pArcElbow != NULL)
|
|
{
|
|
double dSta = 0.0,dEnd = 0.0;
|
|
pArcElbow->getStartParam(dSta);
|
|
pArcElbow->getEndParam(dEnd);
|
|
|
|
AcGePoint3d ptSta,ptEnd;
|
|
pArcElbow->getStartPoint(ptSta);
|
|
pArcElbow->getEndPoint(ptEnd);
|
|
|
|
//一阶求导
|
|
AcGeVector3d vt1,vt2;
|
|
pArcElbow->getFirstDeriv(dSta,vt1);//方向指向有弧侧
|
|
pArcElbow->getFirstDeriv(dEnd,vt2);//方向指向无弧侧
|
|
vt1.negate();//方向指向无弧侧
|
|
|
|
//端面向上 画圆
|
|
if (vt1.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
AcDbCircle* pCir = new AcDbCircle;
|
|
pCir->setCenter(ptSta);
|
|
pCir->setRadius(dR);
|
|
pCir->setLayer(pArcElbow->layerId());
|
|
pCir->setNormal(AcGeVector3d::kZAxis);
|
|
dc.DrawEntity(pCir);
|
|
Add2DBuffer(pCir);
|
|
return;
|
|
}
|
|
|
|
if (vt2.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
AcDbCircle* pCir = new AcDbCircle;
|
|
pCir->setCenter(ptEnd);
|
|
pCir->setRadius(dR);
|
|
pCir->setLayer(pArcElbow->layerId());
|
|
pCir->setNormal(AcGeVector3d::kZAxis);
|
|
dc.DrawEntity(pCir);
|
|
Add2DBuffer(pCir);
|
|
return;
|
|
}
|
|
|
|
double dOpenAng = PI / 12.0;
|
|
if (nStyle == 2)//单线
|
|
{
|
|
dOpenAng = PI / 2.0;
|
|
}
|
|
|
|
//端面向下 画弧
|
|
AcGePoint3d ptGe[3];
|
|
if (vt1.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vt2 = ptEnd - ptSta;
|
|
vt2.z = 0.0;
|
|
vt2.normalize();
|
|
vt2.rotateBy(dOpenAng,AcGeVector3d::kZAxis);
|
|
|
|
ptGe[0] = ptSta + dR * vt2;
|
|
vt2.rotateBy(-2.0 * dOpenAng,AcGeVector3d::kZAxis);
|
|
ptGe[2] = ptSta + dR * vt2;
|
|
|
|
vt2 = ptSta - ptEnd;
|
|
vt2.z = 0.0;
|
|
vt2.normalize();
|
|
ptGe[1] = ptSta + dR * vt2;
|
|
|
|
AcDbArc* pArc = KTCADUtilityEx::FormatArc(ptGe[0],ptGe[1],ptGe[2]);
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->setLayer(pArcElbow->layerId());
|
|
pArc->setNormal(AcGeVector3d::kZAxis);
|
|
pArc->setCenter(ptSta);
|
|
dc.DrawEntity(pArc);
|
|
Add2DBuffer(pArc);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (vt2.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vt1 = ptSta - ptEnd;
|
|
vt1.z = 0.0;
|
|
vt1.normalize();
|
|
vt1.rotateBy(dOpenAng,AcGeVector3d::kZAxis);
|
|
|
|
ptGe[0] = ptEnd + dR * vt1;
|
|
vt1.rotateBy(-2.0 * dOpenAng,AcGeVector3d::kZAxis);
|
|
ptGe[2] = ptEnd + dR * vt1;
|
|
|
|
vt1 = ptEnd - ptSta;
|
|
vt1.z = 0.0;
|
|
vt1.normalize();
|
|
ptGe[1] = ptEnd + dR * vt1;
|
|
|
|
AcDbArc* pArc = KTCADUtilityEx::FormatArc(ptGe[0],ptGe[1],ptGe[2]);
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->setLayer(pArcElbow->layerId());
|
|
pArc->setNormal(AcGeVector3d::kZAxis);
|
|
pArc->setCenter(ptEnd);
|
|
dc.DrawEntity(pArc);
|
|
Add2DBuffer(pArc);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawIncline2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGeVector3d vtMaj,vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0,dRatio = 1.0,dSweepAngle = PI / 2.0;
|
|
double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0, dDn2 = 0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);
|
|
|
|
int nElbowStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_ELBOWSTYLE, nElbowStyle);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[3];
|
|
dDn2 = dParam.dSize[0];
|
|
if (dDn < 1.e-6) dDn = dDn2;
|
|
|
|
dL = GetElbowL(&dParam);
|
|
dW = dParam.dSize[1];
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
|
|
AcGePoint3d ptGe[8],ptGeU[6];
|
|
AcGeVector3d vtNormal = vtMin.crossProduct(vtMaj);
|
|
if (vtNormal.isParallelTo(AcGeVector3d::kZAxis))//水平放置
|
|
{
|
|
AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
|
|
AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
|
|
vtMV.normalize();
|
|
vtNV.normalize();
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[0] -= vtMV * 0.5 * dDn;
|
|
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
ptGe[2] -= vtNV * 0.5 * dDn2;
|
|
|
|
AcGeLine3d ln1(ptGe[0],vtMaj);
|
|
AcGeLine3d ln2(ptGe[2],vtMin);
|
|
ln1.intersectWith(ln2,ptGe[1]);
|
|
|
|
ptGe[3] = ptGe[2] + vtNV * dDn2;
|
|
ptGe[4] = ptGe[3] - vtMin * dLx;
|
|
|
|
ptGe[6] = ptGe[0] + vtMV * dDn;
|
|
ptGe[5] = ptGe[6] - vtMaj * dLx;
|
|
|
|
ptGe[7] = ptGe[0];
|
|
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
AcDbPolyline *pPl = NULL;
|
|
if (!bHide)
|
|
{
|
|
pPl = FormatPolyline(ptGe,8);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AcGePoint3d *ptGe2 = ptGe;
|
|
pPl = FormatPolyline(ptGe2, 3);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
AcGePoint3d *ptGe3 = ptGe;
|
|
ptGe3 += 3;//->3
|
|
|
|
pPl = FormatPolyline(ptGe3, 4);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[1] = ptMid;
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe,3);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//有一个向量平行 Z
|
|
if (vtMaj.isParallelTo(AcGeVector3d::kZAxis) ||
|
|
vtMin.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
AcGeVector3d vtH, vtV;
|
|
|
|
//弯头类型
|
|
switch (nElbowStyle)
|
|
{
|
|
case 0://垂直上弯
|
|
case 1://垂直下弯
|
|
{
|
|
if (vtMin.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtMaj;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else if (vtMaj.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtMin;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
|
|
//简易画法
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += vtH * dL;
|
|
|
|
ptGe[1] = ptMid;
|
|
ptGe[1] -= vtH * 0.5 * dW;
|
|
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
ptGe[1] += vtV * 0.5 * dDn;
|
|
|
|
ptGe[2] = ptGe[1] - vtV * dDn;
|
|
ptGe[3] = ptGe[0] - vtV * dDn;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += vtH * 0.5 * dW;
|
|
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
ptGe[1] = ptGe[0] - vtV * dDn;
|
|
|
|
AcDbLine *pLn = new AcDbLine(ptGe[0], ptGe[1]);
|
|
pLn->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
|
|
break;
|
|
}
|
|
case 2://垂直左上弯
|
|
{
|
|
if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += vtH * dL;
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1] -= vtV * dDn;
|
|
|
|
ptGe[2] = ptGe[1] - vtH * (dL + 0.5 * dDn);
|
|
ptGe[3] = ptGe[0] - vtH * (dL + 0.5 * dDn);
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
ptGeU[0] = ptMid;
|
|
ptGeU[0] -= vtH * 0.5 * dDn;
|
|
ptGeU[0] += vtV * 0.5 * dW;
|
|
|
|
ptGeU[1] = ptGeU[0] + vtH * dDn;
|
|
ptGeU[2] = ptGeU[1] - vtV * dW;
|
|
ptGeU[3] = ptGeU[0] - vtV * dW;
|
|
ptGeU[4] = ptGeU[0];
|
|
|
|
pPl = FormatPolyline(ptGeU, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
if (!vtV.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
pPl->setLayer(this->GetDashLayer());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
break;
|
|
}
|
|
case 3://垂直右上弯
|
|
{
|
|
if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//简易画法
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += vtH * dL;
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1] -= vtV * dDn;
|
|
|
|
ptGe[2] = ptGe[1] - vtH * (dL + 0.5 * dDn);
|
|
ptGe[3] = ptGe[0] - vtH * (dL + 0.5 * dDn);
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
ptGeU[0] = ptMid;
|
|
ptGeU[0] -= vtH * 0.5 * dDn;
|
|
ptGeU[0] += vtV * 0.5 * dW;
|
|
|
|
ptGeU[1] = ptGeU[0] + vtH * dDn;
|
|
ptGeU[2] = ptGeU[1] - vtV * dW;
|
|
ptGeU[3] = ptGeU[0] - vtV * dW;
|
|
ptGeU[4] = ptGeU[0];
|
|
|
|
pPl = FormatPolyline(ptGeU, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
if (!vtV.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
pPl->setLayer(this->GetDashLayer());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
break;
|
|
}
|
|
case 4://垂直左下弯
|
|
{
|
|
if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//简易画法
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += vtH * dL;
|
|
ptGe[0] += vtV * 0.5 * dW;
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1] -= vtV * dW;
|
|
|
|
ptGe[2] = ptGe[1] - vtH * (dL + 0.5 * dDn);
|
|
ptGe[3] = ptGe[0] - vtH * (dL + 0.5 * dDn);
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
ptGeU[0] = ptMid;
|
|
ptGeU[0] -= vtH * 0.5 * dDn;
|
|
ptGeU[0] += vtV * 0.5 * dW;
|
|
|
|
ptGeU[1] = ptGeU[0] + vtH * dDn;
|
|
ptGeU[2] = ptGeU[1] - vtV * dW;
|
|
ptGeU[3] = ptGeU[0] - vtV * dW;
|
|
ptGeU[4] = ptGeU[0];
|
|
|
|
pPl = FormatPolyline(ptGeU, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
if (!vtV.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
pPl->setLayer(this->GetDashLayer());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 5://垂直右下弯
|
|
{
|
|
if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//简易画法
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += vtH * dL;
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1] -= vtV * dDn;
|
|
|
|
ptGe[2] = ptGe[1] - vtH * (dL + 0.5 * dDn);
|
|
ptGe[3] = ptGe[0] - vtH * (dL + 0.5 * dDn);
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
ptGeU[0] = ptMid;
|
|
ptGeU[0] -= vtH * 0.5 * dDn;
|
|
ptGeU[0] += vtV * 0.5 * dW;
|
|
|
|
ptGeU[1] = ptGeU[0] + vtH * dDn;
|
|
ptGeU[2] = ptGeU[1] - vtV * dW;
|
|
ptGeU[3] = ptGeU[0] - vtV * dW;
|
|
ptGeU[4] = ptGeU[0];
|
|
|
|
pPl = FormatPolyline(ptGeU, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
if (!vtV.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
pPl->setLayer(this->GetDashLayer());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//空间倾斜不考虑
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrIncline2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dSweepAngle = PI / 2.0;
|
|
double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0, dDn2=0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG, dSweepAngle);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
int nCenNDraw = 0;
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn2 = dParam.dSize[0];//末端
|
|
dW = dParam.dSize[1]; //H
|
|
dDn = dParam.dSize[3];//开始端
|
|
if (dDn < 1.e-1) dDn = dDn2;
|
|
|
|
//dL = dDn * dRatio + dLx;
|
|
dL = GetElbowL(&dParam);
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
|
|
AcGePoint3d ptGe[8],ptGeL[8];
|
|
AcGeVector3d vtNormal = vtMin.crossProduct(vtMaj);
|
|
if (vtNormal.isParallelTo(AcGeVector3d::kZAxis))//电缆沟水平放置
|
|
{
|
|
AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
|
|
AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
|
|
vtMV.normalize();
|
|
vtNV.normalize();
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[0] -= vtMV * 0.5 * dDn;
|
|
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
ptGe[2] -= vtNV * 0.5 * dDn2;
|
|
|
|
AcGeLine3d ln1(ptGe[0], vtMaj);
|
|
AcGeLine3d ln2(ptGe[2], vtMin);
|
|
ln1.intersectWith(ln2, ptGe[1]);
|
|
|
|
ptGe[3] = ptGe[2] + vtNV * dDn2;
|
|
ptGe[4] = ptGe[3] - vtMin * dLx;
|
|
|
|
ptGe[6] = ptGe[0] + vtMV * dDn;
|
|
ptGe[5] = ptGe[6] - vtMaj * dLx;
|
|
|
|
ptGe[7] = ptGe[0];
|
|
|
|
//电缆沟直角结构!
|
|
memcpy(ptGeL, ptGe, sizeof(AcGePoint3d) * 8);
|
|
ptGeL[4] = GetIntersectPt(ptGe[3], vtMin, ptGe[6], vtMaj);
|
|
ptGeL[5] = ptGe[6];
|
|
ptGeL[6] = ptGeL[0];
|
|
|
|
BOOL bHide = FALSE;
|
|
m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);
|
|
|
|
AcDbPolyline *pPl = NULL;
|
|
if (!bHide)
|
|
{
|
|
//pPl = FormatPolyline(ptGe, 8);
|
|
pPl = FormatPolyline(ptGeL, 7);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AcGePoint3d *ptGe2 = ptGe;
|
|
pPl = FormatPolyline(ptGe2, 3);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
|
|
// AcGePoint3d *ptGe3 = ptGe;
|
|
AcGePoint3d *ptGe3 = ptGeL;
|
|
ptGe3 += 3;//->3
|
|
|
|
pPl = FormatPolyline(ptGe3, 3);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[1] = ptMid;
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
|
|
if (nCenNDraw == FALSE)
|
|
{
|
|
pPl = FormatPolyline(ptGe, 3);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(layerId());
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawIncline3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcCmTransparency tr = transparency();
|
|
|
|
AcGeVector3d vtMaj,vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0,dRatio = 1.0,dSweepAngle = PI / 2.0,dH = 0;
|
|
double dThick = 0.35,dLx = 50.0,dL = 0.0,dW = 0.0, dDn2 = 0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
int nElbowStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_ELBOWSTYLE, nElbowStyle);
|
|
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
vtNorm.normalize();
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
|
|
AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
|
|
AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
|
|
vtMV.normalize();
|
|
vtNV.normalize();
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn = dParam.dSize[3];
|
|
dDn2 = dParam.dSize[0];//末端
|
|
if (dDn < 1.e-6) dDn = dDn2;
|
|
|
|
dW = dParam.dSize[1];
|
|
dH = dW;
|
|
//dL = dDn * dRatio + dLx;
|
|
dL = GetElbowL(&dParam);
|
|
|
|
AcGePoint3d ptGe[8], ptFr, ptTo, ptTmp,ptGeI[8],ptGeU[8],ptGeUI[8];
|
|
AcDbLine lnPath;
|
|
AecDbX3dPart part;
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//水平放置
|
|
{
|
|
//OUT
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[0] -= vtMV * 0.5 * dDn;
|
|
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
ptGe[2] -= vtNV * 0.5 * dDn2;
|
|
|
|
AcGeLine3d ln1(ptGe[0], vtMaj);
|
|
AcGeLine3d ln2(ptGe[2], vtMin);
|
|
ln1.intersectWith(ln2, ptGe[1]);
|
|
|
|
ptGe[3] = ptGe[2] + vtNV * dDn2;
|
|
ptGe[4] = ptGe[3] - vtMin * dLx;
|
|
|
|
ptGe[6] = ptGe[0] + vtMV * dDn;
|
|
ptGe[5] = ptGe[6] - vtMaj * dLx;
|
|
|
|
ptGe[7] = ptGe[0];
|
|
|
|
//In
|
|
AcGePoint3d ptTmp;
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 8);
|
|
OffsetPoint(ptGeI[0], ptGeI[6], dThick);
|
|
|
|
ptTmp = ptGeI[0];
|
|
OffsetPoint(ptTmp, ptGeI[1], dThick);
|
|
|
|
OffsetPoint(ptGeI[2], ptGeI[3], dThick);
|
|
|
|
ptGeI[5] = ptGeI[6] - vtMaj * (dLx + dThick);//大约
|
|
ptGeI[4] = ptGeI[3] - vtMin * (dLx + dThick);//大约
|
|
ptGeI[7] = ptGeI[0];
|
|
|
|
AcDbLine lnPath;
|
|
AcDbRegion *pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 8);
|
|
if (pRegOut != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dW;//W
|
|
ptTo = ptMid + vtNorm * 0.5 * dW;//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
AcGeMatrix3d xform;
|
|
AcGeVector3d vt = vtNorm * 0.5 * dW;
|
|
xform.setToTranslation(vt);
|
|
pRegOut->transformBy(xform);
|
|
|
|
AecDbX3dPart part;
|
|
AcDbX3dSolid *pX3dSolidOut = new AcDbX3dSolid;
|
|
pX3dSolidOut->CreateExtrude(pRegOut, lnPath);
|
|
part.AddX3dSolid(pX3dSolidOut);
|
|
|
|
AcDbRegion *pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 8);
|
|
if (pRegIn != NULL)
|
|
{
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
|
|
!dParam.m_bCover)
|
|
{
|
|
//水平放置,不带盖子时
|
|
AcGeVector3d vtRegNorm;
|
|
pRegIn->getNormal(vtRegNorm);
|
|
|
|
ptFr = ptMid - vtRegNorm * 0.5 * dW;
|
|
ptTo = ptMid + vtRegNorm * 0.5 * (dW - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtRegNorm * 0.5 * dW;
|
|
}
|
|
else
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * (dW - 2.0 * dThick);//W
|
|
ptTo = ptMid + vtNorm * 0.5 * (dW - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtNorm * 0.5 * (dW - 2.0 * dThick);
|
|
}
|
|
|
|
xform.setToTranslation(vt);
|
|
pRegIn->transformBy(xform);
|
|
|
|
AcDbX3dSolid *pX3dSolidIn = new AcDbX3dSolid;
|
|
pX3dSolidIn->CreateExtrude(pRegIn, lnPath);
|
|
part.AddX3dSolid(pX3dSolidIn, AcDb::kBoolSubtract);
|
|
|
|
BoolSubtractUserInf3d(part);
|
|
part.Create();
|
|
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
delete pRegIn;
|
|
}
|
|
delete pRegOut;
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
AcGePoint3dArray arPts;
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
arPts.append(ptGe[i]);
|
|
}
|
|
AcDb3dPolyline *pPl3d = Format3dPolyline(arPts);
|
|
if (pPl3d != NULL)
|
|
{
|
|
dc.DrawEntity(pPl3d);
|
|
Add3DBuffer(pPl3d);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//有一个向量平行 Z
|
|
if (vtMaj.isParallelTo(AcGeVector3d::kZAxis) ||
|
|
vtMin.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
AcGeVector3d vtH, vtV, vtZ,vt34;
|
|
|
|
if (nElbowStyle <= 1)
|
|
{
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[0] -= vtMin * 0.5 * dH;
|
|
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
ptGe[2] -= vtMaj * 0.5 * dH;
|
|
|
|
AcGeLine3d ln1(ptGe[0], vtMaj);
|
|
AcGeLine3d ln2(ptGe[2], vtMin);
|
|
ln1.intersectWith(ln2, ptGe[1]);
|
|
|
|
ptGe[3] = ptGe[2] + vtMaj * dH;
|
|
ptGe[4] = ptGe[3] - vtMin * dLx;
|
|
|
|
ptGe[6] = ptGe[0] + vtMin * dH;
|
|
ptGe[5] = ptGe[6] - vtMaj * dLx;
|
|
|
|
ptGe[7] = ptGe[0];
|
|
|
|
//In
|
|
AcGePoint3d ptTmp;
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 8);
|
|
OffsetPoint(ptGeI[0], ptGeI[6], dThick);
|
|
|
|
ptTmp = ptGeI[0];
|
|
OffsetPoint(ptTmp, ptGeI[1], dThick);
|
|
|
|
OffsetPoint(ptGeI[2], ptGeI[3], dThick);
|
|
|
|
ptGeI[5] = ptGeI[6] - vtMaj * (dLx + dThick);//大约
|
|
ptGeI[4] = ptGeI[3] - vtMin * (dLx + dThick);//大约
|
|
ptGeI[7] = ptGeI[0];
|
|
|
|
AcDbLine lnPath;
|
|
AcDbRegion *pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 8);
|
|
if (pRegOut != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dDn;//W
|
|
ptTo = ptMid + vtNorm * 0.5 * dDn;//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
AcGeMatrix3d xform;
|
|
AcGeVector3d vt = vtNorm * 0.5 * dDn;
|
|
xform.setToTranslation(vt);
|
|
pRegOut->transformBy(xform);
|
|
|
|
AecDbX3dPart part;
|
|
AcDbX3dSolid *pX3dSolidOut = new AcDbX3dSolid;
|
|
pX3dSolidOut->CreateExtrude(pRegOut, lnPath);
|
|
part.AddX3dSolid(pX3dSolidOut);
|
|
|
|
AcDbRegion *pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 8);
|
|
if (pRegIn != NULL)
|
|
{
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) && !dParam.m_bCover)
|
|
{
|
|
//水平放置,不带盖子时
|
|
AcGeVector3d vtRegNorm;
|
|
pRegIn->getNormal(vtRegNorm);
|
|
|
|
ptFr = ptMid - vtRegNorm * 0.5 * dW;
|
|
ptTo = ptMid + vtRegNorm * 0.5 * (dW - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtRegNorm * 0.5 * dW;
|
|
}
|
|
else //非水平放置
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * (dDn - 2.0 * dThick);//W
|
|
ptTo = ptMid + vtNorm * 0.5 * (dDn - 2.0 * dThick);//W
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
vt = vtNorm * 0.5 * (dDn - 2.0 * dThick);
|
|
}
|
|
|
|
xform.setToTranslation(vt);
|
|
pRegIn->transformBy(xform);
|
|
|
|
AcDbX3dSolid *pX3dSolidIn = new AcDbX3dSolid;
|
|
pX3dSolidIn->CreateExtrude(pRegIn, lnPath);
|
|
part.AddX3dSolid(pX3dSolidIn, AcDb::kBoolSubtract);
|
|
|
|
BoolSubtractUserInf3d(part);
|
|
part.Create();
|
|
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
delete pRegIn;
|
|
}
|
|
delete pRegOut;
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
AcGePoint3dArray arPts;
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
arPts.append(ptGe[i]);
|
|
}
|
|
AcDb3dPolyline *pPl3d = Format3dPolyline(arPts);
|
|
if (pPl3d != NULL)
|
|
{
|
|
dc.DrawEntity(pPl3d);
|
|
Add3DBuffer(pPl3d);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool bGeSet = false;
|
|
if (nElbowStyle == 2) //垂直左上弯
|
|
{
|
|
if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtZ = vtMaj;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtZ = vtMin;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//3d
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtH * 0.5 * dDn;
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
ptGe[0] += AcGeVector3d::kZAxis * 0.5 * dW;
|
|
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1] -= vtV * dDn;
|
|
|
|
ptGe[2] = ptGe[1] - AcGeVector3d::kZAxis * dW;
|
|
ptGe[3] = ptGe[0] - AcGeVector3d::kZAxis * dW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 5);
|
|
OffsetPoint(ptGeI[0], ptGeI[3], dThick);
|
|
OffsetPoint(ptGeI[1], ptGeI[2], dThick);
|
|
OffsetPoint(ptGeI[0], ptGeI[1], dThick);
|
|
OffsetPoint(ptGeI[2], ptGeI[3], dThick);
|
|
ptGeI[4] = ptGeI[0];
|
|
for (int ii = 0; ii < 5; ii++)
|
|
{
|
|
ptGeI[ii] += vtH * dThick;
|
|
}
|
|
|
|
//口
|
|
ptGeU[0] = ptMid;
|
|
ptGeU[0] -= vtH * 0.5 * dDn;
|
|
ptGeU[0] += vtV * 0.5 * dW;
|
|
|
|
ptGeU[1] = ptGeU[0] + vtH * dDn;
|
|
ptGeU[2] = ptGeU[1] - vtV * dW;
|
|
ptGeU[3] = ptGeU[0] - vtV * dW;
|
|
ptGeU[4] = ptGeU[0];
|
|
for (int ii = 0; ii < 5; ii++)
|
|
{
|
|
ptGeU[ii] += vtZ * 0.5 * dW;
|
|
}
|
|
|
|
memcpy(ptGeUI, ptGeU, sizeof(AcGePoint3d) * 5);
|
|
OffsetPoint(ptGeUI[0], ptGeUI[3], dThick);
|
|
OffsetPoint(ptGeUI[1], ptGeUI[2], dThick);
|
|
OffsetPoint(ptGeUI[0], ptGeUI[1], dThick);
|
|
OffsetPoint(ptGeUI[2], ptGeUI[3], dThick);
|
|
ptGeUI[4] = ptGeUI[0];
|
|
|
|
bGeSet = true;
|
|
}
|
|
else if (nElbowStyle == 3)//垂直右上弯
|
|
{
|
|
if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtZ = vtMaj;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtZ = vtMin;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//3d
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtH * 0.5 * dDn;
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
ptGe[0] += AcGeVector3d::kZAxis * 0.5 * dW;
|
|
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1] -= vtV * dDn;
|
|
|
|
ptGe[2] = ptGe[1] - AcGeVector3d::kZAxis * dW;
|
|
ptGe[3] = ptGe[0] - AcGeVector3d::kZAxis * dW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 5);
|
|
OffsetPoint(ptGeI[0], ptGeI[3], dThick);
|
|
OffsetPoint(ptGeI[1], ptGeI[2], dThick);
|
|
OffsetPoint(ptGeI[0], ptGeI[1], dThick);
|
|
OffsetPoint(ptGeI[2], ptGeI[3], dThick);
|
|
ptGeI[4] = ptGeI[0];
|
|
for (int ii = 0; ii < 5; ii++)
|
|
{
|
|
ptGeI[ii] += vtH * dThick;
|
|
}
|
|
|
|
//口
|
|
ptGeU[0] = ptMid;
|
|
ptGeU[0] -= vtH * 0.5 * dDn;
|
|
ptGeU[0] -= vtV * 0.5 * dW;
|
|
ptGeU[1] = ptGeU[0] + vtH * dDn;
|
|
ptGeU[2] = ptGeU[1] + vtV * dW;
|
|
ptGeU[3] = ptGeU[0] + vtV * dW;
|
|
ptGeU[4] = ptGeU[0];
|
|
for (int ii = 0; ii < 5; ii++)
|
|
{
|
|
ptGeU[ii] += vtZ * 0.5 * dW;
|
|
}
|
|
|
|
memcpy(ptGeUI, ptGeU, sizeof(AcGePoint3d) * 5);
|
|
OffsetPoint(ptGeUI[0], ptGeUI[3], dThick);
|
|
OffsetPoint(ptGeUI[1], ptGeUI[2], dThick);
|
|
OffsetPoint(ptGeUI[0], ptGeUI[1], dThick);
|
|
OffsetPoint(ptGeUI[2], ptGeUI[3], dThick);
|
|
ptGeUI[4] = ptGeUI[0];
|
|
|
|
bGeSet = true;
|
|
}
|
|
else if (nElbowStyle == 4)//垂直左下弯
|
|
{
|
|
if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtZ = vtMaj;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtZ = vtMin;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//3d
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtH * 0.5 * dDn;
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
ptGe[0] += AcGeVector3d::kZAxis * 0.5 * dW;
|
|
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1] -= vtV * dDn;
|
|
|
|
ptGe[2] = ptGe[1] - AcGeVector3d::kZAxis * dW;
|
|
ptGe[3] = ptGe[0] - AcGeVector3d::kZAxis * dW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 5);
|
|
OffsetPoint(ptGeI[0], ptGeI[3], dThick);
|
|
OffsetPoint(ptGeI[1], ptGeI[2], dThick);
|
|
OffsetPoint(ptGeI[0], ptGeI[1], dThick);
|
|
OffsetPoint(ptGeI[2], ptGeI[3], dThick);
|
|
ptGeI[4] = ptGeI[0];
|
|
for (int ii = 0; ii < 5; ii++)
|
|
{
|
|
ptGeI[ii] += vtH * dThick;
|
|
}
|
|
|
|
//口
|
|
ptGeU[0] = ptMid;
|
|
ptGeU[0] -= vtH * 0.5 * dDn;
|
|
ptGeU[0] += vtV * 0.5 * dW;
|
|
ptGeU[1] = ptGeU[0] + vtH * dDn;
|
|
ptGeU[2] = ptGeU[1] - vtV * dW;
|
|
ptGeU[3] = ptGeU[0] - vtV * dW;
|
|
ptGeU[4] = ptGeU[0];
|
|
for (int ii = 0; ii < 5; ii++)
|
|
{
|
|
ptGeU[ii] += vtZ * 0.5 * dW;
|
|
}
|
|
|
|
memcpy(ptGeUI, ptGeU, sizeof(AcGePoint3d) * 5);
|
|
OffsetPoint(ptGeUI[0], ptGeUI[3], dThick);
|
|
OffsetPoint(ptGeUI[1], ptGeUI[2], dThick);
|
|
OffsetPoint(ptGeUI[0], ptGeUI[1], dThick);
|
|
OffsetPoint(ptGeUI[2], ptGeUI[3], dThick);
|
|
ptGeUI[4] = ptGeUI[0];
|
|
|
|
bGeSet = true;
|
|
}
|
|
else if (nElbowStyle == 5)//垂直右下弯
|
|
{
|
|
if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtZ = vtMaj;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtZ = vtMin;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//3d
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtH * 0.5 * dDn;
|
|
ptGe[0] += vtV * 0.5 * dDn;
|
|
ptGe[0] += AcGeVector3d::kZAxis * 0.5 * dW;
|
|
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1] -= vtV * dDn;
|
|
|
|
ptGe[2] = ptGe[1] - AcGeVector3d::kZAxis * dW;
|
|
ptGe[3] = ptGe[0] - AcGeVector3d::kZAxis * dW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 5);
|
|
OffsetPoint(ptGeI[0], ptGeI[3], dThick);
|
|
OffsetPoint(ptGeI[1], ptGeI[2], dThick);
|
|
OffsetPoint(ptGeI[0], ptGeI[1], dThick);
|
|
OffsetPoint(ptGeI[2], ptGeI[3], dThick);
|
|
ptGeI[4] = ptGeI[0];
|
|
for (int ii = 0; ii < 5; ii++)
|
|
{
|
|
ptGeI[ii] += vtH * dThick;
|
|
}
|
|
|
|
//口
|
|
ptGeU[0] = ptMid;
|
|
ptGeU[0] -= vtH * 0.5 * dDn;
|
|
ptGeU[0] -= vtV * 0.5 * dW;
|
|
ptGeU[1] = ptGeU[0] + vtH * dDn;
|
|
ptGeU[2] = ptGeU[1] + vtV * dW;
|
|
ptGeU[3] = ptGeU[0] + vtV * dW;
|
|
ptGeU[4] = ptGeU[0];
|
|
for (int ii = 0; ii < 5; ii++)
|
|
{
|
|
ptGeU[ii] += vtZ * 0.5 * dW;
|
|
}
|
|
|
|
memcpy(ptGeUI, ptGeU, sizeof(AcGePoint3d) * 5);
|
|
OffsetPoint(ptGeUI[0], ptGeUI[3], dThick);
|
|
OffsetPoint(ptGeUI[1], ptGeUI[2], dThick);
|
|
OffsetPoint(ptGeUI[0], ptGeUI[1], dThick);
|
|
OffsetPoint(ptGeUI[2], ptGeUI[3], dThick);
|
|
ptGeUI[4] = ptGeUI[0];
|
|
for (int ii = 0; ii < 5; ii++)
|
|
{
|
|
ptGeUI[ii] -= vtZ * 1.1 * dThick;
|
|
}
|
|
bGeSet = true;
|
|
}
|
|
|
|
if (bGeSet)
|
|
{
|
|
//主
|
|
AcDbRegion *pRegM = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegM != NULL)
|
|
{
|
|
lnPath.setStartPoint(ptGe[0]);
|
|
lnPath.setEndPoint(ptGe[0] + vtH * (dL + 0.5 * dDn));
|
|
|
|
AcDbX3dSolid *pX3dSolidM = new AcDbX3dSolid;
|
|
pX3dSolidM->CreateExtrude(pRegM, lnPath);
|
|
part.AddX3dSolid(pX3dSolidM);
|
|
|
|
AcDbRegion *pRegMI = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 5);
|
|
if (pRegMI != NULL)
|
|
{
|
|
lnPath.setStartPoint(ptGeI[0]);
|
|
lnPath.setEndPoint(ptGeI[0] + vtH * (dL + 0.5 * dDn));
|
|
|
|
AcDbX3dSolid *pX3dSolidMI = new AcDbX3dSolid;
|
|
pX3dSolidMI->CreateExtrude(pRegMI, lnPath);
|
|
part.AddX3dSolid(pX3dSolidMI, AcDb::kBoolSubtract);
|
|
}
|
|
}
|
|
|
|
AcDbRegion *pRegN = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeU, 5);
|
|
if (pRegN != NULL)
|
|
{
|
|
lnPath.setStartPoint(ptGeU[0]);
|
|
lnPath.setEndPoint(ptGeU[0] + vtZ * dL);
|
|
|
|
AcDbX3dSolid *pX3dSolidN = new AcDbX3dSolid;
|
|
pX3dSolidN->CreateExtrude(pRegN, lnPath);
|
|
part.AddX3dSolid(pX3dSolidN);
|
|
|
|
AcDbRegion *pRegNI = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeUI, 5);
|
|
if (pRegNI != NULL)
|
|
{
|
|
lnPath.setStartPoint(ptGeUI[0]);
|
|
lnPath.setEndPoint(ptGeUI[0] + vtZ * (dL + 2.2 * dThick));
|
|
|
|
AcDbX3dSolid *pX3dSolidNI = new AcDbX3dSolid;
|
|
pX3dSolidNI->CreateExtrude(pRegNI, lnPath);
|
|
part.AddX3dSolid(pX3dSolidNI, AcDb::kBoolSubtract);
|
|
}
|
|
}
|
|
|
|
part.Create();
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::DrawTrIncline3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcCmTransparency tr = transparency();
|
|
|
|
AcGeVector3d vtMaj, vtMin;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0, dRatio = 1.0, dSweepAngle = PI / 2.0, dDn2 = 0;
|
|
double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0, dOD = 0.0, dOD2 = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG, dSweepAngle);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
DlgData data;
|
|
memset(&data, 0, sizeof(DlgData));
|
|
GetDlgData(data,0);
|
|
|
|
AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
|
|
vtNorm.normalize();
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
if (vtNorm.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
vtNorm *= -1;//(0,0,-1)//一律向下
|
|
|
|
AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
|
|
AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
|
|
vtMV.normalize();
|
|
vtNV.normalize();
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn2 = dParam.dSize[0];//内径 末端
|
|
dOD2 = dDn2 + 2.0 * dParam.dSize[2];
|
|
|
|
dW = dParam.dSize[1];//H
|
|
|
|
dDn = dParam.dSize[3];//开始端
|
|
if (dDn < 1.e-1) dDn = dDn2;
|
|
|
|
dOD = dDn + 2.0 * dParam.dSize[2];
|
|
|
|
//dL = dDn * dRatio + dLx;
|
|
dL = GetElbowL(&dParam);
|
|
|
|
DlgData data2;
|
|
memset(&data2, 0, sizeof(DlgData));
|
|
GetDlgData(data2, 1);
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(AcGePoint3d::kOrigin, vtNorm);
|
|
if (ln3d.isParallelTo(AcGePlane::kXYPlane))
|
|
{
|
|
double dTmp = dW;
|
|
dW = dDn;
|
|
dDn = dTmp;
|
|
}
|
|
|
|
AcGePoint3d ptGe[8], ptFr, ptTo, ptGeI[8];
|
|
|
|
//OUT
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[0] -= vtMV * 0.5 * dOD;
|
|
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
ptGe[2] -= vtNV * 0.5 * dOD2;
|
|
|
|
AcGeLine3d ln1(ptGe[0], vtMaj);
|
|
AcGeLine3d ln2(ptGe[2], vtMin);
|
|
ln1.intersectWith(ln2, ptGe[1]);
|
|
|
|
ptGe[3] = ptGe[2] + vtNV * dOD2;
|
|
ptGe[5] = ptGe[0] + vtMV * dOD;
|
|
|
|
AcGeLine3d ln3(ptGe[3], vtMin);
|
|
AcGeLine3d ln4(ptGe[5], vtMaj);
|
|
ln3.intersectWith(ln4, ptGe[4]);
|
|
ptGe[6] = ptGe[0];
|
|
|
|
//TestPoint(ptGe, 7, 1);
|
|
|
|
AcDbLine lnPath;
|
|
AecDbX3dPart part;
|
|
|
|
//顶板
|
|
AcDbRegion *pRegTop = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 7);
|
|
if (pRegTop != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * 0.5 * dW;//H
|
|
ptTo = ptFr + vtNorm * data.m_dk;//k
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegTop);
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegTop, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop);
|
|
}
|
|
|
|
//外侧墙
|
|
ptGeI[0] = ptGe[0];
|
|
ptGeI[1] = ptGe[1];
|
|
ptGeI[2] = ptGe[2];
|
|
ptGeI[3] = ptGe[2] + vtNV * data.m_dt;
|
|
ptGeI[5] = ptGe[0] + vtMV * data.m_dt;
|
|
ptGeI[4] = GetIntersectPt(ptGeI[3], vtMin, ptGeI[5], vtMaj);
|
|
ptGeI[6] = ptGeI[0];
|
|
|
|
//TestPoint(ptGeI, 7, 2);
|
|
|
|
AcDbRegion *pRegWall1 = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 7);
|
|
if (pRegWall1 != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dW - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall1);
|
|
AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
|
|
pX3dWall1->CreateExtrude(pRegWall1, lnPath);
|
|
part.AddX3dSolid(pX3dWall1);
|
|
}
|
|
|
|
//内侧墙
|
|
ptGeI[0] = ptGe[5];
|
|
ptGeI[1] = ptGe[4];
|
|
ptGeI[2] = ptGe[3];
|
|
|
|
ptGeI[3] = ptGe[3] - vtNV * data.m_dt;
|
|
ptGeI[5] = ptGe[5] - vtMV * data.m_dt;
|
|
|
|
ptGeI[4] = GetIntersectPt(ptGeI[3], vtMin, ptGeI[5], vtMaj);
|
|
ptGeI[6] = ptGeI[0];
|
|
//TestPoint(ptGeI, 7, 3);
|
|
|
|
AcDbRegion *pRegWall2 = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 7);
|
|
if (pRegWall2 != NULL)
|
|
{
|
|
ptFr = ptMid - vtNorm * (0.5 * dW - data.m_dk);//H
|
|
ptTo = ptFr + vtNorm * data.m_dH;//H
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegWall2);
|
|
AcDbX3dSolid *pX3dWall2 = new AcDbX3dSolid;
|
|
pX3dWall2->CreateExtrude(pRegWall2, lnPath);
|
|
part.AddX3dSolid(pX3dWall2);
|
|
}
|
|
|
|
//底板
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
ptGe[0] -= vtMV * 0.5 * data2.m_dd;
|
|
|
|
ptGe[2] = ptMid;
|
|
ptGe[2] += dL * vtMin;
|
|
ptGe[2] -= vtNV * 0.5 * data.m_dd;
|
|
ptGe[1] = GetIntersectPt(ptGe[0], vtMaj, ptGe[2], vtMin);
|
|
|
|
ptGe[3] = ptGe[2] + vtNV * data.m_dd;
|
|
ptGe[5] = ptGe[0] + vtMV * data2.m_dd;
|
|
ptGe[4] = GetIntersectPt(ptGe[3], vtMin, ptGe[5], vtMaj);
|
|
ptGe[6] = ptGe[0];
|
|
|
|
//TestPoint(ptGe, 7, 4);
|
|
|
|
AcDbRegion *pRegBom = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 7);
|
|
if (pRegBom != NULL)
|
|
{
|
|
ptFr = ptMid + vtNorm * 0.5 * dW;//H
|
|
ptTo = ptFr - vtNorm * data.m_db;//H
|
|
|
|
lnPath.setStartPoint(ptFr);
|
|
lnPath.setEndPoint(ptTo);
|
|
|
|
MoveRegion(ptFr - ptMid, pRegBom);
|
|
AcDbX3dSolid *pX3dSlabB = new AcDbX3dSolid;
|
|
pX3dSlabB->CreateExtrude(pRegBom, lnPath);
|
|
part.AddX3dSolid(pX3dSlabB);
|
|
}
|
|
|
|
part.Create();
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AecDbObjXDataMap* AecDbEcFitting::GetSpecialtyData(AcDb::OpenMode bMode)
|
|
{
|
|
switch(bMode)
|
|
{
|
|
case AcDb::kForRead:
|
|
{
|
|
assertReadEnabled();
|
|
break;
|
|
}
|
|
case AcDb::kForWrite:
|
|
{
|
|
if (!isWriteEnabled())
|
|
{
|
|
upgradeOpen();
|
|
}
|
|
assertWriteEnabled();
|
|
break;
|
|
}
|
|
case AcDb::kForNotify:
|
|
{
|
|
assertReadEnabled();
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
const AecDbObjXDataMap * AecDbEcFitting::GetSpecialtyData() const
|
|
{
|
|
assertReadEnabled();
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
//接口重载
|
|
bool AecDbEcFitting::GetInterface(AcArray<AecInterface>& arInfs) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGeVector3d vtNorm(0,0,1);
|
|
AcGeVector3d vtMaj,vtMin,vtOffset;
|
|
AcGePoint3d ptMid;
|
|
double dDn = 0.0,dRatio = 1.0,dSweepAngle = PI / 2.0;
|
|
double dThick = 0.35,dLx = 50.0,dL = 0.0,dW = 0.0,dDn2 = 0.0;
|
|
double dOffsetH = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptMid);
|
|
|
|
m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
|
|
m_mapSpecXData.GetAt(KEY_OFFSETDIR,vtOffset);//偏移方向
|
|
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
vtOffset.normalize();
|
|
vtNorm.normalize();
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
|
|
m_mapSpecXData.GetAt(KEY_Offset,dOffsetH);
|
|
|
|
m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
|
|
m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dThick);
|
|
m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
|
|
|
|
if (dThick < 1.e-6)
|
|
dThick = 5.0;//至少5mm
|
|
|
|
AecHvac::DuctParam dParam;
|
|
GetDuctParam(dParam);
|
|
|
|
dDn2 = dParam.dSize[0];//D L 末端
|
|
dDn = dParam.dSize[3];//开始端
|
|
if (dDn < 1.e-6)
|
|
dDn = dDn2;
|
|
|
|
double dH = dParam.dSize[1];//H
|
|
double dR = dDn * dRatio;
|
|
dW = dParam.dSize[1];//
|
|
|
|
//变径偏心
|
|
int nEcCen = 0;//偏心
|
|
m_mapSpecXData.GetAt(KEY_ECCEN,nEcCen);
|
|
|
|
if (!m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm))
|
|
{
|
|
vtNorm = vtMin.crossProduct(vtMaj);
|
|
}
|
|
vtNorm.normalize();
|
|
|
|
//变径
|
|
AcGeVector3d vtW = vtMaj;
|
|
vtW.rotateBy(PI / 2.0,vtNorm);
|
|
vtW.normalize();
|
|
double dW1 = dParam.dSize[3];//开始端
|
|
|
|
AcGePoint3d ptGe[5];
|
|
AcGeVector3d vtH, vtV, vtZ;
|
|
|
|
int nType = 0;
|
|
m_mapSpecXData.GetAt(KEY_RUNTIME,nType);
|
|
EFittingType eType = (EFittingType)nType;
|
|
|
|
AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
|
|
m_mapSpecXData.GetAt(HELB_Type, (int&)eElbowType);
|
|
AecInterface inf;
|
|
inf.nSectType = 0;
|
|
inf.dV = inf.dA = 0;
|
|
inf.bSizeUnLock = true;
|
|
inf.nType = nType;
|
|
inf.dGasket = 0;
|
|
int nElbowStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_ELBOWSTYLE, nElbowStyle);
|
|
|
|
int nTeeStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_TEESTYLE, nTeeStyle);
|
|
|
|
switch( eType )
|
|
{
|
|
case eElbow:
|
|
{
|
|
switch(dParam.eType)
|
|
{
|
|
case eRect:
|
|
{
|
|
if (nElbowStyle <= 1) //0,1 标准 [电缆沟] [桥架]
|
|
{
|
|
dL = GetElbowL(&dParam);
|
|
|
|
//L W t
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
arInfs.append(inf);
|
|
|
|
inf.dSize1 = dDn2;
|
|
inf.dSize2 = dW;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMin;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMin;
|
|
arInfs.append(inf);
|
|
}
|
|
else if (nElbowStyle ==2 )//垂直左上弯 [桥架]
|
|
{
|
|
if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtZ = vtMaj;
|
|
}
|
|
else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtZ = vtMin;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
dL = GetElbowL(&dParam);
|
|
|
|
//L W t
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtH;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 0;
|
|
arInfs.append(inf);
|
|
|
|
ptGe[0] = ptMid;
|
|
//ptGe[0] += vtV * 0.5 * dDn;
|
|
//ptGe[0] -= vtV * 0.5 * dW;
|
|
ptGe[0] += vtZ * 0.5 * dW;
|
|
|
|
ptGe[0] += vtZ * dL;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 1;
|
|
arInfs.append(inf);
|
|
|
|
}
|
|
else if (nElbowStyle == 3)//垂直右上弯 [桥架]
|
|
{
|
|
if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtZ = vtMaj;
|
|
}
|
|
else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtZ = vtMin;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
dL = GetElbowL(&dParam);
|
|
|
|
//L W t
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtH;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 0;
|
|
arInfs.append(inf);
|
|
|
|
ptGe[0] = ptMid;
|
|
//ptGe[0] -= vtV * 0.5 * dDn;
|
|
//ptGe[0] += vtV * 0.5 * dW;
|
|
ptGe[0] += vtZ * 0.5 * dW;
|
|
|
|
ptGe[0] += vtZ * dL;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 1;
|
|
arInfs.append(inf);
|
|
}
|
|
else if (nElbowStyle == 4)//垂直左下弯
|
|
{
|
|
if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtZ = vtMaj;
|
|
}
|
|
else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtZ = vtMin;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
dL = GetElbowL(&dParam);
|
|
|
|
//L W t
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtH;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 0;
|
|
arInfs.append(inf);
|
|
|
|
ptGe[0] = ptMid;
|
|
//ptGe[0] += vtV * 0.5 * dDn;
|
|
//ptGe[0] -= vtV * 0.5 * dW;
|
|
ptGe[0] += vtZ * 0.5 * dW;
|
|
|
|
ptGe[0] += vtZ * dL;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 1;
|
|
arInfs.append(inf);
|
|
}
|
|
else if (nElbowStyle == 5)//垂直右下弯
|
|
{
|
|
if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMin;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtZ = vtMaj;
|
|
}
|
|
else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtH = vtMaj;
|
|
vtV = vtH;
|
|
vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtZ = vtMin;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
dL = GetElbowL(&dParam);
|
|
|
|
//L W t
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtH;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 0;
|
|
arInfs.append(inf);
|
|
|
|
ptGe[0] = ptMid;
|
|
//ptGe[0] -= vtV * 0.5 * dDn;
|
|
//ptGe[0] += vtV * 0.5 * dW;
|
|
ptGe[0] += vtZ * 0.5 * dW;
|
|
|
|
ptGe[0] += vtZ * dL;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 1;
|
|
arInfs.append(inf);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case eCircle:
|
|
{
|
|
dL = GetElbowL(&dParam);
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMaj;
|
|
|
|
AecInterface inf;
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dDn;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 0;
|
|
arInfs.append(inf);
|
|
|
|
inf.dSize1 = dDn2;
|
|
inf.dSize2 = dDn2;
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMin;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMin;
|
|
inf.nLevel = 1;
|
|
arInfs.append(inf);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case eTee:
|
|
{
|
|
dL = GetElbowL(&dParam);
|
|
|
|
//L W t
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= dL * vtMaj;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.vtDir.negate();
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 0;
|
|
arInfs.append(inf);
|
|
|
|
ptGe[0] += 2.0 * dL * vtMaj;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.nLevel = 1;
|
|
arInfs.append(inf);
|
|
|
|
if (nTeeStyle == 0)
|
|
{
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] += dL * vtMin;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMin;
|
|
inf.nLevel = 2;
|
|
arInfs.append(inf);
|
|
}
|
|
/*else
|
|
{
|
|
//userinf
|
|
}*/
|
|
break;
|
|
}
|
|
case eCross:
|
|
{
|
|
dL = GetElbowL(&dParam);
|
|
|
|
//L W t
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= dL * vtMaj;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.vtDir.negate();
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 0;
|
|
arInfs.append(inf);
|
|
|
|
ptGe[0] += 2.0 * dL * vtMaj;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.nLevel = 1;
|
|
arInfs.append(inf);
|
|
|
|
//min
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= dL * vtMin;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMin;
|
|
inf.vtDir.negate();
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 2;
|
|
arInfs.append(inf);
|
|
|
|
ptGe[0] += 2.0 * dL * vtMaj;
|
|
inf.ptPos = ptGe[0];
|
|
inf.vtDir = vtMin;
|
|
inf.nLevel = 3;
|
|
arInfs.append(inf);
|
|
|
|
break;
|
|
}
|
|
case eReduce:
|
|
{
|
|
m_mapSpecXData.GetAt(KEY_L,dL);
|
|
|
|
ptGe[0] = ptMid;
|
|
ptGe[0] -= vtMaj * 0.5 * dL;
|
|
ptGe[0] += vtW * 0.5 * dW1;
|
|
|
|
if (nEcCen == 0)
|
|
{
|
|
ptGe[1] = ptMid;
|
|
ptGe[1] += vtMaj * 0.5 * dL;
|
|
ptGe[1] += vtW * 0.5 * dDn;
|
|
}
|
|
else if (nEcCen == 1)
|
|
{
|
|
ptGe[1] = ptGe[0] + vtMaj * dL;
|
|
}
|
|
else if (nEcCen == 2)
|
|
{
|
|
ptGe[1] = ptMid;
|
|
ptGe[1] -= vtMaj * 0.5 * dL;
|
|
ptGe[1] -= vtW * 0.5 * dW1;
|
|
ptGe[1] += vtMaj * dL;
|
|
ptGe[1] += vtW * dDn;
|
|
}
|
|
|
|
ptGe[2] = ptGe[1] - vtW * dDn;
|
|
ptGe[3] = ptGe[0] - vtW * dW1;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW1;
|
|
inf.ptPos = MidPoint(ptGe[0],ptGe[3]);
|
|
inf.vtDir = vtMaj;
|
|
inf.vtDir.negate();
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 0;
|
|
arInfs.append(inf);
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = MidPoint(ptGe[1],ptGe[2]);
|
|
inf.vtDir = vtMaj;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 1;
|
|
arInfs.append(inf);
|
|
|
|
break;
|
|
}
|
|
case eOffset:
|
|
{
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
vtNorm.normalize();
|
|
vtOffset.normalize();
|
|
|
|
//偏移方向的反方向
|
|
AcGeVector3d vtV = vtOffset;//Maj->Min的方向
|
|
vtV = vtV.orthoProject(vtMaj);//MAKE SURE
|
|
vtV.negate();
|
|
vtV.normalize();
|
|
|
|
if (dOffsetH < 1.e-6)
|
|
{
|
|
acutPrintf(_T("\nOffset dist error!"));
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//乙字弯角度 90 < A < 180
|
|
if ( ( dSweepAngle - 90.0 ) > 1.e-10 && (dSweepAngle - 180.0) < 1.e-10)
|
|
{
|
|
AcGePoint3d ptGeCen[4];
|
|
|
|
//转化为弧度
|
|
dSweepAngle *= PI / 180.0;
|
|
|
|
//玄段长度
|
|
double dChrodx = dR * tan(dSweepAngle * 0.5);
|
|
|
|
//斜段总桥架长度
|
|
double dLseg = dOffsetH / sin(dSweepAngle);//180-a
|
|
|
|
//投影到maj方向上 总长
|
|
double dL = dOffsetH / fabs(tan(dSweepAngle));//180-a
|
|
dL += dChrodx * 2.0;
|
|
|
|
//伞心中最大对角线长
|
|
double dAL = sqrt(dR * dR + dChrodx * dChrodx);
|
|
|
|
ptGeCen[0] = ptMid - vtMaj * 0.5 * dL;
|
|
ptGeCen[0] += vtV * 0.5 * dOffsetH;
|
|
|
|
ptGeCen[1] = ptGeCen[0] + vtMaj * dChrodx;
|
|
|
|
AcGeVector3d vtMidL = ptMid - ptGeCen[1];
|
|
vtMidL.normalize();
|
|
ptGeCen[2] = ptGeCen[1] + vtMidL * dLseg;
|
|
ptGeCen[3] = ptGeCen[2] + vtMin * dChrodx;
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW1;
|
|
inf.ptPos = ptGeCen[0];
|
|
inf.vtDir = vtMaj;
|
|
inf.vtDir.negate();
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 0;
|
|
arInfs.append(inf);
|
|
|
|
inf.dSize1 = dDn;
|
|
inf.dSize2 = dW;
|
|
inf.ptPos = ptGeCen[3];
|
|
inf.vtDir = vtMin;
|
|
inf.idOwner = objectId();
|
|
inf.nLevel = 1;
|
|
arInfs.append(inf);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
int nCount = arInfs.length();
|
|
for (int i = 0; i < m_arUserInfs.length(); i++)
|
|
{
|
|
const AecUserInterface &infu = m_arUserInfs.at(i);
|
|
if (infu.nPoints == 2)
|
|
{
|
|
inf.ptPos = infu.ptGe[0];
|
|
inf.dSize1 = infu.ptGe[0].distanceTo(infu.ptGe[1]);
|
|
inf.nSectType = 1;
|
|
inf.vtDir = infu.vtDir;
|
|
inf.ptPos += infu.vtDir;
|
|
inf.nLevel = i + 2;
|
|
inf.nLevel = nCount + i;
|
|
arInfs.append(inf);
|
|
}
|
|
else if (infu.nPoints == 4)//目前只考虑矩形
|
|
{
|
|
inf.ptPos = MidPoint(infu.ptGe[0], infu.ptGe[2]);
|
|
inf.dSize1 = infu.ptGe[0].distanceTo(infu.ptGe[1]);
|
|
inf.dSize2 = infu.ptGe[1].distanceTo(infu.ptGe[2]);
|
|
inf.nSectType = 0;
|
|
inf.vtDir = infu.vtDir;
|
|
inf.ptPos += infu.vtDir;
|
|
inf.nLevel = i + 2;
|
|
inf.nLevel = nCount + i;
|
|
arInfs.append(inf);
|
|
}
|
|
else if (infu.nPoints == 5)//目前只考虑矩形 0 == 4
|
|
{
|
|
inf.ptPos = MidPoint(infu.ptGe[0], infu.ptGe[2]);
|
|
inf.dSize1 = infu.ptGe[0].distanceTo(infu.ptGe[1]);
|
|
inf.dSize2 = infu.ptGe[1].distanceTo(infu.ptGe[2]);
|
|
inf.nSectType = 0;
|
|
inf.vtDir = infu.vtDir;
|
|
inf.ptPos += infu.vtDir;
|
|
inf.nLevel = i + 2;
|
|
inf.nLevel = nCount + i;
|
|
inf.dGasket = 0;
|
|
arInfs.append(inf);
|
|
}
|
|
}
|
|
|
|
return !arInfs.isEmpty();
|
|
}
|
|
|
|
bool AecDbEcFitting::GetInterface(int nIndex,AecInterface& inf) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcArray<AecInterface> arInfs;
|
|
GetInterface(arInfs);
|
|
|
|
if (nIndex > -1 && nIndex < arInfs.length())
|
|
{
|
|
inf = arInfs.at(nIndex);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int AecDbEcFitting::GetInterfaceCount() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int nType = 0;
|
|
m_mapSpecXData.GetAt(KEY_RUNTIME,nType);
|
|
EFittingType eType = (EFittingType)nType;
|
|
|
|
int nTeeStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_TEESTYLE, nTeeStyle);
|
|
|
|
int nInfs = 0;
|
|
switch( eType )
|
|
{
|
|
case eElbow:
|
|
nInfs = 2;
|
|
break;
|
|
case eTee:
|
|
{
|
|
nInfs = 3;
|
|
if (nTeeStyle > 0)
|
|
{
|
|
nInfs = 2;
|
|
}
|
|
}
|
|
break;
|
|
case eCross:
|
|
nInfs = 4;
|
|
break;
|
|
case eReduce:
|
|
nInfs = 2;
|
|
break;
|
|
case eOffset:
|
|
nInfs = 2;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
nInfs += GetUserInterfaceCount();
|
|
|
|
return nInfs;
|
|
}
|
|
|
|
AcGeVector3d AecDbEcFitting::GetNormal() const
|
|
{
|
|
int nType = 0;
|
|
m_mapSpecXData.GetAt(KEY_RUNTIME,nType);
|
|
EFittingType eType = (EFittingType)nType;
|
|
|
|
AcGeVector3d vtMaj,vtMin,vtNorm(0,0,1);
|
|
m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
|
|
m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
|
|
vtMaj.normalize();
|
|
vtMin.normalize();
|
|
|
|
int nInfs = 0;
|
|
switch( eType )
|
|
{
|
|
case eElbow:
|
|
case eTee:
|
|
case eCross:
|
|
{
|
|
vtNorm = vtMaj.crossProduct(vtMin);
|
|
break;
|
|
}
|
|
case eReduce:
|
|
case eOffset:
|
|
{
|
|
m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return vtNorm;
|
|
}
|
|
|
|
int AecDbEcFitting::GetActiveInf() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nInfActive;
|
|
}
|
|
|
|
void AecDbEcFitting::SetActiveInf(int nIndex)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nInfActive = nIndex;
|
|
}
|
|
|
|
void AecDbEcFitting::LockInf(int nInf)
|
|
{
|
|
bool bUpgraded = false;
|
|
if (!isWriteEnabled())
|
|
{
|
|
upgradeOpen();
|
|
bUpgraded = true;
|
|
}
|
|
|
|
CString sKey;
|
|
if (nInf == -1)
|
|
{
|
|
int nCnt = GetInterfaceCount();
|
|
for (int k = 0;k < nCnt;k++)
|
|
{
|
|
sKey.Format(_T("LK_%d"),k);
|
|
m_mapSpecXData.RemoveAt(sKey);
|
|
}
|
|
|
|
if (bUpgraded)
|
|
{
|
|
downgradeOpen();
|
|
}
|
|
return;
|
|
}
|
|
|
|
sKey.Format(_T("LK_%d"),nInf);
|
|
m_mapSpecXData.SetAt(sKey,nInf);
|
|
|
|
if (bUpgraded)
|
|
{
|
|
downgradeOpen();
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbEcFitting::TransformBy(const AcGeMatrix3d xform)
|
|
{
|
|
AssertWriteEnabled();
|
|
return subTransformBy(xform);
|
|
}
|
|
|
|
bool AecDbEcFitting::TransformAssocInf(int nInf,const AcGeMatrix3d& xform)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//FITTING件没有橡皮拉伸特征,固定整体移动
|
|
AecInterface inf;
|
|
if ( GetInterface(nInf,inf) )
|
|
{
|
|
AcGeVector3d vtDir = inf.vtDir;
|
|
AcGePoint3d pt1 = inf.ptPos;
|
|
pt1.transformBy(xform);
|
|
|
|
//AcGeVector3d vt2 = pt1 - inf.ptPos;
|
|
//if (vt2.isParallelTo(vtDir))
|
|
//{
|
|
// return false;
|
|
//}
|
|
|
|
TransformBy(xform);
|
|
return true;//继续发消息
|
|
}
|
|
return false;//不继续发消息
|
|
}
|
|
|
|
bool AecDbEcFitting::GetFittingName(CString &sName) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int nType = 0;
|
|
m_mapSpecXData.GetAt(KEY_RUNTIME, nType);
|
|
EFittingType eType = (EFittingType)nType;
|
|
|
|
switch (eType)
|
|
{
|
|
case eElbow:
|
|
sName = _T("桥架弯头");
|
|
break;
|
|
case eTee:
|
|
sName = _T("桥架三通");
|
|
break;
|
|
case eCross:
|
|
sName = _T("桥架四通");
|
|
break;
|
|
case eReduce:
|
|
sName = _T("桥架变径");
|
|
break;
|
|
case eOffset:
|
|
sName = _T("桥架乙字弯");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool AecDbEcFitting::GetSectionDraw(AcGePlane& plan,const AcGeVector3d& vtTo,AcDbVoidPtrArray& arRegionPtrs) const
|
|
{
|
|
AcGeMatrix3d xform;
|
|
xform.setToPlaneToWorld(plan);
|
|
xform.invert();
|
|
|
|
AcDbVoidPtrArray arSubPtrs;
|
|
AecDbEcFitting* pFit = (AecDbEcFitting*)clone();
|
|
if (pFit != NULL)
|
|
{
|
|
pFit->transformBy(xform);
|
|
|
|
AcGiViewDraw dc(NULL, NULL);
|
|
pFit->Draw2d(dc);
|
|
|
|
pFit->GetDraw2dables(0,arSubPtrs);
|
|
|
|
CString sName;
|
|
GetFittingName(sName);
|
|
MakeBlockRefSet(arSubPtrs, layerId(),Adesk::kTrue,sName);
|
|
|
|
arRegionPtrs.append(arSubPtrs);
|
|
delete pFit;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int AecDbEcFitting::GetSectionDraw(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const AcGeVector3d& vtViewDir,const AcGeVector3d& vtTo, AcDbVoidPtrArray& arRegionPtrs) const
|
|
{
|
|
AcGePlane plan;
|
|
AcGeVector3d vtU = ptTo - ptFr;
|
|
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
plan.set(ptFr,vtU,vtViewDir);
|
|
|
|
int nCount = arRegionPtrs.length();
|
|
GetSectionDraw(plan,vtTo,arRegionPtrs);
|
|
|
|
int nCoundPre = arRegionPtrs.length();
|
|
return (nCount - nCoundPre);
|
|
}
|
|
|
|
int AecDbEcFitting::ComparedTo(AecDbEntityBase* pCurOther) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecDbEcFitting* pPipeOther = AecDbEcFitting::cast(pCurOther);
|
|
if (pPipeOther != NULL)
|
|
{
|
|
AecHvac::DuctParam dpThis;
|
|
GetDuctParam(dpThis);
|
|
|
|
AecHvac::DuctParam dpThat;
|
|
pPipeOther->GetDuctParam(dpThat);
|
|
|
|
if (dpThis.eType != dpThat.eType)
|
|
return 1;
|
|
|
|
if ( fabs(dpThis.dSize[0] - dpThat.dSize[0]) > 0.1)
|
|
return 1;
|
|
|
|
if ( fabs(dpThis.dSize[1] - dpThat.dSize[1]) > 0.1)
|
|
return 1;
|
|
|
|
if ( fabs(dpThis.dSize[2] - dpThat.dSize[2]) > 0.1)
|
|
return 1;
|
|
|
|
if ( fabs(dpThis.m_dEl - dpThat.m_dEl) > 0.1)
|
|
return 1;
|
|
|
|
AcGePoint3d ptSta(0,0,0);
|
|
m_mapSpecXData.GetAt(KEY_MID, ptSta);
|
|
|
|
AcGePoint3d ptSta2(0,0,0);
|
|
pPipeOther->GetSpecialtyData()->GetAt(KEY_MID, ptSta2);
|
|
|
|
if (ptSta.distanceTo(ptSta2) > 2.0)//误差2毫米
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//用户接口
|
|
void AecDbEcFitting::AddUserInterface(const AecUserInterface &inf)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_arUserInfs.append(inf);
|
|
}
|
|
|
|
bool AecDbEcFitting::RemoveUserInterface(const TCHAR *pszNo)
|
|
{
|
|
if (pszNo == NULL)
|
|
return false;
|
|
|
|
AssertWriteEnabled();
|
|
for (int i = 0; i < m_arUserInfs.length(); i++)
|
|
{
|
|
AecUserInterface &inf = m_arUserInfs.at(i);
|
|
if (_tcscmp(inf.szNo, pszNo) == 0)
|
|
{
|
|
m_arUserInfs.removeAt(i);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AecDbEcFitting::RemoveUserInterface(int nIndex)
|
|
{
|
|
AssertWriteEnabled();
|
|
if (nIndex > -1 && nIndex < m_arUserInfs.length())
|
|
{
|
|
m_arUserInfs.removeAt(nIndex);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int AecDbEcFitting::GetUserInterfaceCount() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_arUserInfs.length();
|
|
}
|
|
|
|
bool AecDbEcFitting::GetUserInterface(int nIndex, AecUserInterface &inf) const
|
|
{
|
|
assertReadEnabled();
|
|
if (nIndex > -1 && nIndex < m_arUserInfs.length())
|
|
{
|
|
inf = m_arUserInfs.at(nIndex);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AecDbEcFitting::GetUserInterface(const AcGePoint3d &ptHit, AecUserInterface &inf) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGePoint3d ptInf;
|
|
for (int i = 0; i < m_arUserInfs.length(); i++)
|
|
{
|
|
const AecUserInterface &infu = m_arUserInfs.at(i);
|
|
if (infu.nPoints == 2)
|
|
{
|
|
ptInf = infu.ptGe[0] + infu.vtDir;
|
|
if (ptHit.distanceTo(ptInf) < 1.e-6)
|
|
{
|
|
inf = infu;
|
|
return true;
|
|
}
|
|
}
|
|
else if (infu.nPoints == 4)//目前只考虑矩形
|
|
{
|
|
ptInf = MidPoint(infu.ptGe[0], infu.ptGe[2]) + infu.vtDir;
|
|
if (ptHit.distanceTo(ptInf) < 1.e-6)
|
|
{
|
|
inf = infu;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AecDbEcFitting::ReadUserInterface(AcDbDwgFiler *pFiler)
|
|
{
|
|
//读取用户接口
|
|
m_arUserInfs.removeAll();
|
|
AecUserInterface userInf;
|
|
|
|
Adesk::UInt32 nLen = 0;
|
|
pFiler->readUInt32(&nLen);
|
|
|
|
TCHAR *pszTemp = NULL;
|
|
for (Adesk::UInt32 i = 0; i < nLen; i++)
|
|
{
|
|
memset(&userInf, 0, sizeof(AecUserInterface));
|
|
|
|
pFiler->readString(&pszTemp);
|
|
if (pszTemp != NULL)
|
|
{
|
|
_tcscpy(userInf.szNo, pszTemp);
|
|
acutDelString(pszTemp);
|
|
}
|
|
|
|
Adesk::UInt16 nPts = 0;
|
|
pFiler->readUInt16(&nPts);
|
|
userInf.nPoints = nPts;
|
|
|
|
for (Adesk::UInt16 j = 0; j < nPts; j++)
|
|
{
|
|
pFiler->readPoint3d(&userInf.ptGe[j]);
|
|
}
|
|
|
|
pFiler->readVector3d(&userInf.vtDir);
|
|
|
|
pszTemp = NULL;
|
|
pFiler->readString(&pszTemp);
|
|
|
|
if (pszTemp != NULL)
|
|
{
|
|
_tcscpy(userInf.szSys, pszTemp);
|
|
acutDelString(pszTemp);
|
|
}
|
|
m_arUserInfs.append(userInf);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void AecDbEcFitting::WriteUserInterface(AcDbDwgFiler *pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
pFiler->writeUInt32(m_arUserInfs.length());
|
|
|
|
for (int i = 0; i < m_arUserInfs.length(); i++)
|
|
{
|
|
const AecUserInterface &inf = m_arUserInfs.at(i);
|
|
|
|
pFiler->writeString(inf.szNo);
|
|
|
|
pFiler->writeUInt16(inf.nPoints);
|
|
|
|
for (Adesk::UInt16 ii = 0; ii < inf.nPoints; ii++)
|
|
{
|
|
pFiler->writePoint3d(inf.ptGe[ii]);
|
|
}
|
|
|
|
pFiler->writeVector3d(inf.vtDir);
|
|
|
|
pFiler->writeString(inf.szSys);
|
|
}
|
|
}
|
|
|
|
#include "hlrcutoption.h"
|
|
void AecDbEcFitting::ProcessHlrResult(const AcArray<AcDbEntity *> &ar, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr, AcArray<AcDbEntity *> &output) const
|
|
{
|
|
double dW;
|
|
HlrCutOption::ProcessHlrResult(this
|
|
, HlrCutOption::getHlrLW_ElecSys(dW)
|
|
, dW
|
|
, HlrCutOption::getHlrBLK_FITTING()
|
|
, ar
|
|
, preAr
|
|
, output);
|
|
} |