2769 lines
74 KiB
C++
2769 lines
74 KiB
C++
#include "stdafx.h"
|
|
#include "THImpHvacDeDustCover.h"
|
|
#include "TDbInterfaceMsgWrite.h"
|
|
|
|
|
|
THImpHvacDeDustCover::THImpHvacDeDustCover()
|
|
{
|
|
|
|
}
|
|
|
|
THImpHvacDeDustCover::~THImpHvacDeDustCover()
|
|
{
|
|
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::GetInterfaceSizeData(int nIndex, TInterface& pipeInterface) const
|
|
{
|
|
ASSERT(NULL != m_pXDataMap);
|
|
|
|
// 获取尺寸
|
|
double dWidth = 0.0, dThick = 0.0;
|
|
|
|
// 设置接口数据
|
|
pipeInterface.SetSize(dWidth, dThick);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::GetInterface(int nIndex,TInterface& pipeInterface) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vt;
|
|
CString sName;
|
|
double dw,dt;
|
|
AcDbObjectId id;
|
|
|
|
GetInterFaceLocal(nIndex, pt);
|
|
GetInterFaceLocal(nIndex, vt);
|
|
GetInterFaceLocal(nIndex, sName);
|
|
GetInterFaceLocal(nIndex, dw, dt);
|
|
CString sID;
|
|
sID.Format(_T("%s%d"), KEY_IDCNT_, nIndex + 1);
|
|
if (m_pXDataMap->GetAt(sID, id) && MakesureInterfaceValidate(id, pt, vt, pipeInterface))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
pipeInterface.SetSize(dw,dt);
|
|
pipeInterface.SetOutDir(vt);
|
|
pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
|
|
pipeInterface.SetPosition(pt);
|
|
pipeInterface.SetDescr(sName);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::GetInterface(const AcGePoint3d& ptCon,TInterface& pipeInterface) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
|
|
int nIndex(-1);
|
|
if(GetIFIndexFormPt(nIndex,ptCon))
|
|
return GetInterface(nIndex,pipeInterface);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::HasInterface(const AcGePoint3d& ptCon,const AcGeVector3d& vtDir)
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
|
|
// 获取各点位置
|
|
int nIndex(-1);
|
|
AcGeVector3d vtIf;
|
|
if(GetIFIndexFormPt(nIndex,ptCon))
|
|
{
|
|
GetInterFaceLocal(nIndex,vtIf);
|
|
return (vtDir.isParallelTo(vtIf));
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
int THImpHvacDeDustCover::GetInterfaceCount() const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return 0;
|
|
int iIfNum(0);
|
|
m_pXDataMap->GetAt(HEQU_InterfaceNum, iIfNum);
|
|
return iIfNum;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
|
|
// 打开对象
|
|
AcDbEntity* pEnt;
|
|
if (Acad::eOk != acdbOpenObject(pEnt, idConnect, AcDb::kForRead))
|
|
return FALSE;
|
|
// 检查对象类型，是否是暖通管件
|
|
if (!(pEnt->isKindOf(TDbHvacDuct::desc()) || pEnt->isKindOf(TDbHvacFitting::desc())
|
|
|| pEnt->isKindOf(TDbHvacEquipment::desc())))
|
|
{
|
|
pEnt->close();
|
|
return FALSE;
|
|
}
|
|
|
|
// 获取各点位置
|
|
int nIndex(-1);
|
|
if(GetIFIndexFormPt(nIndex,ptConnect))
|
|
{
|
|
CString sID;
|
|
sID.Format(_T("%s%d"), KEY_IDCNT_, nIndex + 1);
|
|
|
|
// 基类指针
|
|
TDbInterfacesObj* pInterfaceObj = TDbInterfacesObj::cast(pEnt);
|
|
ASSERT(NULL != pInterfaceObj);
|
|
m_pXDataMap->SetAt(sID, idConnect);
|
|
pEnt->close();
|
|
return TRUE;
|
|
}
|
|
pEnt->close();
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::RemoveInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
|
|
// 浅层次删除; 命名字典中的关系,需要外面移除关系,只移除内部关系
|
|
|
|
AcDbObjectId id;
|
|
int nIndex(-1);
|
|
if(GetIFIndexFormPt(nIndex,ptConnect))
|
|
{
|
|
CString sID;
|
|
sID.Format(_T("%s%d"),KEY_IDCNT_,nIndex + 1);
|
|
m_pXDataMap->SetAt(sID, AcDbObjectId::kNull);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::NotifyInterfaceToModify(const TInterfaceModifyMsg& iModiMsg,TInterfaceModifyMsgs& iModiMsgs)
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
|
|
// 获得消息传递设置, 确定是否传递消息
|
|
CString sDispatch = _T("0");
|
|
GetGlobalContext(KEY_DISPATCHMSG, sDispatch);
|
|
BOOL bDispatch = (_ttoi(sDispatch) != 0);
|
|
|
|
BOOL bMsgTranslate = FALSE;
|
|
// 获得消息类型, 根据消息类型处理
|
|
TDb::InterfaceOper eOper = iModiMsg.GetInterfaceOper();
|
|
switch (eOper)
|
|
{
|
|
case TDb::eMoveGripPoint:
|
|
// 夹点移动消息处理
|
|
bMsgTranslate = OnMoveGripPointMsgNotify(iModiMsg, iModiMsgs);
|
|
break;
|
|
default:
|
|
return bMsgTranslate;
|
|
}
|
|
|
|
// 记录修改标识
|
|
if (m_pOwnerEnt != NULL)
|
|
m_pOwnerEnt->recordGraphicsModified();
|
|
|
|
return bMsgTranslate;
|
|
}
|
|
|
|
|
|
BOOL THImpHvacDeDustCover::OnMoveGripPointMsgNotify( const TInterfaceModifyMsg& iModiMsg,
|
|
TInterfaceModifyMsgs& iModiMsgs )
|
|
{
|
|
if (!TAuxTools::IsAutoWorkOffset())
|
|
return FALSE;
|
|
|
|
ASSERT(NULL != m_pXDataMap);
|
|
|
|
AcDbObjectId id = iModiMsg.GetMsgOperateOn();
|
|
AcDbObjectId idOwner = m_pOwnerEnt->objectId();
|
|
if (id != idOwner) // 消息发送目标正确
|
|
return FALSE;
|
|
|
|
AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset();
|
|
if (vtOffset.isZeroLength())
|
|
return FALSE;
|
|
|
|
BOOL bMsgTranslate = FALSE;
|
|
|
|
int nPos = iModiMsg.GetGripPosition();
|
|
if (nPos == eStart || nPos == eMid || nPos == eEnd || nPos == eBr1 || nPos == eBr2)
|
|
{
|
|
AcGePoint3d ptCenter, ptText;
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
m_pXDataMap->GetAt(HEQU_TextPoint, ptText);
|
|
|
|
ptCenter += vtOffset;
|
|
ptText += vtOffset;
|
|
|
|
m_pXDataMap->SetAt(HEQU_CenterPoint, ptCenter);
|
|
m_pXDataMap->SetAt(HEQU_TextPoint, ptText);
|
|
|
|
// 设备其他接口消息传递
|
|
TInterface tIf;
|
|
AcDbObjectId idT(AcDbObjectId::kNull);
|
|
AcGePoint3d ptIf;
|
|
AcGeVector3d vtIf;
|
|
int i(0);
|
|
for (i = 0; i < GetInterfaceCount(); i++)
|
|
{
|
|
tIf.Reset();
|
|
if (!GetInterface(i, tIf))
|
|
continue;
|
|
|
|
ptIf = tIf.GetPosition();
|
|
vtIf = tIf.GetOutDir();
|
|
if (FindConnect(ptIf, vtIf, idOwner, idT))
|
|
{
|
|
if (vtOffset.isParallelTo(vtIf) || vtOffset.isPerpendicularTo(vtIf))
|
|
{
|
|
TInterfaceModifyMsg msg;
|
|
msg.SetMsgPoint(ptIf);
|
|
msg.SetMoveGripOffset(vtOffset);
|
|
msg.SetMsgOperateOn(idT);
|
|
msg.SetGripPosition(eStart);
|
|
iModiMsgs.append(msg);
|
|
bMsgTranslate = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
AcGeMatrix3d mtTrans;
|
|
mtTrans.setToTranslation(vtOffset);
|
|
SetInterFaceLocal(mtTrans);
|
|
|
|
// 更新模型空间的扩展字典的注册的接口数据
|
|
AcGeMatrix3d xform;
|
|
xform.setToTranslation(vtOffset);
|
|
UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
|
|
}
|
|
|
|
return bMsgTranslate;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::MakeCurves(TComplexCurve& cplCurve) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
|
|
AcGePoint3dArray arPts;
|
|
GetBoxPts(arPts);
|
|
|
|
TDb::TCurveElement el;
|
|
memset(&el,0,sizeof(TDb::TCurveElement));
|
|
|
|
if (IsVertAlignment())
|
|
{
|
|
// 外框
|
|
el.ptGe[0] = arPts[1];
|
|
el.ptGe[1] = arPts[2];
|
|
el.ptGe[2] = arPts[2];
|
|
cplCurve.append(el);
|
|
el.ptGe[0] = arPts[3];
|
|
el.ptGe[1] = arPts[4];
|
|
el.ptGe[2] = arPts[4];
|
|
cplCurve.append(el);
|
|
el.ptGe[0] = arPts[1];
|
|
el.ptGe[1] = arPts[4];
|
|
el.ptGe[2] = arPts[4];
|
|
cplCurve.append(el);
|
|
el.ptGe[0] = arPts[2];
|
|
el.ptGe[1] = arPts[3];
|
|
el.ptGe[2] = arPts[3];
|
|
cplCurve.append(el);
|
|
}
|
|
else if (IsHorzAligment())
|
|
{
|
|
if (arPts.length() != 7)
|
|
return FALSE;
|
|
// 外框
|
|
el.ptGe[0] = arPts[3];
|
|
el.ptGe[1] = arPts[4];
|
|
el.ptGe[2] = arPts[4];
|
|
cplCurve.append(el);
|
|
el.ptGe[0] = arPts[4];
|
|
el.ptGe[1] = arPts[5];
|
|
el.ptGe[2] = arPts[5];
|
|
cplCurve.append(el);
|
|
el.ptGe[0] = arPts[5];
|
|
el.ptGe[1] = arPts[6];
|
|
el.ptGe[2] = arPts[6];
|
|
cplCurve.append(el);
|
|
el.ptGe[0] = arPts[6];
|
|
el.ptGe[1] = arPts[3];
|
|
el.ptGe[2] = arPts[3];
|
|
cplCurve.append(el);
|
|
}
|
|
else
|
|
;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::GetCurvesInSide(TComplexCurve& compCurve) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
|
|
// 基本四角点
|
|
AcGePoint3dArray arPts;
|
|
GetBoxPts(arPts);
|
|
if (arPts.length() < 5)
|
|
return FALSE;
|
|
|
|
HvacDeDustCoverType eType = TDb::eCenterInterface;
|
|
m_pXDataMap->GetAt(HDED_TYPE, (int&)eType);
|
|
|
|
if (IsVertAlignment())
|
|
{
|
|
if (TDb::eSideInterface == eType)
|
|
CheckIfPostion();
|
|
|
|
// 接口信息
|
|
AcGePoint3d ptIf;
|
|
GetInterFaceLocal(0, ptIf);
|
|
double dHeigh(0), dDia(0);
|
|
GetInterFaceLocal(0, dDia, dHeigh);
|
|
|
|
// 主向量、法向量、跟主向量垂直向量
|
|
AcGeVector3d vtMain, vtNormal, vtVert;
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
vtNormal = GetNormal();
|
|
vtMain.normalize();
|
|
vtVert = vtMain;
|
|
vtVert.rotateBy(PI*0.5, vtNormal);
|
|
|
|
AcGePoint3d ptUp, ptDown, ptLeft, ptRight; // 圆的上下左右四点
|
|
ptUp = ptIf + vtVert * dDia * 0.5;
|
|
ptDown = ptUp - vtVert * dDia;
|
|
ptLeft = ptIf - vtMain * dDia * 0.5;
|
|
ptRight = ptLeft + vtMain * dDia;
|
|
ptUp.z = ptDown.z = ptLeft.z = ptRight.z = arPts[1].z;
|
|
|
|
TDb::TCurveElement el;
|
|
memset(&el,0,sizeof(TDb::TCurveElement));
|
|
|
|
// 绘制接口圆
|
|
el.ptGe[0] = ptUp;
|
|
el.ptGe[1] = ptLeft;
|
|
el.ptGe[2] = ptDown;
|
|
compCurve.append(el);
|
|
|
|
el.ptGe[0] = ptDown;
|
|
el.ptGe[1] = ptRight;
|
|
el.ptGe[2] = ptUp;
|
|
compCurve.append(el);
|
|
|
|
// 绘制支撑线
|
|
el.ptGe[0] = arPts[1];
|
|
el.ptGe[1] = ptUp;
|
|
el.ptGe[2] = ptUp;
|
|
compCurve.append(el);
|
|
|
|
el.ptGe[0] = ptUp;
|
|
el.ptGe[1] = arPts[2];
|
|
el.ptGe[2] = arPts[2];
|
|
compCurve.append(el);
|
|
|
|
el.ptGe[0] = arPts[2];
|
|
el.ptGe[1] = ptRight;
|
|
el.ptGe[2] = ptRight;
|
|
compCurve.append(el);
|
|
|
|
el.ptGe[0] = ptRight;
|
|
el.ptGe[1] = arPts[3];
|
|
el.ptGe[2] = arPts[3];
|
|
compCurve.append(el);
|
|
|
|
el.ptGe[0] = arPts[3];
|
|
el.ptGe[1] = ptDown;
|
|
el.ptGe[2] = ptDown;
|
|
compCurve.append(el);
|
|
|
|
el.ptGe[0] = ptDown;
|
|
el.ptGe[1] = arPts[4];
|
|
el.ptGe[2] = arPts[4];
|
|
compCurve.append(el);
|
|
|
|
el.ptGe[0] = arPts[4];
|
|
el.ptGe[1] = ptLeft;
|
|
el.ptGe[2] = ptLeft;
|
|
compCurve.append(el);
|
|
|
|
el.ptGe[0] = ptLeft;
|
|
el.ptGe[1] = arPts[1];
|
|
el.ptGe[2] = arPts[1];
|
|
compCurve.append(el);
|
|
}
|
|
else if (IsHorzAligment())
|
|
{
|
|
if (arPts.length() != 7)
|
|
return FALSE;
|
|
|
|
TDb::TCurveElement el;
|
|
memset(&el,0,sizeof(TDb::TCurveElement));
|
|
|
|
el.ptGe[0] = arPts[2];
|
|
el.ptGe[1] = arPts[5];
|
|
el.ptGe[2] = arPts[5];
|
|
compCurve.append(el);
|
|
|
|
el.ptGe[0] = arPts[2];
|
|
el.ptGe[1] = arPts[6];
|
|
el.ptGe[2] = arPts[6];
|
|
compCurve.append(el);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
AcDbPolyline* THImpHvacDeDustCover::MakePolyCurve() const
|
|
{
|
|
//
|
|
//
|
|
// 1 ┃━━━━━┃ 3
|
|
// ┃ ┃
|
|
// ┃ 0 ┃
|
|
// ┃ ┃
|
|
// 2 ┃━━━━━┃ 4
|
|
//
|
|
|
|
// 获取各点位置
|
|
AcDbPolyline* pPolyLine = NULL;
|
|
|
|
if (IsVertAlignment())
|
|
{
|
|
AcGePoint3d pt1, pt2, pt3, pt4, ptCenter;
|
|
AcGePoint3d ptU1, ptU2, ptU3, ptU4;
|
|
AcGeVector3d vtMain, vtNor, vtMainv;
|
|
double dLength(50.0), dThick(50.0), dWidth(50.0), dPlusEdge(50.0);
|
|
AcDbDatabase* pDb = acdbCurDwg();
|
|
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
|
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
m_pXDataMap->GetAt(HEQU_Length, dLength);
|
|
m_pXDataMap->GetAt(HEQU_Width, dWidth);
|
|
m_pXDataMap->GetAt(HEQU_Thick, dThick);
|
|
|
|
// 避免有重复点造成无效的多段线，R16平台下崩溃
|
|
if (dLength < 1)
|
|
dLength = 1.0;
|
|
if (dWidth < 1)
|
|
dWidth = 1.0;
|
|
if (dThick < 1)
|
|
dThick = 1.0;
|
|
|
|
vtMainv = vtMain;
|
|
vtMainv.rotateBy(PI * 0.5, vtNor);
|
|
vtMain.normalize();
|
|
vtMainv.normalize();
|
|
|
|
pt1 = ptCenter + vtMainv * dWidth * 0.5;
|
|
pt2 = ptCenter - vtMainv * dWidth * 0.5;
|
|
pt1 = pt1 - vtMain * dLength *0.5;
|
|
pt3 = pt1 + vtMain * dLength;
|
|
pt2 = pt2 - vtMain * dLength *0.5;
|
|
pt4 = pt2 + vtMain * dLength;
|
|
ptU1 = pt1 + vtNor * dThick;
|
|
ptU2 = pt2 + vtNor * dThick;
|
|
ptU3 = pt3 + vtNor * dThick;
|
|
ptU4 = pt4 + vtNor * dThick;
|
|
AcGePoint3dArray arpts;
|
|
|
|
if (vtNor.angleTo(vtZAxis) < PI*0.25 || vtNor.angleTo(-vtZAxis) < PI*0.25)
|
|
{
|
|
arpts.append(pt1);
|
|
arpts.append(pt2);
|
|
arpts.append(pt4);
|
|
arpts.append(pt3);
|
|
}
|
|
else if (vtNor.angleTo(pDb->ucsxdir()) < PI*0.25 || vtNor.angleTo(-pDb->ucsxdir()) < PI*0.25)
|
|
{
|
|
ptU2.z = pt2.z = ptU1.z = pt1.z = ptCenter.z;
|
|
arpts.append(ptU2);
|
|
arpts.append(pt2);
|
|
arpts.append(pt1);
|
|
arpts.append(ptU1);
|
|
}
|
|
else if (vtNor.angleTo(pDb->ucsydir()) < PI*0.25 || vtNor.angleTo(-pDb->ucsydir()) < PI*0.25)
|
|
{
|
|
ptU1.z = pt1.z = ptU3.z = pt3.z = ptCenter.z;
|
|
arpts.append(ptU1);
|
|
arpts.append(pt1);
|
|
arpts.append(pt3);
|
|
arpts.append(ptU3);
|
|
}
|
|
|
|
AcGePlane plan(arpts[0], arpts[1], arpts[2]);
|
|
AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
|
|
plan.set(ptOrth, vtZAxis);
|
|
|
|
double dEl = ptOrth.asVector().length();
|
|
if (ptOrth.asVector().angleTo(plan.normal()) > PI*0.5)
|
|
dEl *= -1.0;
|
|
|
|
pPolyLine = new AcDbPolyline;
|
|
pPolyLine->addVertexAt(0,arpts[0].convert2d(plan));
|
|
pPolyLine->addVertexAt(1,arpts[1].convert2d(plan));
|
|
pPolyLine->addVertexAt(2,arpts[2].convert2d(plan));
|
|
pPolyLine->addVertexAt(3,arpts[3].convert2d(plan));
|
|
pPolyLine->setClosed(Adesk::kTrue);
|
|
pPolyLine->setElevation(dEl);
|
|
pPolyLine->setNormal(plan.normal());
|
|
return pPolyLine;
|
|
}
|
|
else if (IsHorzAligment())
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
if (!GetBoxPts(arPts))
|
|
return NULL;
|
|
|
|
if (arPts.length() != 7)
|
|
return FALSE;
|
|
|
|
AcGeVector3d vtZAxis(TAuxTools::GetUcsZvt());
|
|
|
|
AcGePlane plan(arPts[0], vtZAxis);
|
|
AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
|
|
plan.set(ptOrth, vtZAxis);
|
|
|
|
double dEl = ptOrth.asVector().length();
|
|
if (ptOrth.asVector().angleTo(plan.normal()) > PI*0.5)
|
|
dEl *= -1.0;
|
|
|
|
pPolyLine = new AcDbPolyline;
|
|
if (NULL != pPolyLine)
|
|
{
|
|
pPolyLine->addVertexAt(0, arPts[3].convert2d(plan));
|
|
pPolyLine->addVertexAt(1, arPts[4].convert2d(plan));
|
|
pPolyLine->addVertexAt(2, arPts[5].convert2d(plan));
|
|
pPolyLine->addVertexAt(3, arPts[6].convert2d(plan));
|
|
pPolyLine->setClosed(Adesk::kTrue);
|
|
pPolyLine->setElevation(dEl);
|
|
pPolyLine->setNormal(plan.normal());
|
|
|
|
return pPolyLine;
|
|
}
|
|
}
|
|
else
|
|
;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::MakePolyCurveFaces(AcDbVoidPtrArray& arFaces)
|
|
{
|
|
//
|
|
//
|
|
// 1 ┃━━━━━┃ 3
|
|
// ┃ ┃
|
|
// ┃ 0 ┃
|
|
// ┃ ┃
|
|
// 2 ┃━━━━━┃ 4
|
|
//
|
|
|
|
if (IsVertAlignment())
|
|
{
|
|
// 获取各点位置
|
|
AcGePoint3d pt1, pt2, pt3, pt4, ptCenter;
|
|
AcGeVector3d vtMain, vtNor, vtMainv;
|
|
AcDbDatabase* pDb = acdbCurDwg();
|
|
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
|
double dLength(50.0), dThick(50.0), dWidth(50.0), dPlusEdge(50.0);
|
|
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
m_pXDataMap->GetAt(HEQU_Length, dLength);
|
|
m_pXDataMap->GetAt(HEQU_Width, dWidth);
|
|
vtMainv = vtMain;
|
|
vtMainv.rotateBy(PI * 0.5, vtZAxis);
|
|
vtMain.normalize();
|
|
vtMainv.normalize();
|
|
|
|
if (IsParallelToX())
|
|
{
|
|
dLength = dThick;
|
|
}
|
|
else if (IsParallelToY())
|
|
{
|
|
dWidth = dThick;
|
|
}
|
|
|
|
pt1 = ptCenter + vtMainv * dWidth * 0.5;
|
|
pt2 = ptCenter - vtMainv * dWidth * 0.5;
|
|
pt1 = pt1 - vtMain * dLength *0.5;
|
|
pt3 = pt1 + vtMain * dLength;
|
|
pt2 = pt2 - vtMain * dLength *0.5;
|
|
pt4 = pt2 + vtMain * dLength;
|
|
AcDbFace * pFace = new AcDbFace;
|
|
pFace->setVertexAt(0,pt1);
|
|
pFace->setVertexAt(1,pt2);
|
|
pFace->setVertexAt(2,pt4);
|
|
pFace->setVertexAt(3,pt3);
|
|
arFaces.append(pFace);
|
|
}
|
|
else if (IsHorzAligment())
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
if (!GetBoxPts(arPts))
|
|
return FALSE;
|
|
|
|
if (arPts.length() != 7)
|
|
return FALSE;
|
|
|
|
AcDbFace* pFace = new AcDbFace;
|
|
if (NULL != pFace)
|
|
{
|
|
pFace->setVertexAt(0, arPts[3]);
|
|
pFace->setVertexAt(1, arPts[4]);
|
|
pFace->setVertexAt(2, arPts[5]);
|
|
pFace->setVertexAt(3, arPts[6]);
|
|
arFaces.append(pFace);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
;
|
|
}
|
|
|
|
return arFaces.length() > 0;
|
|
}
|
|
|
|
void THImpHvacDeDustCover::GetKindName(CString& sName)
|
|
{
|
|
sName = _T("ATS_DBHEQUIPMENT");
|
|
}
|
|
|
|
TDb::Position THImpHvacDeDustCover::ExplainGripIndex(int nIndex) const
|
|
{
|
|
if(nIndex == 0)
|
|
{
|
|
return TDb::eMid;
|
|
}
|
|
else
|
|
{
|
|
int nIfCount = GetInterfaceCount();
|
|
if (nIndex <= nIfCount)
|
|
return TDb::eCommand0;
|
|
else if (nIndex == nIfCount + 1)
|
|
return TDb::eAdjust0;
|
|
else if (nIndex > nIfCount + 1 && nIndex <= nIfCount + 5)
|
|
return TDb::eMid;
|
|
else if (nIndex > nIfCount + 5)
|
|
return TDb::eStart;
|
|
}
|
|
|
|
return TDb::eMid;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::GetGripText(int i, CString &cs) const
|
|
{
|
|
if (i == 0)
|
|
{
|
|
cs = _T("改变位置");
|
|
}
|
|
else
|
|
{
|
|
int nIfCount = GetInterfaceCount();
|
|
if (i <= nIfCount)
|
|
GetInterFaceLocal(i - 1,cs);
|
|
else if (i == nIfCount + 1)
|
|
cs = _T("移动接口位置");
|
|
else if (i > nIfCount + 1 && i <= nIfCount + 5)
|
|
cs = _T("改变位置");
|
|
else if (i > nIfCount + 4)
|
|
cs = _T("改变文字位置");
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void THImpHvacDeDustCover::GetTips(CMapStringToString& mapLable2Tip) const
|
|
{
|
|
}
|
|
|
|
bool THImpHvacDeDustCover::GetSection(const AcDbFace &face, const AcGeVector3d &vtPlaneSecDir,
|
|
std::vector<TObjSectionRecord> §ionRecord, AcDbVoidPtrArray& arFillPtrs) const
|
|
{
|
|
AcDbVoidPtrArray arFaces;
|
|
XExplodeStream dc(arFaces);
|
|
ExplodeOrDraw3d(dc);
|
|
|
|
double dElevation(0.0);
|
|
AcDbEntity* pEnt = NULL;
|
|
AcDbFace* pFace = NULL;
|
|
TGGeSectionPlane section_pln(face, vtPlaneSecDir); // 构造一个辅助剖面
|
|
AcDbObjectId idObj = m_pOwnerEnt->objectId();
|
|
AcDbObjectId idLayer = m_pOwnerEnt->layerId();
|
|
for (int i = 0; i < arFaces.length(); ++i)
|
|
{
|
|
pEnt = (AcDbEntity*)arFaces[i];
|
|
if (NULL == pEnt)
|
|
continue;
|
|
|
|
pFace = AcDbFace::cast(pEnt);
|
|
if (pFace)
|
|
{
|
|
TGGeSectionPlane pln(*pFace, vtPlaneSecDir);
|
|
TGGePoly2D poly;
|
|
dElevation = SectionUtility::Projection_plane2plane(section_pln, pln, poly);
|
|
if(!!poly)
|
|
sectionRecord.push_back(TObjSectionRecord(idObj, idLayer, TObjSectionRecord::eTCH_DBHEQUIPMENT, dElevation, poly));
|
|
}
|
|
|
|
delete pEnt;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 从天圆地方（变径）三维画法中拷贝过来修改的
|
|
Acad::ErrorStatus THImpHvacDeDustCover::ExplodeOrDraw3d(XExplodeDraw &mode) const
|
|
{
|
|
ASSERT(NULL != m_pXDataMap);
|
|
|
|
double dStartWidth = 200.0, dStartThick = 200.0, dEndWidth = 400.0,
|
|
dEndThick = 400.0, dPlusEdge = 0.0;
|
|
|
|
AcGePoint3d ptStart, ptEnd;
|
|
AcGeVector3d vtNormal, vtMain; // vtNormal::对应以前变径的normal，不同于此设备normal
|
|
|
|
m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
|
|
TDb::HvacDeDustCoverType eType = TDb::eCenterInterface;
|
|
m_pXDataMap->GetAt(HDED_TYPE, (int&)eType);
|
|
AcGeVector3d vtSect;
|
|
if (TDb::eCenterInterface == eType || TDb::eSideInterface == eType)
|
|
{
|
|
vtSect = vtNormal;
|
|
vtNormal = vtMain;
|
|
|
|
m_pXDataMap->GetAt(HEQU_Length, dEndThick);
|
|
m_pXDataMap->GetAt(HEQU_Width, dEndWidth);
|
|
dEndThick = fabs(dEndThick);
|
|
dEndWidth = fabs(dEndWidth);
|
|
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptEnd);
|
|
}
|
|
else if (TDb::eHorzSideInterface == eType)
|
|
{
|
|
AcGeVector3d vtIf;
|
|
if (!GetInterFaceLocal(0, vtIf))
|
|
return Acad::eNotImplementedYet;
|
|
vtSect = vtIf;
|
|
vtNormal.normalize();
|
|
|
|
m_pXDataMap->GetAt(HEQU_Thick, dEndThick);
|
|
m_pXDataMap->GetAt(HEQU_Width, dEndWidth);
|
|
dEndThick = fabs(dEndThick);
|
|
dEndWidth = fabs(dEndWidth);
|
|
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptEnd);
|
|
ptEnd = ptEnd - vtIf.normalize() * dEndThick*0.5;
|
|
}
|
|
|
|
double dTemp(0);
|
|
GetInterFaceLocal(0, dStartWidth, dTemp);
|
|
dStartThick = dStartWidth;
|
|
|
|
|
|
GetInterFaceLocal(0, ptStart);
|
|
|
|
// 以下与 变径(方对圆)的三位绘制方法完全相同Lixl comment
|
|
double dMinDiffAng = PI / 12.0; // 圆弧分割的角度
|
|
GetGlobalContext()->GetAt(KEY_MINDIFFANG, dMinDiffAng);
|
|
int nSect = int(PI / (2.0 * dMinDiffAng)) + 1; // 每PI/2圆弧分成的段数
|
|
dMinDiffAng = PI / (2.0 * nSect);
|
|
|
|
// 起始端圆分割点
|
|
AcGeVector3d vt = vtSect;
|
|
vt.rotateBy(PI / 2.0, vtNormal);
|
|
vt.normalize();
|
|
AcGePoint3dArray arCirPt;
|
|
AcGePoint3d ptCir;
|
|
ptCir = ptStart + vt * dStartWidth / 2.0;
|
|
arCirPt.append(ptCir);
|
|
for (int i = 1; i < 4 * nSect; i++)
|
|
{
|
|
ptCir.rotateBy(dMinDiffAng, vtSect, ptStart);
|
|
arCirPt.append(ptCir);
|
|
}
|
|
arCirPt.append(ptStart + vt * dStartWidth / 2.0); // 最后一个封闭，可消除计算误差
|
|
|
|
// 终止端矩形顶点
|
|
AcGePoint3dArray arRectPt;
|
|
arRectPt.append(ptEnd + dEndWidth * vt / 2.0 - dEndThick * vtNormal / 2.0);
|
|
arRectPt.append(arRectPt.at(0) + dEndThick * vtNormal);
|
|
arRectPt.append(arRectPt.at(1) - dEndWidth * vt);
|
|
arRectPt.append(arRectPt.at(0) - dEndWidth * vt);
|
|
arRectPt.append(arRectPt.at(0));
|
|
|
|
// 4*(nSect+1)+1行4列网格点
|
|
AcGePoint3dArray arPoint;
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
// 圆上点和矩形边
|
|
arPoint.append(arCirPt.at(i * nSect));
|
|
arPoint.append(arCirPt.at(i * nSect) - dPlusEdge * vtSect);
|
|
arPoint.append(arRectPt.at(i) + dPlusEdge * vtSect);
|
|
arPoint.append(arRectPt.at(i));
|
|
|
|
// 圆上边和矩形顶点
|
|
for (int j = 0; j < nSect; j++)
|
|
{
|
|
arPoint.append(arCirPt.at(i * nSect + j));
|
|
arPoint.append(arCirPt.at(i * nSect + j) - dPlusEdge * vtSect);
|
|
arPoint.append(arRectPt.at(i + 1) + dPlusEdge * vtSect);
|
|
arPoint.append(arRectPt.at(i + 1));
|
|
}
|
|
}
|
|
arPoint.append(arCirPt.at(0));
|
|
arPoint.append(arCirPt.at(0) - dPlusEdge * vtSect);
|
|
arPoint.append(arRectPt.at(0) + dPlusEdge * vtSect);
|
|
arPoint.append(arRectPt.at(0));
|
|
|
|
mode.DrawMesh(4 * (nSect + 1) + 1, 4, arPoint.asArrayPtr());
|
|
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcGeVector3d THImpHvacDeDustCover::GetNormal() const
|
|
{
|
|
ASSERT(NULL != m_pXDataMap);
|
|
AcGeVector3d vtNor;
|
|
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
|
return vtNor.normalize();
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::ExplodeOrDraw2d(XExplodeDraw &mode) const
|
|
{
|
|
if (m_pXDataMap == NULL)
|
|
return Acad::eNotImplementedYet;
|
|
|
|
BOOL bHasName = FALSE;
|
|
m_pXDataMap->GetAt(HEQU_HasText, bHasName);
|
|
|
|
if (bHasName)
|
|
{
|
|
CString sType(_T(""));
|
|
m_pXDataMap->GetAt(HEQU_SEquipName, sType);
|
|
AcGePoint3d ptInst = AcGePoint3d::kOrigin;
|
|
m_pXDataMap->GetAt(HEQU_TextPoint, ptInst);
|
|
AcGeVector3d vtMain = AcGeVector3d::kXAxis;
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
double dTextHeight = 3;
|
|
m_pXDataMap->GetAt(KEY_TextHeight, dTextHeight);
|
|
AcDbObjectId idLayer = AcDbObjectId::kNull;
|
|
m_pXDataMap->GetAt(KEY_EndLayer, idLayer);
|
|
|
|
// add by hh 2011-05-25 调整文字方向 避免出现颠倒的情况
|
|
double dAng = TAuxTools::GetUcsXvt().angleTo(vtMain, TAuxTools::GetUcsZvt());
|
|
if (dAng > PI / 2 && dAng <= PI + PI / 2){
|
|
vtMain.negate();
|
|
}
|
|
|
|
TDbText *pText = new TDbText;
|
|
pText->setPropertiesFrom(m_pOwnerEnt);
|
|
pText->SetText(sType);
|
|
|
|
AcDbObjectId idStyle = AcDbObjectId::kNull;
|
|
m_pXDataMap->GetAt(HDIM_DimTextId, idStyle);
|
|
pText->SetStyleId(idStyle);
|
|
|
|
pText->SetHeight(dTextHeight);
|
|
pText->SetLocation(ptInst);
|
|
pText->SetRotation(AcGeVector3d::kXAxis.angleTo(vtMain, AcGeVector3d::kZAxis));
|
|
pText->SetAlignment(XExplodeDraw::kMiddleCenter);
|
|
pText->setLayer(idLayer);//InitLayer(_T("TA-构件标注"))
|
|
|
|
BOOL bMask(FALSE);
|
|
m_pXDataMap->GetAt(HEQU_TextShadeBg, bMask);
|
|
pText->SetMaskFlag(bMask);
|
|
|
|
// 绘制文字
|
|
if (mode.IsFullExplode())
|
|
pText->ExplodeOrDraw2d(mode);
|
|
else
|
|
mode.DrawEntity(*pText);
|
|
|
|
delete pText;
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::InserBlockCen(XExplodeDraw &mode, AcDbObjectId idBlock) const
|
|
{
|
|
ASSERT(NULL != m_pXDataMap);
|
|
AcGeVector3d vtMain, vtScale, vtNor;
|
|
double dLength(1.0);
|
|
double dWidth(1.0);
|
|
double dThick(1.0);
|
|
AcGePoint3d ptCenter;
|
|
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
m_pXDataMap->GetAt(HEQU_Length, dLength);
|
|
m_pXDataMap->GetAt(HEQU_Width, dWidth);
|
|
m_pXDataMap->GetAt(HEQU_Thick, dThick);
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
m_pXDataMap->GetAt(HEQU_Scale, vtScale);
|
|
if (dThick < 1)
|
|
{
|
|
dThick = 1;
|
|
}
|
|
|
|
double dAngle(0.0);
|
|
|
|
dLength *= vtScale.x;
|
|
dWidth *= vtScale.y;
|
|
dThick *= vtScale.z;
|
|
dAngle = AcGeVector3d::kXAxis.angleTo(vtMain,vtNor);
|
|
//如果没有高度值，则高度比例置为1
|
|
if (vtScale.z == 1)
|
|
{
|
|
dThick = 1;
|
|
}
|
|
|
|
AcGeScale3d scale(dLength, dWidth, dThick);
|
|
|
|
AcDbObject *pObj;
|
|
XPoint xpoint = ptCenter;
|
|
if (acdbOpenObject(pObj, idBlock, AcDb::kForRead) != Acad::eOk)
|
|
return Acad::eNotImplementedYet;
|
|
AcDbBlockTableRecord *pBlock = AcDbBlockTableRecord::cast(pObj);
|
|
if (pBlock == NULL)
|
|
{
|
|
pObj->close();
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
mode.DrawBlock(*pBlock, xpoint, scale, dAngle, TRUE);
|
|
Acad::ErrorStatus es = pObj->close();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::InserBlockHand(XExplodeDraw &mode) const
|
|
{
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::Draw2dBox(XExplodeDraw &mode) const
|
|
{
|
|
AcGeVector3d vtNor;
|
|
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
|
AcGePoint3dArray arPts;
|
|
GetBoxPts(arPts);
|
|
double dEl;
|
|
AcGePlane plane = TAuxTools::GetHidePlane(arPts[1],arPts[2],arPts[3],vtNor,dEl);
|
|
AcDbPolyline polyLine;
|
|
polyLine.addVertexAt(0,arPts[1].convert2d(plane));
|
|
polyLine.addVertexAt(1,arPts[2].convert2d(plane));
|
|
polyLine.addVertexAt(2,arPts[3].convert2d(plane));
|
|
polyLine.addVertexAt(3,arPts[4].convert2d(plane));
|
|
mode.Polyline(polyLine);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 竖直放置
|
|
// 5 6
|
|
// ┃ ┃
|
|
// 1 ┃━━━━━┃ 2
|
|
// ┃ ┃
|
|
// ┃ 0 ┃
|
|
// ┃ ┃
|
|
// 4 ┃━━━━━┃ 3
|
|
// ┃ ┃
|
|
// 8 7
|
|
//
|
|
|
|
// 水平放置
|
|
// 6 |\ \
|
|
// | \ \
|
|
// | \ \ 3
|
|
// | \|2___1
|
|
// | 0 /|
|
|
// | / / 4
|
|
// | / /
|
|
// 5 |/ /
|
|
|
|
BOOL THImpHvacDeDustCover::GetBoxPts(AcGePoint3dArray &arPts) const
|
|
{
|
|
// 获取各点位置
|
|
|
|
AcGePoint3d ptCenter;
|
|
AcGeVector3d vtMain, vtNor, vtMainv;
|
|
double dLength(50.0), dWidth(50.0), dHeight(50.0);
|
|
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
m_pXDataMap->GetAt(HEQU_Length, dLength);
|
|
m_pXDataMap->GetAt(HEQU_Width, dWidth);
|
|
m_pXDataMap->GetAt(HEQU_Thick, dHeight);
|
|
dLength = fabs(dLength);
|
|
dWidth = fabs(dWidth);
|
|
dHeight = fabs(dHeight);
|
|
vtNor.normalize();
|
|
vtMain.normalize();
|
|
|
|
if (IsVertAlignment())
|
|
{
|
|
vtMainv = vtMain;
|
|
vtMainv.rotateBy(PI * 0.5, vtNor);
|
|
vtMain.normalize();
|
|
vtMainv.normalize();
|
|
//0
|
|
arPts.append(ptCenter);
|
|
AcGePoint3d pt;
|
|
pt = ptCenter - vtMain * dLength * 0.5;
|
|
pt = pt + vtMainv * dWidth * 0.5;
|
|
//1
|
|
arPts.append(pt);
|
|
//2
|
|
arPts.append(arPts[1] + vtMain * dLength);
|
|
//3
|
|
arPts.append(arPts[2] - vtMainv * dWidth);
|
|
//4
|
|
arPts.append(arPts[1] - vtMainv * dWidth);
|
|
|
|
return TRUE;
|
|
}
|
|
else if (IsHorzAligment())
|
|
{
|
|
// 接口MAP
|
|
TDbXDataMap ifmap;
|
|
if(!m_pXDataMap->GetAt(HEQU_Interface, 0, ifmap))
|
|
return FALSE;
|
|
|
|
AcDbDatabase* pDb = acdbCurDwg();
|
|
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
|
|
|
// 0 ptCenter为中心插入点
|
|
arPts.append(ptCenter);
|
|
|
|
// 1 启动风管命令点
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vtIf;
|
|
ifmap.GetAt(HEQUIF_Point, pt);
|
|
ifmap.GetAt(HEQUIF_Vector, vtIf);
|
|
arPts.append(pt + vtIf.normalize() * 100);
|
|
// 2 接口点,调整点
|
|
arPts.append(pt);
|
|
|
|
vtMainv = vtIf.normalize();
|
|
vtMainv.rotateBy(PI*0.5, vtZAxis);
|
|
|
|
double dIFWidth(0.0);
|
|
ifmap.GetAt(HEQUIF_Width, dIFWidth);
|
|
|
|
// 3 接口上方点
|
|
arPts.append(pt + vtMainv * dIFWidth * 0.5);
|
|
// 4 接口下方点
|
|
arPts.append(pt - vtMainv * dIFWidth * 0.5);
|
|
|
|
pt = ptCenter - vtIf * dHeight * 0.5;
|
|
// 5 除尘罩底部下方点
|
|
arPts.append(pt - vtMainv * dWidth * 0.5);
|
|
// 6 除尘罩底部上方点
|
|
arPts.append(pt + vtMainv * dWidth * 0.5);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void THImpHvacDeDustCover::list() const
|
|
{
|
|
if (m_pXDataMap != NULL)
|
|
{
|
|
AcGePoint3d ptCenter;
|
|
AcGeVector3d vtMain;
|
|
CString sType,sName,sParma;
|
|
double dLength(50.0), dThick(50.0), dWidth(50.0), dPlusEdge(50.0);
|
|
double daircap(0),drefri(0),dheatcap(0),dwtrRes(0);
|
|
TDbXDataMap mapparam;
|
|
m_pXDataMap->GetAt(HEQU_SEquipType, sType);
|
|
m_pXDataMap->GetAt(HEQU_SEquipName, sName);
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
m_pXDataMap->GetAt(HEQU_Length, dLength);
|
|
m_pXDataMap->GetAt(HEQU_Width, dWidth);
|
|
m_pXDataMap->GetAt(HEQU_Thick, dThick);
|
|
|
|
acutPrintf(_T("\t\t\t\t\t\t\t\t%s"),sType);
|
|
acutPrintf(_T("\n\t\t\t\t\t型号: %s"),sName);
|
|
//读出所有参数信息
|
|
m_pXDataMap->GetAt(HEQU_Parameter,0,mapparam);
|
|
TDbXDataMap::It it;
|
|
TXData xdata;
|
|
for(it = mapparam.Begin();it != mapparam.End();)
|
|
{
|
|
m_pXDataMap->GetAt(it->first, sParma);
|
|
mapparam.GetNext(it,xdata);
|
|
acutPrintf(_T("\n\t\t\t\t\t%s%s"),xdata.pszVal,sParma);
|
|
}
|
|
//几何参数信息
|
|
acutPrintf(_T("\n\t\t\t\t\t长度: %.0fmm"),fabs(dLength));
|
|
acutPrintf(_T("\n\t\t\t\t\t宽度: %.0fmm"),fabs(dWidth));
|
|
acutPrintf(_T("\n\t\t\t\t\t高度: %.0fmm"),fabs(dThick));
|
|
acutPrintf(_T("\n\t\t\t\t\t标高: %.0fm"),ptCenter.z * 0.001);
|
|
int icount(0);
|
|
m_pXDataMap->GetAt(HEQU_InterfaceNum, icount);
|
|
if (icount < 1)
|
|
{
|
|
acutPrintf(_T("\n\t\t\t\t\t接口:无"));
|
|
}
|
|
else
|
|
{
|
|
CString sIFName;
|
|
AcGeVector3d vt;
|
|
AcGePoint3d pt;
|
|
TDbXDataMap xdatamap;
|
|
double dw(0),dh(0),dangle(0);
|
|
for (int i = 0; i < icount; i++)
|
|
{
|
|
xdatamap.Empty();
|
|
m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
|
|
xdatamap.GetAt(HEQUIF_Name, sIFName);
|
|
xdatamap.GetAt(HEQUIF_Point, pt);
|
|
xdatamap.GetAt(HEQUIF_Vector, vt);
|
|
xdatamap.GetAt(HEQUIF_Width, dw);
|
|
xdatamap.GetAt(HEQUIF_Height, dh);
|
|
dangle = vt.angleTo(AcGeVector3d::kXAxis,AcGeVector3d::kZAxis) * 180 / PI;
|
|
acutPrintf(_T("\n\t\t\t\t\t接口: %d"),i);
|
|
acutPrintf(_T("\n\t\t\t\t\t接口名称: %s"),sIFName);
|
|
acutPrintf(_T("\n\t\t\t\t\t接口位置: (%.0f,%.0f,%.0f)"),pt.x,pt.y,pt.z);
|
|
acutPrintf(_T("\n\t\t\t\t\t接口方向: %.0f度"), dangle);
|
|
if (dh < 0)
|
|
{
|
|
acutPrintf(_T("\n\t\t\t\t\t接口直径: %.0fmm"), dw);
|
|
}
|
|
else
|
|
{
|
|
acutPrintf(_T("\n\t\t\t\t\t接口宽度: %.0fmm"), dw);
|
|
acutPrintf(_T("\n\t\t\t\t\t接口长度: %.0fmm"), dh);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::transformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return Acad::eNotApplicable;
|
|
// 取得位置点
|
|
AcGePoint3d ptCenter, ptText;
|
|
AcGeVector3d vtMain,vtNor;
|
|
double dL(1.0),dW(1.0),dT(1.0);
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
m_pXDataMap->GetAt(HEQU_TextPoint, ptText);
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
m_pXDataMap->GetAt(HEQU_Length, dL);
|
|
m_pXDataMap->GetAt(HEQU_Width, dW);
|
|
m_pXDataMap->GetAt(HEQU_Thick, dT);
|
|
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
|
|
|
AcGeVector3d vtPrep(vtNor.crossProduct(vtMain));
|
|
|
|
// AcGeVector3d vtSz(dL,dW,dT);
|
|
// vtSz.transformBy(xform);
|
|
|
|
// 变换位置
|
|
vtNor.transformBy(xform);
|
|
ptCenter.transformBy(xform);
|
|
ptText.transformBy(xform);
|
|
vtMain.transformBy(xform);
|
|
vtPrep.transformBy(xform);
|
|
|
|
// 同向是旋转，不变号，反向是镜像，变号。
|
|
int iSign = ((vtPrep.isCodirectionalTo(vtNor.crossProduct(vtMain))) ? 1 : -1);
|
|
SetInterFaceLocal(xform);
|
|
double dscale = xform.scale();
|
|
|
|
// 更新点
|
|
m_pXDataMap->SetAt(HVAC_Normal, vtNor);
|
|
double ddd = xform.norm();
|
|
m_pXDataMap->SetAt(HEQU_CenterPoint, ptCenter);
|
|
m_pXDataMap->SetAt(HEQU_TextPoint, ptText);
|
|
m_pXDataMap->SetAt(HEQU_MainDir, vtMain);
|
|
m_pXDataMap->SetAt(HEQU_Length, dL * dscale);
|
|
m_pXDataMap->SetAt(HEQU_Width, dW * dscale * iSign);//
|
|
m_pXDataMap->SetAt(HEQU_Thick, dT * dscale);
|
|
|
|
// 传递消息
|
|
if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
|
|
{
|
|
// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
|
|
AcDbDatabase* pDb = m_pOwnerEnt->database();
|
|
if (pDb == NULL) pDb = acdbCurDwg();
|
|
|
|
AcDbObjectId idModel;
|
|
AcDbBlockTable* pTable = NULL;
|
|
pDb->getBlockTable(pTable, AcDb::kForRead);
|
|
if (pTable != NULL)
|
|
{
|
|
pTable->getAt(ACDB_MODEL_SPACE, idModel);
|
|
pTable->close();
|
|
}
|
|
|
|
// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
|
|
if (idModel == m_pOwnerEnt->blockId())
|
|
{
|
|
// 写入接口更改消息
|
|
TInterfaceModifyMsg iMsg;
|
|
iMsg.SetInterfaceOper(TDb::eTransformBy);
|
|
iMsg.SetMsgValidate(TRUE);
|
|
iMsg.SetTransform(xform);
|
|
iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
|
|
|
|
TDbInterfaceMsgWrite msgWrite;
|
|
msgWrite.WriteInterfaceMsg(iMsg);
|
|
|
|
//更新接口记录接口信息
|
|
UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::getStretchPoints(AcGePoint3dArray& stretchPoints) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return Acad::eNotApplicable;
|
|
|
|
// 取得位置点
|
|
AcGePoint3d ptCenter;
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
|
|
stretchPoints.append(ptCenter);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::moveStretchPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
return moveGripPointsAt(indices,offset);
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::moveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
ASSERT(NULL != m_pXDataMap);
|
|
|
|
int nSize = indices.length();
|
|
if (nSize > 0)
|
|
{
|
|
// 取得位置点
|
|
AcGePoint3d ptCenter;
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
AcGeVector3d vtMain,vtMainv;
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
// 选择多个夹点,以first为准
|
|
int nIndex = indices.first();
|
|
TDb::Position ePos = ExplainGripIndex(nIndex);
|
|
switch(ePos)
|
|
{
|
|
case TDb::eMid:
|
|
{
|
|
TDb::InterfaceOper eOper = TDb::eMoveGripPoint;
|
|
AcGeVector3d vtMove = offset;
|
|
|
|
ptCenter += vtMove;
|
|
m_pXDataMap->SetAt(HEQU_CenterPoint, ptCenter);
|
|
|
|
// mcl add 2011.2.17 移动时，标注也移动
|
|
AcGePoint3d ptText;
|
|
m_pXDataMap->GetAt(HEQU_TextPoint, ptText);
|
|
ptText += vtMove;
|
|
m_pXDataMap->SetAt(HEQU_TextPoint, ptText);
|
|
|
|
//更改接口位置
|
|
AcGeMatrix3d maxvt;
|
|
maxvt.setToTranslation(vtMove);
|
|
SetInterFaceLocal(maxvt);
|
|
|
|
if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
|
|
{
|
|
if (TAuxTools::IsEquipAutoMove(this, vtMove))
|
|
{
|
|
// 写入接口更改消息
|
|
TInterfaceModifyMsg iMsg;
|
|
iMsg.SetMsgPoint(ptCenter);//new pos
|
|
iMsg.SetGripPosition(TDb::eMid);
|
|
iMsg.SetMoveGripOffset(vtMove);
|
|
if (eOper == TDb::eTransformBy)
|
|
iMsg.SetTransform(vtMove);
|
|
iMsg.SetMsgValidate(TRUE);
|
|
iMsg.SetInterfaceOper(eOper);
|
|
iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
|
|
TDbInterfaceMsgWrite msgWrite;
|
|
msgWrite.WriteInterfaceMsg(iMsg);
|
|
}
|
|
|
|
//更新接口记录接口信息
|
|
AcGeMatrix3d xform;
|
|
xform.setToTranslation(vtMove);
|
|
UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform);
|
|
}
|
|
break;
|
|
}
|
|
case TDb::eCommand0:
|
|
{
|
|
nIndex -= 1;
|
|
AcGePoint3d ptCom;
|
|
GetInterFaceLocal(nIndex, ptCom);
|
|
if (GetKeyState(VK_MENU) < 0)
|
|
{
|
|
TDbXDataMap xdatamap;
|
|
m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap);
|
|
ptCom += offset;
|
|
xdatamap.SetAt(HEQUIF_Point, ptCom);
|
|
m_pXDataMap->SetAt(HEQU_Interface, nIndex, xdatamap);
|
|
//GetInterfaceFromXdata(nIndex, offset);
|
|
break;
|
|
}
|
|
// 获得夹点命令
|
|
else
|
|
{
|
|
CString sCmdStr;
|
|
int nType(0);
|
|
GetInterFaceLocal(nIndex, nType);
|
|
switch(nType)
|
|
{
|
|
case 0:
|
|
GetGlobalContext()->GetAt(KEY_HVACCOLDGRIPCMD, sCmdStr);
|
|
break;
|
|
case 1:
|
|
case 2:
|
|
GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, sCmdStr);
|
|
break;
|
|
case 3:
|
|
GetGlobalContext()->GetAt(KEY_HVACHEATGRIPCMD, sCmdStr);
|
|
break;
|
|
case 4:
|
|
GetGlobalContext()->GetAt(KEY_HVACMEDIAGRIPCMD, sCmdStr);
|
|
break;
|
|
case 5:
|
|
GetGlobalContext()->GetAt(KEY_HVACFJSQGRIPCMD, sCmdStr);
|
|
break;
|
|
}
|
|
if (sCmdStr.IsEmpty())
|
|
return Acad::eNotApplicable;
|
|
TInterface pipeInterface;
|
|
GetInterface(ptCom, pipeInterface );
|
|
|
|
double dw,dh;
|
|
GetInterFaceLocal(nIndex, dw,dh);
|
|
// 写入接口更改消息
|
|
TInterfaceModifyMsg iMsg;
|
|
iMsg.SetMsgPoint(ptCom);//new pos
|
|
iMsg.SetGripPosition(ePos);
|
|
iMsg.SetMoveGripOffset(offset);
|
|
iMsg.SetMsgValidate(TRUE);
|
|
iMsg.SetInterfaceOper(TDb::eNewCommand);
|
|
iMsg.SetPreviewObjToCreate(TDb::eDeDustCover, 0);
|
|
|
|
AcDbSoftPointerId idOwner;
|
|
m_pXDataMap->GetAt(KEY_THISID,idOwner);
|
|
iMsg.SetMsgOperateOn(idOwner);
|
|
TDbInterfaceMsgWrite msgWrite;
|
|
msgWrite.WriteInterfaceMsg(iMsg);
|
|
|
|
// 发送消息
|
|
acedPostCommand(_T("\33"));
|
|
acedPostCommand(sCmdStr + _T("\n"));
|
|
break;
|
|
}
|
|
|
|
}
|
|
case TDb::eStart:
|
|
{
|
|
AcGePoint3d ptText;
|
|
m_pXDataMap->GetAt(HEQU_TextPoint, ptText);
|
|
ptText += offset;
|
|
m_pXDataMap->SetAt(HEQU_TextPoint, ptText);
|
|
break;
|
|
}
|
|
case TDb::eAdjust0:
|
|
{
|
|
AcGePoint3d ptIf;
|
|
TDbXDataMap xdatamap;
|
|
if (GetInterFaceLocal(0, ptIf) && m_pXDataMap->GetAt(HEQU_Interface, 0, xdatamap))
|
|
{
|
|
TDb::HvacDeDustCoverType eDeType = TDb::eCenterInterface;
|
|
m_pXDataMap->GetAt(HDED_TYPE, (int&)eDeType);
|
|
if (eDeType == TDb::eCenterInterface
|
|
|| eDeType == TDb::eSideInterface)
|
|
{
|
|
ptIf += offset;
|
|
}
|
|
else
|
|
{
|
|
// 侧吸式吸尘罩,调整时,3种形式,中心,向上偏心,向下偏心Lixl add 2012-5-10
|
|
AcGeVector3d vtIf;
|
|
double dIfWidth(50.0), dIfHeight(50.0), dHeight(0.0), dWidth(0.0);
|
|
if (GetInterFaceLocal(0, vtIf) && GetInterFaceLocal(0, dIfWidth, dIfHeight))
|
|
{
|
|
AcDbDatabase* pDb = acdbCurDwg();
|
|
AcGeVector3d vtNor = pDb->ucsxdir().crossProduct(pDb->ucsydir());
|
|
|
|
m_pXDataMap->GetAt(HEQU_Thick, dHeight);
|
|
m_pXDataMap->GetAt(HEQU_Width, dWidth);
|
|
|
|
AcGePoint3d ptEnd = ptCenter + vtIf.normalize() * dHeight * 0.5;
|
|
|
|
AcGeVector3d vtIfv = vtIf;
|
|
vtIfv.rotateBy(PI*0.5, vtNor);
|
|
AcGePoint3d pt1 = ptEnd + vtIfv * dWidth * 0.5;
|
|
AcGePoint3d pt2 = ptEnd - vtIfv * dWidth * 0.5;
|
|
AcGePoint3d pt3 = ptEnd;
|
|
|
|
AcGePoint3d ptNow = ptIf + offset;
|
|
|
|
if (ptNow.distanceTo(pt1) < ptNow.distanceTo(pt2)
|
|
&& ptNow.distanceTo(pt1) < ptNow.distanceTo(pt3))
|
|
{
|
|
ptIf = pt1 - vtIfv * dIfWidth * 0.5;
|
|
}
|
|
else if (ptNow.distanceTo(pt2) < ptNow.distanceTo(pt1)
|
|
&& ptNow.distanceTo(pt2) < ptNow.distanceTo(pt3))
|
|
{
|
|
ptIf = pt2 + vtIfv * dIfWidth * 0.5;
|
|
}
|
|
else
|
|
{
|
|
ptIf = pt3;
|
|
}
|
|
}
|
|
}
|
|
|
|
xdatamap.SetAt(HEQUIF_Point, ptIf);
|
|
m_pXDataMap->SetAt(HEQU_Interface, 0, xdatamap);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::intersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
const AcGePlane& projPlane,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::intersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::getOsnapPoints(AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& pickPoint,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return Acad::eNotApplicable;
|
|
AcGePoint3d ptCenter;
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
AcGePoint3dArray arpts;
|
|
|
|
// 根据捕捉模式处理
|
|
switch(osnapMode)
|
|
{
|
|
case AcDb::kOsModeEnd:
|
|
GetInterFaceLocal(arpts);
|
|
GetFourConer(arpts);
|
|
snapPoints.append(arpts);
|
|
break;
|
|
case AcDb::kOsModeMid:
|
|
snapPoints.append(ptCenter);
|
|
break;
|
|
case AcDb::kOsModeCen:
|
|
break;
|
|
case AcDb::kOsModePerp:
|
|
break;
|
|
case AcDb::kOsModeNear:
|
|
break;
|
|
}
|
|
// add by hh 2011-07-12 支持任意位置捕捉
|
|
TComplexCurve cplCurve;
|
|
MakeCurves(cplCurve);
|
|
GetCurvesInSide(cplCurve);
|
|
int nLen = cplCurve.length();
|
|
if(0 != nLen)
|
|
{
|
|
AcDbLine line;
|
|
AcDbArc arc;
|
|
TDb::TCurveElement curElem;
|
|
for(int i = 0; i < cplCurve.length(); i++)
|
|
{
|
|
curElem = cplCurve[i];
|
|
if(curElem.ptGe[1] == curElem.ptGe[2])
|
|
{
|
|
line.setStartPoint(curElem.ptGe[0]);
|
|
line.setEndPoint(curElem.ptGe[1]);
|
|
line.getOsnapPoints(osnapMode, gsSelectionMark, pickPoint,
|
|
lastPoint, viewXform, snapPoints, geomIds);
|
|
}
|
|
else
|
|
{
|
|
AcGeCircArc3d arcCalc(curElem.ptGe[0], curElem.ptGe[1], curElem.ptGe[2]);
|
|
AcGePoint3d ptCent = arcCalc.center();
|
|
arc.setCenter(ptCent);
|
|
arc.setRadius(arcCalc.radius());
|
|
arc.setStartAngle(acutAngle(XPoint(ptCent), XPoint(curElem.ptGe[0])));
|
|
arc.setEndAngle(acutAngle(XPoint(ptCent), XPoint(curElem.ptGe[2])));
|
|
arc.getOsnapPoints(osnapMode, gsSelectionMark, pickPoint,
|
|
lastPoint, viewXform, snapPoints, geomIds);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::getGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return Acad::eNotApplicable;
|
|
|
|
// 取得位置点
|
|
AcGePoint3d ptCenter;
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
|
|
if (IsVertAlignment())
|
|
{
|
|
gripPoints.append(ptCenter); // 中心点
|
|
|
|
double dDia(0), dTemp(0);
|
|
GetInterFaceLocal(0, dDia, dTemp);
|
|
AcGeVector3d vtOffset;
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtOffset);
|
|
vtOffset.rotateBy(-PI*0.5, GetNormal());
|
|
vtOffset *= dDia * 0.5;
|
|
AcGePoint3dArray arpts;
|
|
if (GetInterFaceLocal(arpts))
|
|
{
|
|
if (arpts.length() > 0)
|
|
gripPoints.append(arpts[0] - vtOffset);
|
|
}
|
|
|
|
// 移动接口位置点
|
|
AcGePoint3d ptMove;
|
|
GetInterFaceLocal(0, ptMove);
|
|
ptMove += vtOffset;
|
|
gripPoints.append(ptMove);
|
|
|
|
GetFourConer(gripPoints);// 四角点
|
|
}
|
|
else if (IsHorzAligment())
|
|
{
|
|
AcGePoint3dArray arpts;
|
|
if (!GetBoxPts(arpts))
|
|
return Acad::eNotApplicable;
|
|
if (arpts.length() != 7)
|
|
return Acad::eNotApplicable;
|
|
|
|
gripPoints.append(arpts);
|
|
}
|
|
|
|
BOOL bHasText = FALSE;
|
|
m_pXDataMap->GetAt(HEQU_HasText, bHasText);
|
|
if (bHasText)
|
|
{
|
|
m_pXDataMap->GetAt(HEQU_TextPoint, ptCenter);
|
|
gripPoints.append(ptCenter);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::GetInterFaceLocal(AcGePoint3dArray& arpts) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
arpts.setLogicalLength(0);
|
|
TDbXDataMap xdatamap;
|
|
int iIfNum(0);
|
|
AcGePoint3d ptInter;
|
|
arpts.setLogicalLength(0);
|
|
m_pXDataMap->GetAt(HEQU_InterfaceNum, iIfNum);
|
|
for (int i = 0; i < iIfNum; i++)
|
|
{
|
|
xdatamap.Empty();
|
|
m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
|
|
if (xdatamap.GetAt(HEQUIF_Point, ptInter))
|
|
arpts.append(ptInter);
|
|
}
|
|
return arpts.length() > 0;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::SetInterFaceLocal(const AcGeMatrix3d& xform) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
int icount(0);
|
|
m_pXDataMap->GetAt(HEQU_InterfaceNum, icount);
|
|
TDbXDataMap xdatamap;
|
|
|
|
CString sName;
|
|
AcGeVector3d vt;
|
|
AcGePoint3d pt;
|
|
for (int i = 0; i < icount; i++)
|
|
{
|
|
xdatamap.Empty();
|
|
m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
|
|
xdatamap.GetAt(HEQUIF_Point, pt);
|
|
xdatamap.GetAt(HEQUIF_Vector, vt);
|
|
pt.transformBy(xform);
|
|
vt.transformBy(xform);
|
|
xdatamap.SetAt(HEQUIF_Point, pt);
|
|
xdatamap.SetAt(HEQUIF_Vector, vt);
|
|
m_pXDataMap->SetAt(HEQU_Interface, i, xdatamap);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::SetInterFaceLocal(const AcGeScale3d& scale3d) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
int icount(0);
|
|
m_pXDataMap->GetAt(HEQU_InterfaceNum, icount);
|
|
|
|
TDbXDataMap xdatamap;
|
|
CString sName;
|
|
AcGeVector3d vt;
|
|
AcGePoint3d pt;
|
|
for (int i = 0; i < icount; i++)
|
|
{
|
|
xdatamap.Empty();
|
|
m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
|
|
xdatamap.GetAt(HEQUIF_Point, pt);
|
|
xdatamap.GetAt(HEQUIF_Vector, vt);
|
|
pt.x *= scale3d.sy;
|
|
pt.y *= scale3d.sx;
|
|
pt.z *= scale3d.sz;
|
|
vt.x *= scale3d.sy;
|
|
vt.y *= scale3d.sx;
|
|
vt.z *= scale3d.sz;
|
|
vt.normalize();
|
|
xdatamap.SetAt(HEQUIF_Point, pt);
|
|
xdatamap.SetAt(HEQUIF_Vector, vt);
|
|
m_pXDataMap->SetAt(HEQU_Interface, i, xdatamap);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// 吸尘罩接口尺寸按定义位置，取自身高度为标高
|
|
BOOL THImpHvacDeDustCover::GetInterFaceLocal(int nIndex, AcGePoint3d &pt) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
|
|
TDbXDataMap xdatamap;
|
|
if(m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap))
|
|
{
|
|
return xdatamap.GetAt(HEQUIF_Point, pt);
|
|
}
|
|
else
|
|
{
|
|
BOOL bOk = m_pXDataMap->GetAt(HEQU_CenterPoint, pt);
|
|
if (bOk)
|
|
{
|
|
double dHeigh(0.0);
|
|
m_pXDataMap->GetAt(HEQU_Thick, dHeigh);
|
|
pt += dHeigh * normal();
|
|
}
|
|
return bOk;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::GetInterFaceLocal(int nIndex, int &nType) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
TDbXDataMap xdatamap;
|
|
if(m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap))
|
|
return xdatamap.GetAt(HEQUIF_Type, nType);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::GetInterFaceLocal(int nIndex, AcGeVector3d &vt) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
TDbXDataMap xdatamap;
|
|
if(m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap))
|
|
return xdatamap.GetAt(HEQUIF_Vector, vt);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::GetInterFaceLocal(int nIndex, CString &sName) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
TDbXDataMap xdatamap;
|
|
if(m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap))
|
|
return xdatamap.GetAt(HEQUIF_Name, sName);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::GetInterFaceLocal(int nIndex, double &dWidth, double &dHeight) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
TDbXDataMap xdatamap;
|
|
double nw(0.0), nh(0.0);
|
|
if(m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap))
|
|
{
|
|
xdatamap.GetAt(HEQUIF_Width, nw);
|
|
xdatamap.GetAt(HEQUIF_Height, nh);
|
|
dWidth = nw;
|
|
dHeight = nh;
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::GetIFIndexFormPt(int &nIndex, const AcGePoint3d &pt) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return FALSE;
|
|
TDbXDataMap xdatamap;
|
|
int iIfNum(0);
|
|
m_pXDataMap->GetAt(HEQU_InterfaceNum, iIfNum);
|
|
AcGePoint3d ptIF;
|
|
for (int i = 0; i < iIfNum; i++)
|
|
{
|
|
xdatamap.Empty();
|
|
m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
|
|
xdatamap.GetAt(HEQUIF_Point, ptIF);
|
|
if(ptIF.distanceTo(pt) < 3.e-1) //将接口判断连接精度由1.e-3改为3.e-1
|
|
{
|
|
//第一接口为设备位置点，所以需要+1
|
|
nIndex = i;
|
|
return TRUE;
|
|
}
|
|
}
|
|
nIndex = -1;
|
|
return FALSE;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::getGeomExtents(AcDbExtents& extents) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::getClassID(CLSID* pClsid) const
|
|
{
|
|
// #if (ADS < 16)
|
|
// // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E8}
|
|
// CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE8 }};
|
|
// #endif
|
|
//
|
|
// #if (ADS == 16)
|
|
// // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E9}
|
|
// CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE9 }};
|
|
// #endif
|
|
//
|
|
// #if (ADS == 17)
|
|
// // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6EA}
|
|
// CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xEA }};
|
|
// #endif
|
|
//
|
|
// #if (ADS == 18)
|
|
// CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xEB }};
|
|
// #endif
|
|
//
|
|
// #if (ADS == 19)
|
|
// CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xEB }};
|
|
// #endif
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus THImpHvacDeDustCover::explode(AcDbVoidPtrArray& entitySet) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::OPMInfo(LPCTSTR pszName, TDb::OPMInfo* pInfo)
|
|
{
|
|
ASSERT(NULL != pszName && NULL != pInfo && NULL != m_pXDataMap);
|
|
// 暖通基本参数设置
|
|
if (0 == _tcsicmp(pszName, KEY_RUNTIME))
|
|
{
|
|
pInfo->bVisible = TRUE;
|
|
pInfo->bEditable = FALSE;
|
|
|
|
// 提供数据列表和对应关系
|
|
if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
|
|
{
|
|
pInfo->parsValues->Add(_T("阀门"));
|
|
pInfo->parlValues->Add(TDb::eValve);
|
|
pInfo->parsValues->Add(_T("吸尘罩"));
|
|
pInfo->parlValues->Add(TDb::eDeDustCover);
|
|
pInfo->parsValues->Add(_T("风口"));
|
|
pInfo->parlValues->Add(TDb::eAirlets);
|
|
pInfo->parsValues->Add(_T("风机"));
|
|
pInfo->parlValues->Add(TDb::eFan);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if (0 == _tcsicmp(pszName, KEY_Name))
|
|
{
|
|
pInfo->bVisible = TRUE;
|
|
pInfo->bEditable = FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
if (0 == _tcsicmp(pszName, KEY_Model))
|
|
{
|
|
pInfo->bVisible = TRUE;
|
|
pInfo->bEditable = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
if (0 == _tcsicmp(pszName, KEY_StartPoint))
|
|
{
|
|
pInfo->bVisible = TRUE;
|
|
pInfo->bEditable = TRUE;
|
|
|
|
// 整体移动
|
|
if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt)
|
|
{
|
|
// 改变顶点变换行为
|
|
AcGePoint3d pt;
|
|
m_pXDataMap->GetAt(KEY_StartPoint, pt);
|
|
AcGeVector3d offset = asPnt3d(pInfo->pXData->dVal) - pt;
|
|
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(offset);
|
|
transformBy(mat);
|
|
pInfo->pXData->nVt = 0; // 设置处理完成标识
|
|
//TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if (0 == _tcsicmp(pszName, KEY_Length))
|
|
{
|
|
pInfo->bVisible = TRUE;
|
|
pInfo->bEditable = TRUE;
|
|
// 替代属性，需要特殊处理数据获取和设置
|
|
if (NULL != pInfo->pXData)
|
|
{
|
|
// 获取数据
|
|
if (0 == pInfo->pXData->nVt)
|
|
{
|
|
m_pXDataMap->GetAt(KEY_Length, *pInfo->pXData);
|
|
}
|
|
// 设置数据
|
|
else
|
|
{
|
|
double dLength(1.0);
|
|
m_pXDataMap->GetAt(KEY_Length, dLength);
|
|
AcGePoint3d pt;
|
|
m_pXDataMap->GetAt(KEY_StartPoint, pt);
|
|
|
|
if (fabs(dLength) < 1e-6)
|
|
{
|
|
m_pXDataMap->SetAt(KEY_Length, pInfo->pXData->dVal[0]);
|
|
return TRUE;
|
|
}
|
|
|
|
double dtmpVal = pInfo->pXData->dVal[0];
|
|
if (fabs(dtmpVal) < 1e-6)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
AcGeMatrix3d mat;
|
|
mat.setToScaling(pInfo->pXData->dVal[0] / dLength, pt);
|
|
transformBy(mat);
|
|
pInfo->pXData->nVt = 0; // 设置处理完成标识
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if (0 == _tcsicmp(pszName, KEY_Width))
|
|
{
|
|
pInfo->bVisible = TRUE;
|
|
pInfo->bEditable = TRUE;
|
|
// 替代属性，需要特殊处理数据获取和设置
|
|
if (NULL != pInfo->pXData)
|
|
{
|
|
// 获取数据
|
|
if (0 == pInfo->pXData->nVt)
|
|
{
|
|
m_pXDataMap->GetAt(KEY_Width, *pInfo->pXData);
|
|
pInfo->pXData->dVal[0] = fabs(pInfo->pXData->dVal[0]);
|
|
}
|
|
// 设置数据
|
|
else
|
|
{
|
|
double dLength(1.0);
|
|
m_pXDataMap->GetAt(KEY_Width, dLength);
|
|
AcGePoint3d pt;
|
|
m_pXDataMap->GetAt(KEY_StartPoint, pt);
|
|
|
|
if (fabs(dLength) < 1e-6)
|
|
{
|
|
m_pXDataMap->SetAt(KEY_Width, pInfo->pXData->dVal[0]);
|
|
return TRUE;
|
|
}
|
|
double dtmpVal = pInfo->pXData->dVal[0];
|
|
if (fabs(dtmpVal) < 1e-6)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
AcGeMatrix3d mat;
|
|
mat.setToScaling(fabs(pInfo->pXData->dVal[0] / dLength), pt);
|
|
transformBy(mat);
|
|
pInfo->pXData->nVt = 0; // 设置处理完成标识
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if (0 == _tcsicmp(pszName, KEY_TextHeight))
|
|
{
|
|
pInfo->bVisible = TRUE;
|
|
pInfo->bEditable = TRUE;
|
|
|
|
if (NULL != pInfo->pXData)
|
|
{
|
|
// 获取数据
|
|
if (0 == pInfo->pXData->nVt)
|
|
{
|
|
m_pXDataMap->GetAt(KEY_TextHeight, *pInfo->pXData);
|
|
}
|
|
// 设置数据
|
|
else
|
|
{
|
|
m_pXDataMap->SetAt(KEY_TextHeight, pInfo->pXData->dVal[0]);
|
|
pInfo->pXData->nVt = 0; // 设置处理完成标识
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if (0 == _tcsicmp(pszName, KEY_Thick))
|
|
{
|
|
pInfo->bVisible = TRUE;
|
|
pInfo->bEditable = TRUE;
|
|
// 替代属性，需要特殊处理数据获取和设置
|
|
if (NULL != pInfo->pXData)
|
|
{
|
|
// 获取数据
|
|
if (0 == pInfo->pXData->nVt)
|
|
{
|
|
m_pXDataMap->GetAt(KEY_Thick, *pInfo->pXData);
|
|
}
|
|
// 设置数据
|
|
else
|
|
{
|
|
double dLength(1.0);
|
|
m_pXDataMap->GetAt(KEY_Thick, dLength);
|
|
AcGePoint3d pt;
|
|
m_pXDataMap->GetAt(KEY_StartPoint, pt);
|
|
|
|
if (fabs(dLength) < 1e-6)
|
|
{
|
|
m_pXDataMap->SetAt(KEY_Thick, pInfo->pXData->dVal[0]);
|
|
return TRUE;
|
|
}
|
|
double dtmpVal = pInfo->pXData->dVal[0];
|
|
if (fabs(dtmpVal) < 1e-6)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
AcGeMatrix3d mat;
|
|
mat.setToScaling(pInfo->pXData->dVal[0] / dLength, pt);
|
|
transformBy(mat);
|
|
pInfo->pXData->nVt = 0; // 设置处理完成标识
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// 多联机样式 为了注册列表名，保证其他管件能用到此参数
|
|
if (0 == _tcsicmp(pszName, HVRV_IType))
|
|
{
|
|
pInfo->bVisible = FALSE;
|
|
pInfo->bEditable = FALSE;
|
|
|
|
// 提供数据列表和对应关系
|
|
if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
|
|
{
|
|
pInfo->parlValues->Add(0);
|
|
pInfo->parsValues->Add(_T("室内机"));
|
|
pInfo->parlValues->Add(1);
|
|
pInfo->parsValues->Add(_T("室外机"));
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL THImpHvacDeDustCover::GetInterfaceFromXdata(const int& nIndex, const AcGeVector3d& vtOff) const
|
|
{
|
|
ASSERT(NULL != m_pXDataMap);
|
|
|
|
AcDbObjectId id2d(AcDbObjectId::kNull);
|
|
AcGeVector3d Scale3d;
|
|
m_pXDataMap->GetAt(HEQU_PartCenter,id2d);
|
|
m_pXDataMap->GetAt(HEQU_Scale,Scale3d);
|
|
AcDbBlockTableRecord *pObj;
|
|
if (acdbOpenObject(pObj, id2d, AcDb::kForRead)!=Acad::eOk)
|
|
{
|
|
AfxMessageBox(_T("打开图形失败！"));
|
|
return FALSE;
|
|
}
|
|
if (pObj == NULL)
|
|
return FALSE;
|
|
AcDbBlockTableRecordIterator* pIT = NULL;
|
|
pObj->newIterator(pIT);
|
|
AcDbEntity* pEnt = NULL;
|
|
resbuf *pXData = NULL;
|
|
for (pIT->start(); !pIT->done(); pIT->step())
|
|
{
|
|
pIT->getEntity(pEnt, AcDb::kForRead);
|
|
if (NULL == pEnt)
|
|
return FALSE;
|
|
pXData = pEnt->xData(_T("THLAYEQUIP_IF"));
|
|
if (pXData != NULL)
|
|
break;
|
|
}
|
|
pObj->close();
|
|
delete pIT;
|
|
if (pEnt != NULL)
|
|
pEnt->close();
|
|
AcGePoint3d pt;
|
|
int nIfNum(0);
|
|
if (pXData != NULL)
|
|
{
|
|
resbuf* pRb = pXData;
|
|
pRb = pRb->rbnext;
|
|
if (NULL != pRb && pRb->restype == 1070 )
|
|
nIfNum = pRb->resval.rint;
|
|
for (int i = 0; i < nIfNum; i++)
|
|
{
|
|
pRb = pRb->rbnext;
|
|
pRb = pRb->rbnext;
|
|
if (NULL != pRb && pRb->restype == 1011 )
|
|
{
|
|
pt[0] = pRb->resval.rpoint[0];
|
|
pt[1] = pRb->resval.rpoint[1];
|
|
pt[2] = 0;
|
|
}
|
|
pRb = pRb->rbnext;
|
|
if (i == nIndex - 1)
|
|
break;
|
|
}
|
|
acutRelRb(pXData);
|
|
}
|
|
OPENOBJ_BEGIN(id2d,AcDb::kForWrite,AcDbBlockTableRecord,pblk);
|
|
if (pblk == NULL)
|
|
return FALSE;
|
|
pblk->newIterator(pIT);
|
|
pEnt = NULL;
|
|
for (; !pIT->done(); pIT->step())
|
|
{
|
|
pIT->getEntity(pEnt, AcDb::kForWrite);
|
|
if (pEnt == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
AcDbLine *pLine = AcDbLine::cast(pEnt);
|
|
if (pLine == NULL)
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
int nCor = pLine->colorIndex();
|
|
double ddis = pLine->startPoint().distanceTo(pLine->endPoint());
|
|
double ddisStr = pLine->startPoint().distanceTo(pt);
|
|
double ddisEnd = pLine->endPoint().distanceTo(pt);
|
|
//颜色是3长度是98
|
|
if (nCor == 3 && fabs(ddis - 98) < 1.e-3)
|
|
{
|
|
if (ddisStr < 1 || ddisEnd < 1)
|
|
{
|
|
AcGeMatrix3d mtx;
|
|
Scale3d.x *= vtOff.x;
|
|
Scale3d.y *= vtOff.y;
|
|
Scale3d.z = 0;
|
|
mtx.setTranslation(Scale3d);
|
|
pLine->transformBy(mtx);
|
|
pEnt->close();
|
|
return TRUE;
|
|
}
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
return FALSE;
|
|
}
|
|
|
|
int THImpHvacDeDustCover::GetXBaseShell(TXShell& xShell)
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// 获得参数
|
|
double dWidth = 0.0;
|
|
m_pXDataMap->GetAt(HEQU_Width, dWidth);
|
|
double dThick = 0.0;
|
|
m_pXDataMap->GetAt(HEQU_Length, dThick);
|
|
double dLength = 0.0;
|
|
m_pXDataMap->GetAt(HEQU_Thick, dLength);
|
|
AcGeVector3d vtNormal;
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtNormal);
|
|
vtNormal.normalize();
|
|
AcGeVector3d vt;
|
|
m_pXDataMap->GetAt(HVAC_Normal, vt);
|
|
vt.normalize();
|
|
AcGePoint3d ptStart;
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptStart);
|
|
AcGePoint3d ptEnd = ptStart + vt * dLength;
|
|
|
|
// 构造碰撞实体
|
|
TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dWidth, dThick, dWidth, dThick, xShell);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int THImpHvacDeDustCover::GetBodyBox(AcDbExtents& ext) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// 获得参数
|
|
double dWidth = 0.0;
|
|
m_pXDataMap->GetAt(HEQU_Width, dWidth);
|
|
double dHalfWidth = dWidth / 2.0;
|
|
double dThick = 0.0;
|
|
m_pXDataMap->GetAt(HEQU_Length, dThick);
|
|
double dHalfThick = dThick / 2.0;
|
|
double dLength = 0.0;
|
|
m_pXDataMap->GetAt(HEQU_Thick, dLength);
|
|
AcGeVector3d vtNormal;
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtNormal);
|
|
vtNormal.normalize();
|
|
AcGeVector3d vt;
|
|
m_pXDataMap->GetAt(HVAC_Normal, vt);
|
|
vt.normalize();
|
|
AcGePoint3d ptStart;
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptStart);
|
|
AcGePoint3d ptEnd = ptStart + vt * dLength;
|
|
AcGeVector3d vtSide = vt;
|
|
vtSide.rotateBy(PI / 2.0, vtNormal);
|
|
vtSide.normalize();
|
|
|
|
// 计算端点
|
|
AcGePoint3dArray arpt;
|
|
arpt.append(ptStart + vtSide * dHalfWidth + vtNormal * dHalfThick);
|
|
arpt.append(ptStart + vtSide * dHalfWidth - vtNormal * dHalfThick);
|
|
arpt.append(ptStart - vtSide * dHalfWidth - vtNormal * dHalfThick);
|
|
arpt.append(ptStart - vtSide * dHalfWidth + vtNormal * dHalfThick);
|
|
arpt.append(ptEnd + vtSide * dHalfWidth + vtNormal * dHalfThick);
|
|
arpt.append(ptEnd + vtSide * dHalfWidth - vtNormal * dHalfThick);
|
|
arpt.append(ptEnd - vtSide * dHalfWidth - vtNormal * dHalfThick);
|
|
arpt.append(ptEnd - vtSide * dHalfWidth + vtNormal * dHalfThick);
|
|
|
|
// 构造最小包含体
|
|
TAuxTools::BuildMinRectangle(arpt, ext);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// 按尺寸获取四角点，增加控制夹点用于捕捉定位，不会清空原arrPt
|
|
void THImpHvacDeDustCover::GetFourConer( AcGePoint3dArray &arrPt ) const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return;
|
|
|
|
AcGePoint3d ptCenter;
|
|
AcGeVector3d vtMain, vtPerl, vtNormal;
|
|
double dLen(1.0), dWidth(1.0);
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
|
|
vtPerl = vtMain.crossProduct(vtNormal);
|
|
|
|
m_pXDataMap->GetAt(HEQU_Width, dWidth);
|
|
m_pXDataMap->GetAt(HEQU_Length, dLen);
|
|
|
|
AcGePoint3d ptLeftUp = ptCenter - vtMain*dLen*0.5 - vtPerl*dWidth*0.5;
|
|
AcGePoint3d ptLeftDw = ptLeftUp + vtPerl*dWidth;
|
|
AcGePoint3d ptRightDw = ptLeftDw + vtMain*dLen;
|
|
AcGePoint3d ptRightUp = ptRightDw - vtPerl*dWidth;
|
|
arrPt.append(ptLeftUp);
|
|
arrPt.append(ptLeftDw);
|
|
arrPt.append(ptRightDw);
|
|
arrPt.append(ptRightUp);
|
|
}
|
|
|
|
// 导出XML
|
|
// CString THImpHvacDeDustCover::GetXml() const
|
|
// {
|
|
// if (NULL == m_pXDataMap || NULL == m_pOwnerEnt)
|
|
// return _T("");
|
|
//
|
|
// int nValue(0);
|
|
// double dValue(0.0);
|
|
// int nPtPreci = 6; // 位置精度
|
|
// int nWhPreci = 0; // 宽度、高度精度
|
|
//
|
|
// TXmlTree xmlTree;
|
|
// CString csText;
|
|
// CString csX, csY, csZ;
|
|
// AcGePoint3d pt;
|
|
// AcGeVector3d vt;
|
|
// AcDbObjectId id;
|
|
// POSITION posRoot = xmlTree.Insert(_T("ATS_DBHEQUIPMENT"), NULL, NULL);
|
|
// {
|
|
// xmlTree.SetAttribute(posRoot, _T("name"), _T("设备"));
|
|
// xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
|
|
// }
|
|
//
|
|
// POSITION posItemEquipType = xmlTree.Insert(_T("EquipType"), posRoot, NULL);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemEquipType, _T("name"), _T("设备类型"));
|
|
// xmlTree.SetAttribute(posItemEquipType, _T("comment"), _T("设备类型"));
|
|
// m_pXDataMap->GetAt(HEQU_SEquipType, csText);
|
|
// xmlTree.SetItemText(posItemEquipType, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemEquipFct = xmlTree.Insert(_T("Equip_Factory"), posRoot, posItemEquipType);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemEquipFct, _T("name"), _T("设备厂商"));
|
|
// xmlTree.SetAttribute(posItemEquipFct, _T("comment"), _T("所属厂商名称"));
|
|
// m_pXDataMap->GetAt(HEQU_SFactory, csText);
|
|
// xmlTree.SetItemText(posItemEquipFct, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemEquipForm = xmlTree.Insert(_T("Equip_Form"), posRoot, posItemEquipFct);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemEquipForm, _T("name"), _T("结构形式"));
|
|
// xmlTree.SetAttribute(posItemEquipForm, _T("comment"), _T("明暗装等"));
|
|
// m_pXDataMap->GetAt(HEQU_Form, csText);
|
|
// xmlTree.SetItemText(posItemEquipForm, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemEquipMode = xmlTree.Insert(_T("Equip_Mode"), posRoot, posItemEquipForm);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemEquipMode, _T("name"), _T("型号"));
|
|
// xmlTree.SetAttribute(posItemEquipMode, _T("comment"), _T("设备具体型号"));
|
|
// m_pXDataMap->GetAt(HEQU_SEquipName, csText);
|
|
// xmlTree.SetItemText(posItemEquipMode, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemEquipName = xmlTree.Insert(_T("EquipName"), posRoot, posItemEquipMode);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemEquipName, _T("name"), _T("名称"));
|
|
// xmlTree.SetAttribute(posItemEquipName, _T("comment"), _T("对应图库中的风机名称"));
|
|
// m_pXDataMap->GetAt(HEQU_SEquipName, csText);
|
|
// xmlTree.SetItemText(posItemEquipName, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemEquipName);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemNorDir, _T("name"), _T("法向量"));
|
|
// m_pXDataMap->GetAt(HVAC_Normal, vt);
|
|
// TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
|
|
// TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
|
|
// TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
|
|
// csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
|
// xmlTree.SetItemText(posItemNorDir, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemCentPt = xmlTree.Insert(_T("CenterPoint"), posRoot, posItemNorDir);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemCentPt, _T("name"), _T("中心点"));
|
|
// xmlTree.SetAttribute(posItemCentPt, _T("comment"), _T("布置点"));
|
|
// m_pXDataMap->GetAt(HEQU_CenterPoint, pt);
|
|
// TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
|
|
// TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
|
|
// TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
|
|
// csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
|
// xmlTree.SetItemText(posItemCentPt, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemMainDir = xmlTree.Insert(_T("MainDir"), posRoot, posItemCentPt);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemMainDir, _T("name"), _T("主矢量"));
|
|
// xmlTree.SetAttribute(posItemMainDir, _T("comment"), _T("布置角度"));
|
|
// m_pXDataMap->GetAt(HEQU_MainDir, vt);
|
|
// TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
|
|
// TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
|
|
// TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
|
|
// csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
|
// xmlTree.SetItemText(posItemMainDir, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemPart2D = xmlTree.Insert(_T("Part2D"), posRoot, posItemMainDir);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemPart2D, _T("name"), _T("2D块ID"));
|
|
// xmlTree.SetAttribute(posItemPart2D, _T("comment"), _T("平面图块"));
|
|
// m_pXDataMap->GetAt(HEQU_PartCenter, id);
|
|
// csText.Format(_T("%d"), id.asOldId());
|
|
// xmlTree.SetItemText(posItemPart2D, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemPart3D = xmlTree.Insert(_T("Part3D"), posRoot, posItemPart2D);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemPart3D, _T("name"), _T("3D块ID"));
|
|
// xmlTree.SetAttribute(posItemPart3D, _T("comment"), _T("三维图块"));
|
|
// m_pXDataMap->GetAt(HEQU_Part3D, id);
|
|
// csText.Format(_T("%d"), id.asOldId());
|
|
// xmlTree.SetItemText(posItemPart3D, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemMirror = xmlTree.Insert(_T("IsMirror"), posRoot, posItemPart3D);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemMirror, _T("name"), _T("是否镜像"));
|
|
// xmlTree.SetAttribute(posItemMirror, _T("comment"), _T("用于辅助绘制0:否,1:是"));
|
|
// m_pXDataMap->GetAt(HEQU_IsConverse, nValue);
|
|
// csText.Format(_T("%d"), nValue);
|
|
// xmlTree.SetItemText(posItemMirror, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemLength = xmlTree.Insert(_T("Length"), posRoot, posItemMirror);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemLength, _T("name"), _T("长度"));
|
|
// xmlTree.SetAttribute(posItemLength, _T("comment"), _T("设备长度"));
|
|
// m_pXDataMap->GetAt(HEQU_Length, dValue);
|
|
// TAuxTools::DoubleToString(dValue, nWhPreci, csText);
|
|
// xmlTree.SetItemText(posItemLength, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemWidth = xmlTree.Insert(_T("Width"), posRoot, posItemLength);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemWidth, _T("name"), _T("宽度"));
|
|
// xmlTree.SetAttribute(posItemWidth, _T("comment"), _T("设备宽度"));
|
|
// m_pXDataMap->GetAt(HEQU_Width, dValue);
|
|
// TAuxTools::DoubleToString(dValue, nWhPreci, csText);
|
|
// xmlTree.SetItemText(posItemWidth, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemThick = xmlTree.Insert(_T("Thick"), posRoot, posItemWidth);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemThick, _T("name"), _T("厚度"));
|
|
// xmlTree.SetAttribute(posItemThick, _T("comment"), _T("设备高度"));
|
|
// m_pXDataMap->GetAt(HEQU_Thick, dValue);
|
|
// TAuxTools::DoubleToString(dValue, nWhPreci, csText);
|
|
// xmlTree.SetItemText(posItemThick, csText);
|
|
// }
|
|
//
|
|
// POSITION posItemScale = xmlTree.Insert(_T("Scale"), posRoot, posItemThick);
|
|
// {
|
|
// xmlTree.SetAttribute(posItemScale, _T("name"), _T("图块比例"));
|
|
// xmlTree.SetAttribute(posItemScale, _T("comment"), _T("图块比例"));
|
|
// m_pXDataMap->GetAt(HEQU_Scale, vt);
|
|
// TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
|
|
// TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
|
|
// TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
|
|
// csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
|
// xmlTree.SetItemText(posItemScale, csText);
|
|
// }
|
|
//
|
|
// CString csXml = xmlTree.GetXml();
|
|
//
|
|
// return csXml;
|
|
// }
|
|
|
|
CString THImpHvacDeDustCover::GetXml(const AcGeMatrix3d& mat) const
|
|
{
|
|
if (NULL == m_pXDataMap || NULL == m_pOwnerEnt)
|
|
return _T("");
|
|
|
|
int nValue(0);
|
|
double dValue(0.0);
|
|
int nPtPreci = 6; // 位置精度
|
|
int nWhPreci = 0; // 宽度、高度精度
|
|
|
|
TXmlTree xmlTree;
|
|
CString csText;
|
|
CString csX, csY, csZ;
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vt;
|
|
AcDbObjectId id;
|
|
|
|
// 获得设备转换矩阵Lixl add 2012-2-1
|
|
// 插入点
|
|
XPoint ptLocation;
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, pt);
|
|
ptLocation = pt;
|
|
// 主方向
|
|
XVector3D vtDirection(0,0,1);
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vt);
|
|
vtDirection = vt;
|
|
// 图块比例
|
|
m_pXDataMap->GetAt(HEQU_Scale, vt);
|
|
AcGeScale3d scale3d(vt.x, vt.y, vt.z);
|
|
XVector3D vtNormal(0,0,1);
|
|
if(fabs(vtDirection.z) > 1.0E-6) //非水平面，计算法向
|
|
{
|
|
vtNormal = XVector3D(1,0,0)*vtDirection;
|
|
vtNormal.Normalize();
|
|
}
|
|
XPoint ptLoc=Wcs2Ecs(ptLocation, vtNormal);
|
|
double nRotEcs = ads_angle(XPoint(),vtDirection); //计算ECS下的转角
|
|
m_pXDataMap->GetAt(HEQU_Part3D, id);
|
|
AcDbBlockReference block(ptLoc, id);
|
|
block.setRotation(nRotEcs);
|
|
block.setScaleFactors(scale3d);
|
|
AcGeMatrix3d mat1 = block.blockTransform();
|
|
mat1 *= mat;
|
|
CString sMat;
|
|
TAuxTools::Matrix3D2String(mat1, sMat);
|
|
|
|
POSITION posRoot = xmlTree.Insert(_T("ATS_DBHEQUIPMENT"), NULL, NULL);
|
|
{
|
|
xmlTree.SetAttribute(posRoot, _T("name"), _T("设备"));
|
|
xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
|
|
}
|
|
|
|
POSITION posItemEquipType = xmlTree.Insert(_T("EquipType"), posRoot, NULL);
|
|
{
|
|
xmlTree.SetAttribute(posItemEquipType, _T("name"), _T("设备类型"));
|
|
xmlTree.SetAttribute(posItemEquipType, _T("comment"), _T("设备类型"));
|
|
m_pXDataMap->GetAt(HEQU_SEquipType, csText);
|
|
xmlTree.SetItemText(posItemEquipType, csText);
|
|
}
|
|
|
|
POSITION posItemEquipFct = xmlTree.Insert(_T("Equip_Factory"), posRoot, posItemEquipType);
|
|
{
|
|
xmlTree.SetAttribute(posItemEquipFct, _T("name"), _T("设备厂商"));
|
|
xmlTree.SetAttribute(posItemEquipFct, _T("comment"), _T("所属厂商名称"));
|
|
m_pXDataMap->GetAt(HEQU_SFactory, csText);
|
|
xmlTree.SetItemText(posItemEquipFct, csText);
|
|
}
|
|
|
|
POSITION posItemEquipForm = xmlTree.Insert(_T("Equip_Form"), posRoot, posItemEquipFct);
|
|
{
|
|
xmlTree.SetAttribute(posItemEquipForm, _T("name"), _T("结构形式"));
|
|
xmlTree.SetAttribute(posItemEquipForm, _T("comment"), _T("明暗装等"));
|
|
m_pXDataMap->GetAt(HEQU_Form, csText);
|
|
xmlTree.SetItemText(posItemEquipForm, csText);
|
|
}
|
|
|
|
POSITION posItemEquipMode = xmlTree.Insert(_T("Equip_Mode"), posRoot, posItemEquipForm);
|
|
{
|
|
xmlTree.SetAttribute(posItemEquipMode, _T("name"), _T("型号"));
|
|
xmlTree.SetAttribute(posItemEquipMode, _T("comment"), _T("设备具体型号"));
|
|
m_pXDataMap->GetAt(HEQU_SEquipName, csText);
|
|
xmlTree.SetItemText(posItemEquipMode, csText);
|
|
}
|
|
|
|
POSITION posItemEquipName = xmlTree.Insert(_T("EquipName"), posRoot, posItemEquipMode);
|
|
{
|
|
xmlTree.SetAttribute(posItemEquipName, _T("name"), _T("名称"));
|
|
xmlTree.SetAttribute(posItemEquipName, _T("comment"), _T("对应图库中的风机名称"));
|
|
m_pXDataMap->GetAt(HEQU_SEquipName, csText);
|
|
xmlTree.SetItemText(posItemEquipName, csText);
|
|
}
|
|
|
|
POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemEquipName);
|
|
{
|
|
xmlTree.SetAttribute(posItemNorDir, _T("name"), _T("法向量"));
|
|
m_pXDataMap->GetAt(HVAC_Normal, vt);
|
|
TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
|
|
TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
|
|
TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
|
|
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
|
xmlTree.SetItemText(posItemNorDir, csText);
|
|
}
|
|
|
|
POSITION posItemCentPt = xmlTree.Insert(_T("CenterPoint"), posRoot, posItemNorDir);
|
|
{
|
|
xmlTree.SetAttribute(posItemCentPt, _T("name"), _T("中心点"));
|
|
xmlTree.SetAttribute(posItemCentPt, _T("comment"), _T("布置点"));
|
|
m_pXDataMap->GetAt(HEQU_CenterPoint, pt);
|
|
TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
|
|
TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
|
|
TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
|
|
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
|
xmlTree.SetItemText(posItemCentPt, csText);
|
|
}
|
|
|
|
POSITION posItemMainDir = xmlTree.Insert(_T("MainDir"), posRoot, posItemCentPt);
|
|
{
|
|
xmlTree.SetAttribute(posItemMainDir, _T("name"), _T("主矢量"));
|
|
xmlTree.SetAttribute(posItemMainDir, _T("comment"), _T("布置角度"));
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vt);
|
|
TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
|
|
TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
|
|
TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
|
|
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
|
xmlTree.SetItemText(posItemMainDir, csText);
|
|
}
|
|
|
|
POSITION posItemPart2D = xmlTree.Insert(_T("Part2D"), posRoot, posItemMainDir);
|
|
{
|
|
xmlTree.SetAttribute(posItemPart2D, _T("name"), _T("2D块ID"));
|
|
xmlTree.SetAttribute(posItemPart2D, _T("comment"), _T("平面图块"));
|
|
m_pXDataMap->GetAt(HEQU_PartCenter, id);
|
|
csText.Format(_T("%d"), id.asOldId());
|
|
xmlTree.SetItemText(posItemPart2D, csText);
|
|
}
|
|
|
|
POSITION posItemPart3D = xmlTree.Insert(_T("Part3D"), posRoot, posItemPart2D);
|
|
{
|
|
xmlTree.SetAttribute(posItemPart3D, _T("name"), _T("3D块ID"));
|
|
xmlTree.SetAttribute(posItemPart3D, _T("comment"), _T("三维图块"));
|
|
m_pXDataMap->GetAt(HEQU_Part3D, id);
|
|
csText.Format(_T("%d"), id.asOldId());
|
|
xmlTree.SetItemText(posItemPart3D, csText);
|
|
}
|
|
|
|
POSITION posItemMirror = xmlTree.Insert(_T("IsMirror"), posRoot, posItemPart3D);
|
|
{
|
|
xmlTree.SetAttribute(posItemMirror, _T("name"), _T("是否镜像"));
|
|
xmlTree.SetAttribute(posItemMirror, _T("comment"), _T("用于辅助绘制0:否,1:是"));
|
|
m_pXDataMap->GetAt(HEQU_IsConverse, nValue);
|
|
csText.Format(_T("%d"), nValue);
|
|
xmlTree.SetItemText(posItemMirror, csText);
|
|
}
|
|
|
|
POSITION posItemLength = xmlTree.Insert(_T("Length"), posRoot, posItemMirror);
|
|
{
|
|
xmlTree.SetAttribute(posItemLength, _T("name"), _T("长度"));
|
|
xmlTree.SetAttribute(posItemLength, _T("comment"), _T("设备长度"));
|
|
m_pXDataMap->GetAt(HEQU_Length, dValue);
|
|
TAuxTools::DoubleToString(dValue, nWhPreci, csText);
|
|
xmlTree.SetItemText(posItemLength, csText);
|
|
}
|
|
|
|
POSITION posItemWidth = xmlTree.Insert(_T("Width"), posRoot, posItemLength);
|
|
{
|
|
xmlTree.SetAttribute(posItemWidth, _T("name"), _T("宽度"));
|
|
xmlTree.SetAttribute(posItemWidth, _T("comment"), _T("设备宽度"));
|
|
m_pXDataMap->GetAt(HEQU_Width, dValue);
|
|
TAuxTools::DoubleToString(dValue, nWhPreci, csText);
|
|
xmlTree.SetItemText(posItemWidth, csText);
|
|
}
|
|
|
|
POSITION posItemThick = xmlTree.Insert(_T("Thick"), posRoot, posItemWidth);
|
|
{
|
|
xmlTree.SetAttribute(posItemThick, _T("name"), _T("厚度"));
|
|
xmlTree.SetAttribute(posItemThick, _T("comment"), _T("设备高度"));
|
|
m_pXDataMap->GetAt(HEQU_Thick, dValue);
|
|
TAuxTools::DoubleToString(dValue, nWhPreci, csText);
|
|
xmlTree.SetItemText(posItemThick, csText);
|
|
}
|
|
|
|
POSITION posItemScale = xmlTree.Insert(_T("Scale"), posRoot, posItemThick);
|
|
{
|
|
xmlTree.SetAttribute(posItemScale, _T("name"), _T("图块比例"));
|
|
xmlTree.SetAttribute(posItemScale, _T("comment"), _T("图块比例"));
|
|
m_pXDataMap->GetAt(HEQU_Scale, vt);
|
|
TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
|
|
TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
|
|
TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
|
|
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
|
xmlTree.SetItemText(posItemScale, csText);
|
|
}
|
|
POSITION posItemMat= xmlTree.Insert(_T("Matrix3d"), posRoot, posItemScale);
|
|
{
|
|
xmlTree.SetAttribute(posItemMat, _T("name"), _T("矩阵"));
|
|
xmlTree.SetAttribute(posItemMat, _T("comment"), _T("图块转换矩阵"));
|
|
xmlTree.SetItemText(posItemMat, sMat);
|
|
}
|
|
|
|
CString csXml = xmlTree.GetXml();
|
|
|
|
return csXml;
|
|
}
|
|
|
|
// 如果超出边界，纠正到距离最近边
|
|
void THImpHvacDeDustCover::CheckIfPostion() const
|
|
{
|
|
if (NULL == m_pXDataMap)
|
|
return;
|
|
|
|
AcGePoint3dArray ptCornerArr;
|
|
GetBoxPts(ptCornerArr);
|
|
if (ptCornerArr.length() < 5)
|
|
return;
|
|
|
|
AcGePoint3d ptIf;
|
|
GetInterFaceLocal(0, ptIf);
|
|
double dOrigEle = ptIf.z;
|
|
|
|
AcGePoint3dArray ptMidArr;
|
|
ptMidArr.append(TAuxTools::Mid(ptCornerArr[1], ptCornerArr[2]));
|
|
ptMidArr.append(TAuxTools::Mid(ptCornerArr[2], ptCornerArr[3]));
|
|
ptMidArr.append(TAuxTools::Mid(ptCornerArr[3], ptCornerArr[4]));
|
|
ptMidArr.append(TAuxTools::Mid(ptCornerArr[4], ptCornerArr[1]));
|
|
|
|
AcGePoint3d ptClosed = ptMidArr[0];
|
|
double dCurDist(0);
|
|
ptIf.z = ptMidArr[0].z;
|
|
double dClosed = ptMidArr[0].distanceTo(ptIf);
|
|
int i(0);
|
|
for (i = 1; i < ptMidArr.length(); i++)
|
|
{
|
|
ptIf.z = ptMidArr[i].z;
|
|
dCurDist = ptMidArr[i].distanceTo(ptIf);
|
|
if (dCurDist < dClosed)
|
|
{
|
|
dClosed = dCurDist;
|
|
ptClosed = ptMidArr[i];
|
|
}
|
|
}
|
|
|
|
// 主向量、法向量、跟主向量垂直向量
|
|
AcGeVector3d vtMain, vtNormal, vtOff;
|
|
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
|
vtNormal = GetNormal();
|
|
vtMain.normalize();
|
|
|
|
if (ptClosed == ptMidArr[0])
|
|
{
|
|
vtOff = vtMain;
|
|
vtOff.rotateBy(-PI*0.5, vtNormal);
|
|
}
|
|
else if (ptClosed == ptMidArr[1])
|
|
{
|
|
vtOff = -vtMain;
|
|
}
|
|
else if (ptClosed == ptMidArr[2])
|
|
{
|
|
vtOff = vtMain;
|
|
vtOff.rotateBy(PI*0.5, vtNormal);
|
|
}
|
|
else
|
|
{
|
|
vtOff = vtMain;
|
|
}
|
|
|
|
double dDia(0.0), dTemp(0);
|
|
GetInterFaceLocal(0,dDia, dTemp);
|
|
ptIf = ptClosed + vtOff * dDia * 0.5;
|
|
ptIf.z = dOrigEle;
|
|
|
|
TDbXDataMap xdatamap;
|
|
if(m_pXDataMap->GetAt(HEQU_Interface, 0, xdatamap))
|
|
{
|
|
xdatamap.SetAt(HEQUIF_Point, ptIf);
|
|
m_pXDataMap->SetAt(HEQU_Interface, 0, xdatamap);
|
|
}
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::IsVertAlignment() const
|
|
{
|
|
ASSERT(NULL != m_pXDataMap);
|
|
|
|
// AcGeVector3d vtNor;
|
|
// if (m_pXDataMap->GetAt(HVAC_Normal, vtNor))
|
|
// {
|
|
// // 获得UCS坐标Z向量
|
|
// AcDbDatabase* pDb = acdbCurDwg();
|
|
// AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
|
//
|
|
// return vtNor.isParallelTo(vtZAxis);
|
|
// }
|
|
// else
|
|
// return FALSE;
|
|
|
|
AcGeVector3d vtIf;
|
|
if (GetInterFaceLocal(0, vtIf))
|
|
{
|
|
// UCS坐标Z向量
|
|
AcDbDatabase* pDb = acdbCurDwg();
|
|
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
|
|
|
return vtIf.isParallelTo(vtZAxis);
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
|
|
}
|
|
|
|
BOOL THImpHvacDeDustCover::IsHorzAligment() const
|
|
{
|
|
ASSERT(NULL != m_pXDataMap);
|
|
|
|
// AcGeVector3d vtNor;
|
|
// if (m_pXDataMap->GetAt(HVAC_Normal, vtNor))
|
|
// {
|
|
// // 获得UCS坐标Z向量
|
|
// AcDbDatabase* pDb = acdbCurDwg();
|
|
// AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
|
//
|
|
// return vtNor.isPerpendicularTo(vtZAxis);
|
|
// }
|
|
// else
|
|
// return FALSE;
|
|
|
|
AcGeVector3d vtIf;
|
|
if (GetInterFaceLocal(0, vtIf))
|
|
{
|
|
// UCS坐标Z向量
|
|
AcDbDatabase* pDb = acdbCurDwg();
|
|
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
|
|
|
return vtIf.isPerpendicularTo(vtZAxis);
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|