#include "stdafx.h" #include "THImpHvacOffset.h" #include "TDbInterfaceMsgWrite.h" #include "TDbHvacEquipment.h" #include "TAuxTools.h" using namespace TDb; extern void GetEndPointIndex(const AcGePoint3dArray &ptArr, int &nIndex1, int &nIndex2, AcGeVector3d* pRangeDir = NULL); // 获取标准基准投影面，２Ｄ相关绘制不在此面上的点都投影到此面上 AcGePlane GetStdPrjPlan( const AcGePoint3d &ptOnPlan ) { AcGeVector3d vtZAxis(TAuxTools::GetUcsZvt()); AcGePlane planStd(ptOnPlan, vtZAxis); AcGePoint3d ptPrj = AcGePoint3d::kOrigin.orthoProject(planStd); planStd.set(ptPrj, vtZAxis); return planStd; } // 辅助添加点函数,减少程序行数 int AutoAppendPt( TComplexCurve &cplCurve, TCurveElement &cplEle, AcGePoint3d &ptS, AcGePoint3d &ptMid, AcGePoint3d &ptE ) { cplEle.ptGe[0] = ptS; cplEle.ptGe[1] = ptMid; cplEle.ptGe[2] = ptE; return cplCurve.append(cplEle); } //　获取三点形成的弧的Ｂｕｌｇｅ值，根据当前用户Ｚ坐标确定正负 double GetBulge(AcGePoint3d ptStart, AcGePoint3d ptMid, AcGePoint3d ptEnd) { AcGeCircArc3d arc(ptStart, ptMid, ptEnd); double dSubAngle = arc.endAng() - arc.startAng(); double dBulge = tan(dSubAngle * 0.25); AcGeVector3d vtMid = ptMid - ptStart; AcGeVector3d vtE = ptEnd- ptStart; AcGeVector3d vtCross = vtMid.crossProduct(vtE); if (!vtCross.isCodirectionalTo(TAuxTools::GetUcsZvt())) dBulge *= -1; return dBulge; } ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// THImpHvacOffset::THImpHvacOffset() { } THImpHvacOffset::~THImpHvacOffset() { } Acad::ErrorStatus THImpHvacOffset::getClassID(CLSID* pClsid) const { // #if (ADS < 16) // // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E5} // CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE5 }}; // #endif // // #if (ADS == 16) // // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E5} // CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE6 }}; // #endif // // #if (ADS == 17) // // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E7} // CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE7 }}; // #endif // // #if (ADS == 18) // CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE8 }}; // #endif // // #if (ADS == 19) // CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE8 }}; // #endif return Acad::eOk; } BOOL THImpHvacOffset::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::eOffset); } return TRUE; } // 乙字弯样式 if (0 == _tcsicmp(pszName, HOFF_Type)) { pInfo->bVisible = TRUE; pInfo->bEditable = TRUE; // 提供数据列表和对应关系 if (NULL != pInfo->parsValues && NULL != pInfo->parlValues) { pInfo->parsValues->Add(_T("双弧")); pInfo->parlValues->Add(eArcuateLink); pInfo->parsValues->Add(_T("角接")); pInfo->parlValues->Add(eLinearLink); } return TRUE; } if (0 == _tcsicmp(pszName, HVAC_SectType)) { pInfo->bVisible = TRUE; pInfo->bEditable = TRUE; // 提供数据列表和对应关系 if (NULL != pInfo->parsValues && NULL != pInfo->parlValues) { pInfo->parsValues->Add(_T("矩形")); pInfo->parlValues->Add(TDb::eRectangular); pInfo->parsValues->Add(_T("圆形")); pInfo->parlValues->Add(TDb::eCircular); } TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo); return TRUE; } // 为了注册列表名，保证其他管件能用到此参数 if (0 == _tcsicmp(pszName, KEY_StartSectType) || 0 == _tcsicmp(pszName, KEY_EndSectType)) { pInfo->bVisible = FALSE; pInfo->bEditable = FALSE; // 提供数据列表和对应关系 if (NULL != pInfo->parsValues && NULL != pInfo->parlValues) { pInfo->parsValues->Add(_T("矩形")); pInfo->parlValues->Add(TDb::eRectangular); } return TRUE; } // 尺寸计算方式 为了注册列表名，保证其他管件能用到此参数 if (0 == _tcsicmp(pszName, HRED_ComputeType)) { pInfo->bVisible = FALSE; pInfo->bEditable = FALSE; // 提供数据列表和对应关系 if (NULL != pInfo->parsValues && NULL != pInfo->parlValues) { pInfo->parsValues->Add(_T("自动计算")); pInfo->parlValues->Add(TDb::eAuto); } return TRUE; } if (0 == _tcsicmp(pszName, HVAC_HasBaseLine)) { pInfo->bVisible = TRUE; pInfo->bEditable = TRUE; // 提供数据列表和对应关系 if (NULL != pInfo->parsValues && NULL != pInfo->parlValues) { pInfo->parsValues->Add(_T("隐藏")); pInfo->parlValues->Add(0); pInfo->parsValues->Add(_T("显示")); pInfo->parlValues->Add(1); } return TRUE; } if (0 == _tcsicmp(pszName, HVAC_IsSingleLine)) { pInfo->bVisible = TRUE; pInfo->bEditable = TRUE; // 提供数据列表和对应关系 if (NULL != pInfo->parsValues && NULL != pInfo->parlValues) { pInfo->parsValues->Add(_T("双线")); pInfo->parlValues->Add(0); pInfo->parsValues->Add(_T("单线")); pInfo->parlValues->Add(1); } TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo); return TRUE; } // 获得单线状态，当状态为单线时不显示 BOOL bSingleLine = FALSE; m_pXDataMap->GetAt(HVAC_IsSingleLine, bSingleLine); // 角度 if (0 == _tcsicmp(pszName, HOFF_Angle)) { pInfo->bVisible = TRUE; pInfo->bEditable = TRUE; if (NULL != pInfo->pXData) { // 获取数据 if (0 == pInfo->pXData->nVt) { m_pXDataMap->GetAt(HRED_Angle, *pInfo->pXData); pInfo->pXData->dVal[0] *= 180/PI; } else { m_pXDataMap->SetAt(HRED_Angle, pInfo->pXData->dVal[0]*PI/180); // 先记录更新前信息 AcGePoint3dArray ptArrOrig; AcDbObjectIdArray idArr; TAuxTools::GetInterfacePoint(this, ptArrOrig); TAuxTools::GetInterfaceId(this, idArr); IsValid(NULL); // 更新连接实体 if (NULL != m_pOwnerEnt) { AcGePoint3dArray ptArrNew; TAuxTools::GetInterfacePoint(this, ptArrNew); TAuxTools::DealWithConEnt(idArr, ptArrOrig, ptArrNew, m_pOwnerEnt->objectId()); m_pOwnerEnt->close(); acedPostCommand(_T("redraw\n")); } pInfo->pXData->nVt = 0; } } return TRUE; } if (0 == _tcsicmp(pszName, HOFF_StartWidth)) { // 获得截面，当截面不为圆型时显示并可改 HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); pInfo->bVisible = (TDb::eCircular != eSectType); pInfo->bEditable = TRUE; ValidOpmCanDraw(HOFF_StartWidth, pInfo); TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo); return TRUE; } if (0 == _tcsicmp(pszName, HOFF_EndWidth)) { // 获得截面，当截面不为圆型时显示并可改 HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); pInfo->bVisible = (TDb::eCircular != eSectType); pInfo->bEditable = TRUE; ValidOpmCanDraw(HOFF_EndWidth, pInfo); TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo); return TRUE; } if (0 == _tcsicmp(pszName, HOFF_Thick)) { // 获得截面，当截面不为圆型时显示并可改 HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); pInfo->bVisible = (TDb::eCircular != eSectType); pInfo->bEditable = TRUE; ValidOpmCanDraw(HOFF_Thick, pInfo); return TRUE; } // HOFF_Diameter和HOFF_StartWidth定义相同，为同一个值 // 为区分显示名称，借用未被使用的KEY_Diameter值来表达 if (0 == _tcsicmp(pszName, KEY_Diameter)) { // 获得截面，当截面为圆型时显示并可改 HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); pInfo->bVisible = (TDb::eCircular == eSectType); pInfo->bEditable = (!bSingleLine && TDb::eCircular == eSectType); // 替代属性，需要特殊处理数据获取和设置 if (NULL != pInfo->pXData) { // 获取数据 if (0 == pInfo->pXData->nVt) { m_pXDataMap->GetAt(HOFF_Diameter, *pInfo->pXData); } // 设置数据 else { ValidOpmCanDraw(HOFF_Thick, pInfo); TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, HOFF_Diameter, pInfo); } } return TRUE; } if (0 == _tcsicmp(pszName, HOFF_StartPoint)) { pInfo->bVisible = TRUE; pInfo->bEditable = TRUE; // 整体移动 if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt) { // 改变顶点变换行为 AcGePoint3d ptStart; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); AcGeVector3d offset = asPnt3d(pInfo->pXData->dVal) - ptStart; AcGeMatrix3d mat; mat.setToTranslation(offset); transformBy(mat); // pInfo->pXData->nVt = 0; // 设置处理完成标识 TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo); } return TRUE; } if (0 == _tcsicmp(pszName, HOFF_EndPoint)) { pInfo->bVisible = TRUE; pInfo->bEditable = TRUE; // 整体移动 if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt) { // 改变顶点变换行为 AcGePoint3d ptEnd; m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGeVector3d offset = asPnt3d(pInfo->pXData->dVal) - ptEnd; AcGeMatrix3d mat; mat.setToTranslation(offset); transformBy(mat); // pInfo->pXData->nVt = 0; // 设置处理完成标识 TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo); } return TRUE; } return FALSE; } // 验证特性表修改值是否合法能绘制,否则改为原值 BOOL THImpHvacOffset::ValidOpmCanDraw(const CString &csKey, TDb::OPMInfo* pInfo) { // 有效性确认 BOOL bValid(TRUE); if (NULL != pInfo->pXData) { if (0 != pInfo->pXData->nVt) { if (pInfo->pXData->dVal[0] < 1e-9) { pInfo->pXData->nVt = 0; // 设置处理完成标识 return FALSE; } double dOrigValue(0.0); m_pXDataMap->GetAt(csKey, dOrigValue); m_pXDataMap->SetAt(csKey, pInfo->pXData->dVal[0]); if (!IsCanDraw()) { bValid = FALSE; m_pXDataMap->SetAt(csKey, dOrigValue); pInfo->pXData->nVt = 0; // 设置处理完成标识 } } } return bValid; } void THImpHvacOffset::GetTips(CMapStringToString& mapLable2Tip) const { } void THImpHvacOffset::list() const { ASSERT(NULL != m_pXDataMap); // 管件类型 acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 暖通：乙字弯")); // 截面类型 HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); switch (eSectType) { case TDb::eRectangular: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 截面：矩形")); break; case TDb::eCircular: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 截面：圆形")); break; case TDb::eOblate: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 截面：扁圆形")); break; } // 圆型截面显示直径 if (TDb::eCircular == eSectType) { double dDiameter = 0.0; m_pXDataMap->GetAt(HOFF_Diameter, dDiameter); acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t直径：%.2f"), dDiameter); } // 非圆型截面显示宽度和厚度 else { double dStartWidth = 0.0, dEndWidth = 0.0, dThick = 0.0; m_pXDataMap->GetAt(HOFF_StartWidth, dStartWidth); m_pXDataMap->GetAt(HOFF_EndWidth, dEndWidth); m_pXDataMap->GetAt(HOFF_Thick, dThick); acutPrintf(_T("\n\t\t\t\t\t\t\t\t始端宽度：%.2f 末端宽度：%.2f 厚度：%.2f"), dStartWidth, dEndWidth, dThick); } // 起点 AcGePoint3d pt; m_pXDataMap->GetAt(HOFF_StartPoint, pt); acutPrintf(_T("\n\t\t\t\t\t\t\t\t自 点，X=%.4f\t Y=%.4f\t Z=%.4f"), pt.x, pt.y, pt.z); // 终点 m_pXDataMap->GetAt(HOFF_EndPoint, pt); acutPrintf(_T("\n\t\t\t\t\t\t\t\t到 点，X=%.4f\t Y=%.4f\t Z=%.4f"), pt.x, pt.y, pt.z); } int THImpHvacOffset::GetInterfaceCount() const { return 2; } void THImpHvacOffset::GetKindName( CString& sName ) { sName = _T("TCH_OFFSET"); } BOOL THImpHvacOffset::GetInterfaceSizeData(int nIndex, TInterface& pipeInterface) const { ASSERT(NULL != m_pXDataMap); // 获取截面类型 TDb::HvacSectType eSectType = TDb::eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); // 获取接口截面、宽度、厚度数据key值 LPCTSTR pszWidthKey, pszThickKey; switch (nIndex) { case 0: pszWidthKey = ((TDb::eCircular == eSectType) ? HOFF_Diameter : HOFF_StartWidth); pszThickKey = HOFF_Thick; break; case 1: pszWidthKey = ((TDb::eCircular == eSectType) ? HOFF_Diameter : HOFF_EndWidth); pszThickKey = HOFF_Thick; break; default: return FALSE; } // 获取尺寸 double dWidth = 0.0, dThick = 0.0; m_pXDataMap->GetAt(pszWidthKey, dWidth); m_pXDataMap->GetAt(pszThickKey, dThick); // 设置接口数据 pipeInterface.SetType(eSectType); pipeInterface.SetSize(dWidth, dThick); return TRUE; } BOOL THImpHvacOffset::GetInterface( int nIndex,TInterface& pipeInterface ) const { if (NULL == m_pXDataMap) return FALSE; // 获取各点位置 AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); // 求各端方向 AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()); AcDbObjectId id; switch(nIndex) { case 0: // 如果起始接口和第一个管连接 if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface)) { GetInterfaceSizeData(nIndex, pipeInterface); return TRUE; } // 如果起始接口和第二个管连接 if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface)) { GetInterfaceSizeData(nIndex, pipeInterface); return TRUE; } // 没有管件连接 pipeInterface.SetOutDir(vtStart); pipeInterface.SetOwnerId(m_pOwnerEnt->objectId()); pipeInterface.SetPosition(ptStart); GetInterfaceSizeData(nIndex, pipeInterface); return TRUE; case 1: // 如果末尾接口和第一个管连接 if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface)) { GetInterfaceSizeData(nIndex, pipeInterface); return TRUE; } // 如果末尾接口和第二个管连接 if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface)) { GetInterfaceSizeData(nIndex, pipeInterface); return TRUE; } // 没有管件连接 pipeInterface.SetOutDir(vtEnd); pipeInterface.SetOwnerId(m_pOwnerEnt->objectId()); pipeInterface.SetPosition(ptEnd); GetInterfaceSizeData(nIndex, pipeInterface); return TRUE; } return FALSE; } BOOL THImpHvacOffset::GetInterface( const AcGePoint3d& ptConnect,TInterface& pipeInterface ) const { if (NULL == m_pXDataMap) return FALSE; // 获取各点位置 AcGePoint3d ptStart, ptEnd, ptBran; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); // 求各端方向 AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()); // 计算测试点到始末点的距离 double dDist1 = ptConnect.distanceTo(ptStart); double dDist2 = ptConnect.distanceTo(ptEnd); AcDbObjectId id; // 位于起始点 if (dDist1 < 1e-3) { // 如果起始接口和第一个管连接 if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface)) { GetInterfaceSizeData(0, pipeInterface); return TRUE; } // 如果起始接口和第二个管件连接 if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface)) { GetInterfaceSizeData(0, pipeInterface); return TRUE; } // 没有管件连接 pipeInterface.SetOutDir(vtStart); pipeInterface.SetOwnerId(m_pOwnerEnt->objectId()); pipeInterface.SetPosition(ptStart); GetInterfaceSizeData(0, pipeInterface); return TRUE; } else if (dDist2 < 1e-3) // 位于末尾点 { // 如果末尾接口和第一个管连接 if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface)) { GetInterfaceSizeData(1, pipeInterface); return TRUE; } // 如果末尾接口和第二个管连接 if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface)) { GetInterfaceSizeData(1, pipeInterface); return TRUE; } // 没有管件连接 pipeInterface.SetOutDir(vtEnd); pipeInterface.SetOwnerId(m_pOwnerEnt->objectId()); pipeInterface.SetPosition(ptEnd); GetInterfaceSizeData(1, pipeInterface); return TRUE; } return FALSE; } BOOL THImpHvacOffset::HasInterface( const AcGePoint3d& ptConnect,const AcGeVector3d& vtDir ) { if (NULL == m_pXDataMap) return FALSE; // 获取各点位置 AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); // 求各端方向 AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()); // 计算测试点到始末点的距离 double dDist1 = ptConnect.distanceTo(ptStart); double dDist2 = ptConnect.distanceTo(ptEnd); // 位于起始点 if (dDist1 < 1e-3) return (vtDir.isParallelTo(vtStart)); // 位于末尾点 if (dDist2 < 1.e-3) return (vtDir.isParallelTo(vtEnd)); return FALSE; } BOOL THImpHvacOffset::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; } // 获取各点位置 AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); // 求各端方向 AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()); // 计算测试点到各点的距离 double dDist1 = ptConnect.distanceTo(ptStart); double dDist2 = ptConnect.distanceTo(ptEnd); // 基类指针 TDbInterfacesObj* pInterfaceObj = TDbInterfacesObj::cast(pEnt); ASSERT(NULL != pInterfaceObj); // 位于起始点 if (dDist1 < 1e-3 && pInterfaceObj->HasInterface(ptStart, vtStart)) { m_pXDataMap->SetAt(KEY_IDCNT1, idConnect); pEnt->close(); return TRUE; } // 位于末尾点 if (dDist2 < 1.e-3 && pInterfaceObj->HasInterface(ptEnd, vtEnd)) { m_pXDataMap->SetAt(KEY_IDCNT2, idConnect); pEnt->close(); return TRUE; } pEnt->close(); return FALSE; } BOOL THImpHvacOffset::RemoveInterfaceRelation( const AcGePoint3d& ptConnect, const AcDbObjectId& idConnect ) { if (NULL == m_pXDataMap) return FALSE; // 浅层次删除; 命名字典中的关系,需要外面移除关系,只移除内部关系 AcDbObjectId id; m_pXDataMap->GetAt(KEY_IDCNT1, id); if (id == idConnect) { m_pXDataMap->SetAt(KEY_IDCNT1, AcDbObjectId::kNull); return TRUE; } m_pXDataMap->GetAt(KEY_IDCNT2, id); if (id == idConnect) { m_pXDataMap->SetAt(KEY_IDCNT2, AcDbObjectId::kNull); return TRUE; } return FALSE; } BOOL THImpHvacOffset::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; case TDb::eTransformBy: // 对象移动消息处理 bMsgTranslate = OnTransformMsgNotify(iModiMsg, iModiMsgs); break; case TDb::eSize: // 尺寸调整消息处理 bMsgTranslate = OnSizeMsgNotify(iModiMsg, iModiMsgs); break; default: return bMsgTranslate; } // 记录修改标识 if (m_pOwnerEnt != NULL) m_pOwnerEnt->recordGraphicsModified(); return bMsgTranslate; } BOOL THImpHvacOffset::OnMoveGripPointMsgNotify( const TInterfaceModifyMsg& iModiMsg, TInterfaceModifyMsgs& iModiMsgs ) { if (!TAuxTools::IsAutoWorkOffset()) return FALSE; ASSERT(NULL != m_pXDataMap); BOOL bMsgTranslate = FALSE; AcDbObjectId id = iModiMsg.GetMsgOperateOn(); if (id != m_pOwnerEnt->objectId()) // 消息发送目标正确 return FALSE; AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset(); if (vtOffset.isZeroLength()) return FALSE; AcGePoint3d ptStart, ptEnd, ptMsg; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); ptMsg = iModiMsg.GetMsgPoint(); AcGeVector3d vtStart, vtEnd; m_pXDataMap->GetAt(HOFF_StartDir, vtStart); m_pXDataMap->GetAt(HOFF_EndDir, vtEnd); // 偏移向量跟法相不不垂直时，直接位移 AcGeVector3d vtNormal = normal(); if (!vtOffset.isPerpendicularTo(vtNormal)) { // 构造接口消息传递 开始端检查 AcDbObjectId idT; if (FindConnect(ptStart, vtStart, m_pOwnerEnt->objectId(), idT)) // sta 点的接口 { TInterfaceModifyMsg msg; msg.SetMsgPoint(ptStart); msg.SetMoveGripOffset(vtOffset); msg.SetMsgOperateOn(idT); msg.SetGripPosition(TDb::eStart); iModiMsgs.append(msg); bMsgTranslate = TRUE; } if (FindConnect(ptEnd, vtEnd, m_pOwnerEnt->objectId(), idT)) // End 点的接口 { TInterfaceModifyMsg msg; msg.SetMsgPoint(ptEnd); msg.SetMoveGripOffset(vtOffset); msg.SetMsgOperateOn(idT); msg.SetGripPosition(TDb::eEnd); iModiMsgs.append(msg); bMsgTranslate = TRUE; } // 移动自身 AcGePoint3d ptNewStart, ptNewEnd; ptNewStart = ptStart + vtOffset; ptNewEnd = ptEnd + vtOffset; m_pXDataMap->SetAt(HOFF_StartPoint, ptNewStart); m_pXDataMap->SetAt(HOFF_EndPoint, ptNewEnd); UpdateInterfaceRec(id, ptStart, ptNewStart); UpdateInterfaceRec(id, ptEnd, ptNewEnd); return bMsgTranslate; } // 先检查接口是否真实连接了实体 BOOL bStartCon(FALSE), bEndCon(FALSE); AcDbObjectId idStart(AcDbObjectId::kNull), idEnd(AcDbObjectId::kNull); m_pXDataMap->GetAt(KEY_IDCNT1, idStart); m_pXDataMap->GetAt(KEY_IDCNT2, idEnd); OPENOBJ_BEGIN(idStart, AcDb::kForRead, TDbInterfacesObj, pIfObj); if (NULL != pIfObj) { AcGePoint3d ptFind = ptStart; if (ptMsg.distanceTo(ptStart) < 1e-6) ptFind += vtOffset; if (pIfObj->GetInterface(ptFind, TInterface())) bStartCon = TRUE; } OPENOBJ_END(); OPENOBJ_BEGIN(idEnd, AcDb::kForRead, TDbInterfacesObj, pIfObj); if (NULL != pIfObj) { AcGePoint3d ptFind = ptEnd; if (ptMsg.distanceTo(ptEnd) < 1e-6) ptFind += vtOffset; if (pIfObj->GetInterface(ptFind, TInterface())) bEndCon = TRUE; } OPENOBJ_END(); if (ptMsg.distanceTo(ptStart) < 1e-6) { AcGePoint3d ptNewStart = ptStart + vtOffset; m_pXDataMap->SetAt(HOFF_StartPoint, ptNewStart); IsValid(NULL); bMsgTranslate = TRUE; if (IsCanDraw()) { AcGePoint3d ptNewEnd; m_pXDataMap->GetAt(HOFF_EndPoint, ptNewEnd); AcGeVector3d vtEndOff = ptNewEnd - ptEnd; vtEndOff = vtEndOff.orthoProject(vtEnd.perpVector()); if (bEndCon && !vtEndOff.isZeroLength()) TAuxTools::DealWithConEnt(idEnd, vtEndOff, id, ptEnd); } else // 不能绘制则返回原点 { m_pXDataMap->SetAt(HOFF_EndPoint, ptEnd); } AcGePoint3d ptNewEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptNewStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptNewEnd); UpdateInterfaceRec(id, ptStart, ptNewStart); UpdateInterfaceRec(id, ptEnd, ptNewEnd); } else if (ptMsg.distanceTo(ptEnd) < 1e-6) { AcGePoint3d ptNewEnd = ptEnd + vtOffset; m_pXDataMap->SetAt(HOFF_EndPoint, ptNewEnd); IsValid(NULL); AcGePoint3d ptFixedEnd; m_pXDataMap->GetAt(HOFF_EndPoint, ptFixedEnd); // 保证末点不变 AcGeVector3d vtChange = ptFixedEnd - ptEnd; AcGeVector3d vtPlan = ptEnd - ptStart; if (vtPlan.isParallelTo(vtStart)) // 非常规乙子弯 { double dAngle = vtChange.angleTo(vtStart); double dLen = vtChange.length() * cos(dAngle); if (vtChange.angleTo(vtStart) > PI*0.5) dLen *= -1; vtChange.setToProduct(vtStart, dLen); } else { vtPlan = vtStart.crossProduct(vtPlan); vtPlan = vtStart.crossProduct(vtPlan); vtChange = vtChange.orthoProject(vtPlan); } AcGePoint3d ptNewStart = ptStart - vtChange; m_pXDataMap->SetAt(HOFF_StartPoint, ptNewStart); m_pXDataMap->SetAt(HOFF_EndPoint, ptNewEnd); bMsgTranslate = TRUE; if (IsCanDraw()) { AcGePoint3d ptNewStart; m_pXDataMap->GetAt(HOFF_StartPoint, ptNewStart); AcGeVector3d vtStartOff = ptNewStart - ptStart; vtStartOff = vtStartOff.orthoProject(vtStart.perpVector()); if (bStartCon && !vtStartOff.isZeroLength()) TAuxTools::DealWithConEnt(idStart, vtStartOff, id, ptStart); } else // 不能绘制则返回原点 { m_pXDataMap->SetAt(HOFF_StartPoint, ptStart); } m_pXDataMap->GetAt(HOFF_StartPoint, ptNewStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptNewEnd); UpdateInterfaceRec(id, ptStart, ptNewStart); UpdateInterfaceRec(id, ptEnd, ptNewEnd); } acedPostCommand(_T("Redraw\n")); // 暂用于响应移动消息后，没有更新接口记录问题 return bMsgTranslate; } BOOL THImpHvacOffset::OnTransformMsgNotify( const TInterfaceModifyMsg& iModiMsg, TInterfaceModifyMsgs& iModiMsgs ) { if (!TAuxTools::IsAutoWorkOffset()) return FALSE; ASSERT(NULL != m_pXDataMap); BOOL bMsgTranslate = FALSE; AcDbObjectId id = iModiMsg.GetMsgOperateOn(); if (id != m_pOwnerEnt->objectId()) // 消息发送目标正确 return FALSE; AcGeMatrix3d mtTrans = iModiMsg.GetTransform(); AcGeVector3d vtSta, vtEnd; AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartDir, vtSta); m_pXDataMap->GetAt(HOFF_EndDir, vtEnd); m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGePoint3d ptGeSOld = ptStart; AcGePoint3d ptGeEOld = ptEnd; ptStart.transformBy(mtTrans); ptEnd.transformBy(mtTrans); m_pXDataMap->SetAt(HOFF_StartPoint, ptStart); m_pXDataMap->SetAt(HOFF_EndPoint, ptEnd); // 构造接口消息传递 开始端检查 AcDbObjectId idT; if (FindConnect(ptGeSOld, vtSta, m_pOwnerEnt->objectId(), idT)) // sta 点的接口 { TInterfaceModifyMsg msg; msg.SetMsgPoint(ptGeSOld); msg.SetTransform(mtTrans); msg.SetMsgOperateOn(idT); iModiMsgs.append(msg); bMsgTranslate = TRUE; } // 构造接口消息传递 末端检查 if (FindConnect(ptGeEOld, vtEnd, m_pOwnerEnt->objectId(), idT)) // end 点的接口 { TInterfaceModifyMsg msg; msg.SetMsgPoint(ptGeEOld); msg.SetTransform(mtTrans); msg.SetMsgOperateOn(idT); iModiMsgs.append(msg); bMsgTranslate = TRUE; } // 更新模型空间的扩展字典的注册的接口数据 UpdateInterfaceRec(m_pOwnerEnt->objectId(), mtTrans); return bMsgTranslate;} BOOL THImpHvacOffset::OnSizeMsgNotify( const TInterfaceModifyMsg& iModiMsg, TInterfaceModifyMsgs& iModiMsgs ) { ASSERT(NULL != m_pXDataMap); BOOL bSizeChanged = FALSE; AcDbObjectId id = iModiMsg.GetMsgOperateOn(); if (id != m_pOwnerEnt->objectId()) // 消息发送目标正确 return FALSE; double dOrigStartWidth(0.0), dOrigEndWidth(0.0), dOrigThick(0.0); m_pXDataMap->GetAt(HOFF_StartWidth, dOrigStartWidth); m_pXDataMap->GetAt(HOFF_EndWidth, dOrigEndWidth); m_pXDataMap->GetAt(HOFF_Thick, dOrigThick); AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset(); AcGePoint3d ptOrigStart, ptOrigEnd, ptMsg; m_pXDataMap->GetAt(HOFF_StartPoint, ptOrigStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptOrigEnd); ptMsg = iModiMsg.GetMsgPoint(); // 先检查接口是否真实连接了实体 BOOL bStartCon(FALSE), bEndCon(FALSE); AcDbObjectId idStart(AcDbObjectId::kNull), idEnd(AcDbObjectId::kNull); m_pXDataMap->GetAt(KEY_IDCNT1, idStart); m_pXDataMap->GetAt(KEY_IDCNT2, idEnd); OPENOBJ_BEGIN(idStart, AcDb::kForRead, TDbInterfacesObj, pIfObj); if (NULL != pIfObj) { AcGePoint3d ptFind = ptOrigStart; if (ptMsg.distanceTo(ptOrigStart) < 1e-6) ptFind += vtOffset; if (pIfObj->GetInterface(ptFind, TInterface())) bStartCon = TRUE; } OPENOBJ_END(); OPENOBJ_BEGIN(idEnd, AcDb::kForRead, TDbInterfacesObj, pIfObj); if (NULL != pIfObj) { AcGePoint3d ptFind = ptOrigEnd; if (ptMsg.distanceTo(ptOrigEnd) < 1e-6) ptFind += vtOffset; if (pIfObj->GetInterface(ptFind, TInterface())) bEndCon = TRUE; } OPENOBJ_END(); HvacSectType eSect = TDb::eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect); // 看哪个接口方向修改了尺寸，修改相应接口尺寸 int nModifyFrom(0); // 修改方向， 0：首，1：尾 // 设置各接口新尺寸 double dNewWidth, dNewHeigh(0.0); AcGeVector3d vtNormal = normal(); if (eSect == TDb::eRectangular) { AcGeVector3d vtWidthDir, vtHeighDir; iModiMsg.GetSizeDir(vtWidthDir, vtHeighDir); // 判断是否是空间连接或导致宽高互换 if (vtHeighDir.isParallelTo(vtNormal)) iModiMsg.GetSize(dNewWidth, dNewHeigh); else iModiMsg.GetSize(dNewHeigh, dNewWidth); } else { iModiMsg.GetSize(dNewWidth, dNewHeigh); dNewHeigh = dNewWidth; } if (ptMsg.distanceTo(ptOrigStart) < 1e-6) { if (eSect == TDb::eRectangular) { m_pXDataMap->SetAt(HOFF_StartWidth, dNewWidth); m_pXDataMap->SetAt(HOFF_Thick, dNewHeigh); } else if (eSect == TDb::eCircular) { m_pXDataMap->SetAt(HOFF_Diameter, dNewWidth); } bSizeChanged = TRUE; nModifyFrom = 0; AcGePoint3d ptNewStart = ptOrigStart + vtOffset; m_pXDataMap->SetAt(HOFF_StartPoint, ptNewStart); if (vtOffset.isParallelTo(vtNormal)) { AcGePoint3d ptNewEnd = ptOrigEnd + vtOffset; m_pXDataMap->SetAt(HOFF_EndPoint, ptNewEnd); } } else if (ptMsg.distanceTo(ptOrigEnd) < 1e-6) { if (eSect == TDb::eRectangular) { m_pXDataMap->SetAt(HOFF_EndWidth, dNewWidth); m_pXDataMap->SetAt(HOFF_Thick, dNewHeigh); } else if (eSect == TDb::eCircular) { m_pXDataMap->SetAt(HOFF_Diameter, dNewWidth); } bSizeChanged = TRUE; nModifyFrom = 1; AcGePoint3d ptNewEnd = ptOrigEnd + vtOffset; m_pXDataMap->SetAt(HOFF_EndPoint, ptNewEnd); if (vtOffset.isParallelTo(vtNormal)) { AcGePoint3d ptNewStart = ptOrigStart + vtOffset; m_pXDataMap->SetAt(HOFF_StartPoint, ptNewStart); } } // 由于尺寸变化，调用内部校正函数，接口点必须沿各向量方向校正, // 不能绘制则返回原来参数 if (!IsValid(NULL)) { m_pXDataMap->SetAt(HOFF_StartWidth, dOrigStartWidth); m_pXDataMap->SetAt(HOFF_EndWidth, dOrigEndWidth); m_pXDataMap->SetAt(HOFF_Thick, dOrigThick); m_pXDataMap->SetAt(HOFF_StartPoint, ptOrigStart); m_pXDataMap->SetAt(HOFF_EndPoint, ptOrigEnd); return FALSE; } AcGePoint3d ptNewStart, ptNewEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptNewStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptNewEnd); // 更新接口记录 AcGeVector3d vtStartOff = ptNewStart - ptOrigStart; AcGeVector3d vtEndOff = ptNewEnd - ptOrigEnd; if (vtStartOff.length() > 1e-6) UpdateInterfaceRec(id, ptOrigStart, ptNewStart); if (vtEndOff.length() > 1e-6) UpdateInterfaceRec(id, ptOrigEnd, ptNewEnd); // 纠正由于风管边壁偏移导致的向量差 AcGeVector3d vtPrj; AcGePoint3d ptFixedStart(ptOrigStart), ptFixedEnd(ptOrigEnd); if (nModifyFrom == 0) { ptFixedStart += vtOffset; AcGeVector3d vtStart; m_pXDataMap->GetAt(HOFF_StartDir, vtStart); vtPrj = vtStart.crossProduct(vtNormal); vtStartOff = vtStartOff.orthoProject(vtPrj); } else if (nModifyFrom == 1) { ptFixedEnd += vtOffset; AcGeVector3d vtEnd; m_pXDataMap->GetAt(HOFF_EndDir, vtEnd); vtPrj = vtEnd.crossProduct(vtNormal); vtEndOff = vtEndOff.orthoProject(vtPrj); } // 根据最终位移向量，处理接口端连接实体位置 if (vtStartOff.length() > 1e-6 && bStartCon) TAuxTools::DealWithConEnt(idStart, vtStartOff, id, ptFixedStart); if (vtEndOff.length() > 1e-6 && bEndCon) TAuxTools::DealWithConEnt(idEnd, vtEndOff, id, ptFixedEnd); return bSizeChanged; } Acad::ErrorStatus THImpHvacOffset::transformBy( const AcGeMatrix3d& xform ) { if (NULL == m_pXDataMap) return Acad::eNotApplicable; // 变换点位置 AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); ptStart.transformBy(xform); ptEnd.transformBy(xform); // 变换向量 AcGeVector3d vtSta(StartVect()), vtEnd(EndVect()); vtSta.transformBy(xform); vtEnd.transformBy(xform); vtSta.normalize(); vtEnd.normalize(); // 更新点 m_pXDataMap->SetAt(HOFF_StartPoint, ptStart); m_pXDataMap->SetAt(HOFF_EndPoint, ptEnd); // 更新向量 m_pXDataMap->SetAt(HOFF_StartDir, vtSta); m_pXDataMap->SetAt(HOFF_EndDir, vtEnd); // 设置尺寸 double dScale = xform.scale(); double dStaWidth(0.0), dEndWidth(0.), dHeigh(0.0); m_pXDataMap->GetAt(HOFF_StartWidth, dStaWidth); m_pXDataMap->GetAt(HOFF_EndWidth, dEndWidth); m_pXDataMap->GetAt(HOFF_Thick, dHeigh); dStaWidth *= dScale; dEndWidth *= dScale; dHeigh *= dScale; m_pXDataMap->SetAt(HOFF_StartWidth, dStaWidth); m_pXDataMap->SetAt(HOFF_EndWidth, dEndWidth); m_pXDataMap->SetAt(HOFF_Thick, dHeigh); // 传递消息 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.SetMsgValidate(TRUE); iMsg.SetTransform(xform); iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId()); TDbInterfaceMsgWrite msgWrite; msgWrite.WriteInterfaceMsg(iMsg); //更新接口记录接口信息 UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform); } } return Acad::eOk; } TDb::Position THImpHvacOffset::ExplainGripIndex( int nIndex ) const { Position ePos = eStart; switch(nIndex) { case 0: ePos = eStart; break; case 1: ePos = eEnd; break; case 2: ePos = eCommand0; break; case 3: ePos = eCommand1; break; default: break; } return ePos; } //　管件不需要拉伸 Acad::ErrorStatus THImpHvacOffset::getStretchPoints( AcGePoint3dArray& stretchPoints ) const { if (NULL == m_pXDataMap) return Acad::eNotApplicable; AcGePoint3d ptSta, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptSta); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); stretchPoints.append(ptSta); stretchPoints.append(ptEnd); return Acad::eOk; } Acad::ErrorStatus THImpHvacOffset::getGripPoints( AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds ) const { if (NULL == m_pXDataMap) return Acad::eNotApplicable; // 获取各点位置、向量 AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()); HvacOffsetType eType = eArcuateLink; HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HOFF_Type, (int&)eType); m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); double dStartWidth(0.0), dEndWidth(0.0), dThick(0.0); m_pXDataMap->GetAt(HOFF_StartWidth, dStartWidth); m_pXDataMap->GetAt(HOFF_EndWidth, dEndWidth); m_pXDataMap->GetAt(HOFF_Thick, dThick); gripPoints.append(ptStart); gripPoints.append(ptEnd); // 取得10个像素点在世界坐标系下的长度,距两端距离 // double dCmdOff = PixelToWcs(10); AcGePoint3d ptCommand1, ptCommand2; AcGeVector3d vtUserZAixs = TAuxTools::GetUcsZvt(); if (IsHorzAlignment() || IsFaceVertAlignment()) { ptCommand1 = ptStart + g_dCmdOff * vtStart; ptCommand2 = ptEnd + g_dCmdOff * vtEnd; } else if (IsSideVertAlignment()) { AcGeVector3d vtCmd = ptStart - ptEnd; vtCmd = vtCmd.orthoProject(vtUserZAixs); vtCmd.normalize(); vtCmd.rotateBy(PI*0.25, vtUserZAixs); ptCommand1 = ptStart + g_dCmdOff * vtCmd; ptCommand2 = ptEnd + g_dCmdOff * vtCmd; } gripPoints.append(ptCommand1); gripPoints.append(ptCommand2); return Acad::eOk; } Acad::ErrorStatus THImpHvacOffset::getOsnapPoints( AcDb::OsnapMode osnapMode, INT_PTR gsSelectionMark, const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint, const AcGeMatrix3d& viewXform, AcGePoint3dArray& snapPoints, AcDbIntArray& geomIds ) const { if (NULL == m_pXDataMap) return Acad::eNotApplicable; // 取得位置点 AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); // 根据捕捉模式处理 switch(osnapMode) { case AcDb::kOsModeEnd: snapPoints.append(ptStart); snapPoints.append(ptEnd); break; case AcDb::kOsModeMid: snapPoints.append(TAuxTools::Mid(ptStart,ptEnd)); break; case AcDb::kOsModeCen: break; case AcDb::kOsModePerp: break; case AcDb::kOsModeNear: break; } return Acad::eOk; } Acad::ErrorStatus THImpHvacOffset::moveStretchPointsAt( const AcDbIntArray& indices, const AcGeVector3d& offset ) { if (indices.length() < 2) return Acad::eNotImplementedYet; return MoveTransGripPointsAt(TDb::eStart, offset, FALSE); } Acad::ErrorStatus THImpHvacOffset::moveGripPointsAt( const AcDbIntArray& indices, const AcGeVector3d& offset ) { if (NULL == m_pXDataMap || offset.length() < 1e-6) return Acad::eNotImplementedYet; // 如果有多个点，则去除命令点后，有多个点时作为移动，单个点时使用该点类型 Position ePos; if (indices.length() == 1) { // 单个夹点 ePos = ExplainGripIndex(indices[0]); } else { // 多个夹点 int iCount = 0; Position eTemp; int iPos = indices.length(); while ((--iPos) >= 0 && iCount < 2) { eTemp = ExplainGripIndex(indices[iPos]); switch (eTemp) { case eStart: case eEnd: case eMid: case eDim1: case eSizeMid0: case eSizeMid1: ePos = eTemp; iCount++; break; } } // 多个命令夹点不处理 if (iCount == 0) return Acad::eOk; // 多个非命令夹点，移动整体 if (iCount > 1) { MoveTransGripPointsAt(eMid, offset, TRUE); return Acad::eOk; } } switch (ePos) { case eStart: case eEnd: // MoveTransGripPointsAt(ePos, offset); MoveGripRandom(ePos, offset); break; break; case eCommand0: case eCommand1: MoveCommandGripPointsAt(ePos, offset); break; default: break; } return Acad::eOk; } // 拖拽管件，支持转向等操作 Acad::ErrorStatus THImpHvacOffset::MoveGripRandom(TDb::Position ePos, const AcGeVector3d& offset ) { AcGePoint3d ptDrag; if (ePos == eStart) m_pXDataMap->GetAt(HOFF_StartPoint, ptDrag); else m_pXDataMap->GetAt(HOFF_EndPoint, ptDrag); TInterfaceModifyMsg iMsg; iMsg.SetMsgPoint(ptDrag); iMsg.SetGripPosition(ePos); iMsg.SetMoveGripOffset(offset); iMsg.SetMsgValidate(TRUE); iMsg.SetInterfaceOper(eNewCommand); iMsg.SetPreviewObjToCreate(eOffset, 0); // 写入接口更改消息 AcDbSoftPointerId idOwner; m_pXDataMap->GetAt(KEY_THISID, idOwner); iMsg.SetMsgOperateOn(idOwner); TDbInterfaceMsgWrite msgWrite; msgWrite.WriteInterfaceMsg(iMsg); // 发送消息 acedPostCommand(_T("\33")); acedPostCommand(_T("znyd\n")); return Acad::eOk; } Acad::ErrorStatus THImpHvacOffset::MoveTransGripPointsAt( TDb::Position ePos, const AcGeVector3d& offset, BOOL bAutoWork ) { ASSERT(NULL != m_pXDataMap); AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); ptStart += offset; ptEnd += offset; m_pXDataMap->SetAt(HOFF_StartPoint, ptStart); m_pXDataMap->SetAt(HOFF_EndPoint, ptEnd); // 传递修改消息 if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid()) { if (bAutoWork) { AcGePoint3d ptOper; if (ePos == eStart) ptOper = ptStart; else if (ePos == eEnd) ptOper = ptEnd; // 创建接口更改消息 TInterfaceModifyMsg iMsg; iMsg.SetMsgPoint(ptOper); iMsg.SetGripPosition(ePos); iMsg.SetMoveGripOffset(offset); iMsg.SetMsgValidate(TRUE); iMsg.SetInterfaceOper(eMoveGripPoint); iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId()); // 写入接口更改消息 TDbInterfaceMsgWrite msgWrite; msgWrite.WriteInterfaceMsg(iMsg); } //更新自身模型空间的扩展字典的接口信息 AcGeMatrix3d xform; xform.setToTranslation(offset); UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform); return Acad::eOk; } return Acad::eNotImplementedYet; } Acad::ErrorStatus THImpHvacOffset::MoveCommandGripPointsAt( TDb::Position ePos, const AcGeVector3d& offset ) { ASSERT(NULL != m_pXDataMap); // 获得夹点命令 CString sCmdStr; GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, sCmdStr); if (sCmdStr.IsEmpty()) return Acad::eNotApplicable; AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGeVector3d vtStart; m_pXDataMap->GetAt(HOFF_StartDir, vtStart); // 创建接口更改消息 TInterfaceModifyMsg iMsg; AcGePoint3d ptDrag; if (ePos == eCommand0) ptDrag = ptStart; else if (ePos == eCommand1) ptDrag = ptEnd; iMsg.SetMsgPoint(ptDrag); iMsg.SetGripPosition(ePos); iMsg.SetMoveGripOffset(offset); iMsg.SetMsgValidate(TRUE); iMsg.SetInterfaceOper(eNewCommand); iMsg.SetPreviewObjToCreate(eOffset, 0); // 写入接口更改消息 AcDbSoftPointerId idOwner; m_pXDataMap->GetAt(KEY_THISID, idOwner); iMsg.SetMsgOperateOn(idOwner); TDbInterfaceMsgWrite msgWrite; msgWrite.WriteInterfaceMsg(iMsg); // 发送消息 acedPostCommand(_T("\33")); acedPostCommand(sCmdStr + _T("\n")); return Acad::eOk; } AcGeVector3d THImpHvacOffset::StartVect() const { ASSERT(NULL != m_pXDataMap); AcGeVector3d vtSta(AcGeVector3d::kIdentity); if (NULL != m_pXDataMap) m_pXDataMap->GetAt(HOFF_StartDir, vtSta); return vtSta; } AcGeVector3d THImpHvacOffset::EndVect() const { ASSERT(NULL != m_pXDataMap); AcGeVector3d vtEnd(AcGeVector3d::kIdentity); if (NULL != m_pXDataMap) m_pXDataMap->GetAt(HOFF_EndDir, vtEnd); return vtEnd; } AcGeVector3d THImpHvacOffset::normal() const { ASSERT(NULL != m_pXDataMap); AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGeVector3d vtEnd(EndVect()); AcGeVector3d vtDirect = ptEnd- ptStart; AcGeVector3d vtNormal = vtDirect.crossProduct(vtEnd); vtNormal.normalize(); return vtNormal; } BOOL THImpHvacOffset::IsHorzAlignment() const { ASSERT(NULL != m_pXDataMap); AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGeVector3d vtUserZAxis = TAuxTools::GetUcsZvt(); AcGeVector3d vtSub = ptEnd - ptStart; return vtSub.isPerpendicularTo(vtUserZAxis); } BOOL THImpHvacOffset::IsSideVertAlignment() const { ASSERT(NULL != m_pXDataMap); AcGeVector3d vtUserZAxis = TAuxTools::GetUcsZvt(); return StartVect().isParallelTo(vtUserZAxis); } BOOL THImpHvacOffset::IsFaceVertAlignment() const { ASSERT(NULL != m_pXDataMap); AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGeVector3d vtSub = ptEnd - ptStart; AcGeVector3d vtSta; m_pXDataMap->GetAt(HOFF_StartDir, vtSta); AcGeVector3d vtUserZAxis = TAuxTools::GetUcsZvt(); AcGeVector3d vtSubPrj = vtSub.orthoProject(TAuxTools::GetUcsZvt()); AcGeVector3d vtStaPrj = vtSta.orthoProject(TAuxTools::GetUcsZvt()); return vtSubPrj.isParallelTo(vtStaPrj); } BOOL THImpHvacOffset::IsSingleLine() const { ASSERT(NULL != m_pXDataMap); BOOL bSingleLine = FALSE; m_pXDataMap->GetAt(HVAC_IsSingleLine, (int&)bSingleLine); return bSingleLine; } BOOL THImpHvacOffset::IsBaseLine() const { ASSERT(NULL != m_pXDataMap); BOOL bBaseLine = FALSE; m_pXDataMap->GetAt(HVAC_HasBaseLine, (int&)bBaseLine); return bBaseLine; } Acad::ErrorStatus THImpHvacOffset::ExplodeOrDraw3d( XExplodeDraw &mode ) const { if (NULL == m_pXDataMap) return Acad::eNotImplementedYet; if (!IsCanDraw()) return Acad::eNotImplementedYet; HvacOffsetType eType = eArcuateLink; HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HOFF_Type, (int&)eType); m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); if (eType == eArcuateLink) { if (eSectType == eRectangular) return ExplodeOrDrawRectArcuate3d(mode); else if (eSectType == eCircular) return ExplodeOrDrawCircleArcuate3d(mode); } else if (eType == eLinearLink) { if (eSectType == eRectangular) return ExplodeOrDrawRectLinear3d(mode); else if (eSectType == eCircular) return ExplodeOrDrawCircleLinear3d(mode); } return Acad::eNotImplementedYet; } Acad::ErrorStatus THImpHvacOffset::ExplodeOrDraw2d( XExplodeDraw &mode ) const { if (NULL == m_pXDataMap) return Acad::eNotImplementedYet; TComplexCurve cplCurve; MakeCurves(cplCurve); TDbExtentsEdge edage; edage.SetEdage(cplCurve); AcDbObjectId idReal = ((TDbInterfacesObj*)m_pOwnerEnt)->layerId(); AcDbObjectId idDash = ((TDbInterfacesObj*)m_pOwnerEnt)->DashLayer(); AcDbObjectId idCent = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer(); edage.ExplodeOrDraw2d(mode,idReal,idDash,idCent,NULL,FALSE,FALSE); return Acad::eOk; } BOOL THImpHvacOffset::MakeCurves( TComplexCurve& compCurve ) const { if (NULL == m_pXDataMap) return FALSE; if (!IsSingleLine() && !IsCanDraw()) return FALSE; if (IsHorzAlignment()) { HvacOffsetType eType = eArcuateLink; m_pXDataMap->GetAt(HOFF_Type, (int&)eType); if (eType == eArcuateLink) return MakeHorizArcuate2DCurves(compCurve, 0); else if (eType == eLinearLink) return MakeHorizLinear2DCurves(compCurve, 0); } else if (IsSideVertAlignment()) { HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); if (eSectType == eRectangular) return MakeSideVertRect2DCurves(compCurve, 0); else if (eSectType == eCircular) return MakeSideVertCircle2DCurves(compCurve, 0); } else if (IsFaceVertAlignment()) { return MakeFaceVert2DCurves(compCurve, 0); } return FALSE; } BOOL THImpHvacOffset::GetCurvesInSide( TComplexCurve& compCurve ) const { if (NULL == m_pXDataMap) return FALSE; if (!IsSingleLine() && !IsCanDraw()) return FALSE; if (IsHorzAlignment()) { HvacOffsetType eType = eArcuateLink; m_pXDataMap->GetAt(HOFF_Type, (int&)eType); if (eType == eArcuateLink) return MakeHorizArcuate2DCurves(compCurve, 1); else if (eType == eLinearLink) return MakeHorizLinear2DCurves(compCurve, 1); } else if (IsSideVertAlignment()) { HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); if (eSectType == eRectangular) return MakeSideVertRect2DCurves(compCurve, 1); else if (eSectType == eCircular) return MakeSideVertCircle2DCurves(compCurve, 1); } else if (IsFaceVertAlignment()) { return MakeFaceVert2DCurves(compCurve, 1); } return FALSE; } AcDbPolyline* THImpHvacOffset::MakePolyCurve() const { if (NULL == m_pXDataMap) return NULL; if (IsHorzAlignment()) { HvacOffsetType eType = eArcuateLink; m_pXDataMap->GetAt(HOFF_Type, (int&)eType); if (eType == eArcuateLink) return MakeHorizArcuatePolyCurves(); else if (eType == eLinearLink) return MakeHorizLinearPolyCurves(); } else if (IsSideVertAlignment()) { HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); if (eSectType == eRectangular) return MakeSideVertRectPolyCurves(); else if (eSectType == eCircular) return MakeSideVertCirclePolyCurves(); } else if (IsFaceVertAlignment()) { return MakeFaceVertPolyCurves(); } return NULL; } BOOL THImpHvacOffset::MakePolyCurveFaces( AcDbVoidPtrArray& arFaces ) { if (NULL == m_pXDataMap) return FALSE; if (IsHorzAlignment()) { HvacOffsetType eType = eArcuateLink; m_pXDataMap->GetAt(HOFF_Type, (int&)eType); if (eType == eArcuateLink) return MakeHorizArcuateCurvesFaces(arFaces); else if (eType == eLinearLink) return MakeHorizLinearCurvesFaces(arFaces); } else if (IsSideVertAlignment()) { HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); if (eSectType == eRectangular) return MakeSideVertRectCurvesFaces(arFaces); else if (eSectType == eCircular) return MakeSideVertCircleCurvesFaces(arFaces); } else if (IsFaceVertAlignment()) { return MakeFaceVertCurvesFaces(arFaces); } return FALSE; } Acad::ErrorStatus THImpHvacOffset::ExplodeOrDrawRectArcuate3d( XExplodeDraw &mode ) const { AcGePoint3dArray ptLeftArr, ptRightArr; GetAllMinAnglePt(ptLeftArr, ptRightArr); if (ptLeftArr.length() != ptRightArr.length() || 7 > ptLeftArr.length()) return Acad::eNotImplementedYet; double dHalfThick(0.0); m_pXDataMap->GetAt(HOFF_Thick, dHalfThick); dHalfThick *= 0.5; AcGeVector3d vtNormal = normal(); AcGeVector3d vtOff = dHalfThick * vtNormal; AcGePoint3dArray ptMeshArr; int i(0); for (i = 0; i < ptLeftArr.length(); i++) { ptMeshArr.append(ptLeftArr[i] + vtOff); ptMeshArr.append(ptRightArr[i] + vtOff); ptMeshArr.append(ptRightArr[i] - vtOff); ptMeshArr.append(ptLeftArr[i] - vtOff); ptMeshArr.append(ptLeftArr[i] + vtOff); } mode.DrawMesh(ptLeftArr.length(), 5, ptMeshArr.asArrayPtr()); return Acad::eOk; } Acad::ErrorStatus THImpHvacOffset::ExplodeOrDrawRectLinear3d( XExplodeDraw &mode ) const { AcGePoint3dArray ptUpArr, ptDownArr; if (!GetTwoSideKeyPoints(ptUpArr, ptDownArr)) return Acad::eNotImplementedYet; if (8 != ptDownArr.length() || 8 != ptUpArr.length()) return Acad::eNotImplementedYet; AcGePoint3dArray ptMeshArr; ptMeshArr.append(ptUpArr[1]); ptMeshArr.append(ptUpArr[0]); ptMeshArr.append(ptDownArr[0]); ptMeshArr.append(ptDownArr[1]); ptMeshArr.append(ptUpArr[1]); ptMeshArr.append(ptUpArr[2]); ptMeshArr.append(ptUpArr[7]); ptMeshArr.append(ptDownArr[7]); ptMeshArr.append(ptDownArr[2]); ptMeshArr.append(ptUpArr[2]); ptMeshArr.append(ptUpArr[3]); ptMeshArr.append(ptUpArr[6]); ptMeshArr.append(ptDownArr[6]); ptMeshArr.append(ptDownArr[3]); ptMeshArr.append(ptUpArr[3]); ptMeshArr.append(ptUpArr[4]); ptMeshArr.append(ptUpArr[5]); ptMeshArr.append(ptDownArr[5]); ptMeshArr.append(ptDownArr[4]); ptMeshArr.append(ptUpArr[4]); mode.DrawMesh(4, 5, ptMeshArr.asArrayPtr()); // AcGePoint3dArray ptMeshArr; // ptMeshArr.append(ptUpArr[1]); // ptMeshArr.append(ptUpArr[2]); // ptMeshArr.append(ptDownArr[1]); // ptMeshArr.append(ptDownArr[2]); // ptMeshArr.append(ptDownArr[0]); // ptMeshArr.append(ptDownArr[3]); // ptMeshArr.append(ptUpArr[0]); // ptMeshArr.append(ptUpArr[3]); // ptMeshArr.append(ptUpArr[1]); // ptMeshArr.append(ptUpArr[2]); // mode.DrawMesh(5, 2, ptMeshArr.asArrayPtr()); return Acad::eOk; } // 先找出左右两侧弧所有最小分度角点，然后循环求出每段圆中各分度角点 Acad::ErrorStatus THImpHvacOffset::ExplodeOrDrawCircleArcuate3d( XExplodeDraw &mode ) const { AcGePoint3dArray ptLeftArr, ptRightArr; GetAllMinAnglePt(ptLeftArr, ptRightArr); if (ptLeftArr.length() != ptRightArr.length() || 7 > ptLeftArr.length()) return Acad::eNotImplementedYet; double dMinAngle(TAuxTools::GetMinDiffAngle()); double dCircleMinAngle(0.0); int nCirclePart = (int)(PI*2 / dMinAngle) + 1; dCircleMinAngle = PI*2 / nCirclePart; // 每段圆左/右侧点,循环点, 每段圆心点 AcGePoint3d ptLeft, ptRight, ptNow, ptCenter; // 每段相切、垂直向量， 法向 AcGeVector3d vtTangEvery, vtPerlEvery, vtNormal(normal()); AcGePoint3dArray ptArrMesh; int i(0), j(0); for (i = 0; i < ptLeftArr.length(); i++) { vtPerlEvery = ptLeftArr[i] - ptRightArr[i]; vtTangEvery = vtPerlEvery.crossProduct(vtNormal); ptCenter = TAuxTools::Mid(ptLeftArr[i], ptRightArr[i]); ptNow = ptLeftArr[i]; for (j = 0; j < nCirclePart; j++) { ptArrMesh.append(ptNow); ptNow.rotateBy(dCircleMinAngle, vtTangEvery, ptCenter); } ptArrMesh.append(ptLeftArr[i]); } mode.DrawMesh(ptLeftArr.length(), nCirclePart + 1, ptArrMesh.asArrayPtr()); return Acad::eOk; } Acad::ErrorStatus THImpHvacOffset::ExplodeOrDrawCircleLinear3d( XExplodeDraw &mode ) const { double dRadius(0.0), dPluse(0.0); m_pXDataMap->GetAt(HOFF_Diameter, dRadius); dRadius *= 0.5; m_pXDataMap->GetAt(HVAC_PlusEdge, dPluse); AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGeVector3d vtStart(StartVect()); AcGeVector3d vtDirect = (ptEnd + dPluse * vtStart) - (ptStart - dPluse * vtStart); AcGeVector3d vtNormal = normal(); double dMinAngle(TAuxTools::GetMinDiffAngle()); int nPart = (int)(PI*2 / dMinAngle) + 1; dMinAngle = PI*2 / nPart; AcGePoint3dArray ptMeshArr; AcGePoint3d ptStartFirst = ptStart + dRadius * vtNormal; AcGePoint3d ptStartNow = ptStartFirst; AcGePoint3d ptNext; int i(0); for (i = 0; i < nPart + 1; i++) { ptMeshArr.append(ptStartNow); ptNext = ptStartNow - dPluse * vtStart; ptMeshArr.append(ptNext); ptNext += vtDirect; ptMeshArr.append(ptNext); ptNext -= dPluse * vtStart; ptMeshArr.append(ptNext); ptStartNow.rotateBy(dMinAngle, vtStart, ptStart); } mode.DrawMesh(nPart + 1, 4, ptMeshArr.asArrayPtr()); return Acad::eOk; } // 按两个弯头连接，有变径时在起始端半部变 BOOL THImpHvacOffset::MakeHorizArcuate2DCurves( TComplexCurve& cplCurve, const int &nOutOrIn ) const { TCurveElement tCurveEle; memset(&tCurveEle, 0, sizeof(TCurveElement)); tCurveEle.bHided = FALSE; tCurveEle.dWidth = 0.0; tCurveEle.gsMark = 0; double dEdgeWidth(GetEdgeLineWidth()); if (IsSingleLine() || (IsBaseLine() && nOutOrIn == 1)) { AcGePoint3dArray ptBaseArr; if (!GetArcBaseKeyPt(ptBaseArr) || ptBaseArr.length() != 7) return FALSE; if (IsSingleLine()) tCurveEle.dWidth = dEdgeWidth; else { tCurveEle.dWidth = GetCentLineWidth(); tCurveEle.idSubLay = GetBaseLayerId(); } AutoAppendPt(cplCurve, tCurveEle, ptBaseArr[0], ptBaseArr[1], ptBaseArr[1]); AutoAppendPt(cplCurve, tCurveEle, ptBaseArr[1], ptBaseArr[2], ptBaseArr[3]); AutoAppendPt(cplCurve, tCurveEle, ptBaseArr[3], ptBaseArr[4], ptBaseArr[5]); AutoAppendPt(cplCurve, tCurveEle, ptBaseArr[5], ptBaseArr[6], ptBaseArr[6]); } else if (nOutOrIn == 0) { AcGePoint3dArray ptLeftArr, ptRightArr; if (!GetArcTwoSideKeyPt(ptLeftArr, ptRightArr)) return FALSE; if (7 != ptLeftArr.length() || 7 != ptRightArr.length()) return FALSE; tCurveEle.dWidth = dEdgeWidth; AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[0], ptLeftArr[1], ptLeftArr[1]); AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[1], ptLeftArr[2], ptLeftArr[3]); AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[3], ptLeftArr[4], ptLeftArr[5]); AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[5], ptLeftArr[6], ptLeftArr[6]); AutoAppendPt(cplCurve, tCurveEle, ptRightArr[0], ptRightArr[1], ptRightArr[1]); AutoAppendPt(cplCurve, tCurveEle, ptRightArr[1], ptRightArr[2], ptRightArr[3]); AutoAppendPt(cplCurve, tCurveEle, ptRightArr[3], ptRightArr[4], ptRightArr[5]); AutoAppendPt(cplCurve, tCurveEle, ptRightArr[5], ptRightArr[6], ptRightArr[6]); tCurveEle.dWidth = GetEndLineWidth(); m_pXDataMap->GetAt(HVAC_EndLayer, tCurveEle.idSubLay); AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[0], ptRightArr[0], ptRightArr[0]); AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[6], ptRightArr[6], ptRightArr[6]); } return TRUE; } BOOL THImpHvacOffset::MakeHorizLinear2DCurves( TComplexCurve& cplCurve, const int &nOutOrIn ) const { TCurveElement tCurveEle; memset(&tCurveEle, 0, sizeof(TCurveElement)); tCurveEle.bHided = FALSE; tCurveEle.dWidth = 0.0; tCurveEle.gsMark = 0; double dEdgeWidth(GetEdgeLineWidth()); if (IsSingleLine() || (IsBaseLine() && nOutOrIn == 1)) { AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); double dPlus(0.0); m_pXDataMap->GetAt(HVAC_PlusEdge, dPlus); AcGeVector3d vtSta(StartVect()), vtEnd(EndVect()); AcGePoint3d ptStaPlus = ptStart - dPlus * vtSta; AcGePoint3d ptEndPlus = ptEnd - dPlus * vtEnd; if (IsSingleLine()) tCurveEle.dWidth = dEdgeWidth; else { tCurveEle.dWidth = GetCentLineWidth(); tCurveEle.idSubLay = GetBaseLayerId(); } AutoAppendPt(cplCurve, tCurveEle, ptStart, ptStaPlus, ptStaPlus); AutoAppendPt(cplCurve, tCurveEle, ptStaPlus, ptEndPlus, ptEndPlus); AutoAppendPt(cplCurve, tCurveEle, ptEndPlus, ptEnd, ptEnd); return TRUE; } else if (nOutOrIn == 0) { AcGePoint3dArray ptArr; GetMidKeyPoints(ptArr); int i(0); for (i = 0; i < ptArr.length() - 1; i++) { if (i == 0 || i == 4) { tCurveEle.dWidth = GetEndLineWidth(); m_pXDataMap->GetAt(HVAC_EndLayer, tCurveEle.idSubLay); } else { tCurveEle.dWidth = dEdgeWidth; tCurveEle.idSubLay.setNull(); } AutoAppendPt(cplCurve, tCurveEle, ptArr[i], ptArr[i+1], ptArr[i+1]); } AutoAppendPt(cplCurve, tCurveEle, ptArr[i], ptArr[0], ptArr[0]); } return TRUE; } BOOL THImpHvacOffset::MakeSideVertRect2DCurves( TComplexCurve& cplCurve, const int &nOutOrIn ) const { TCurveElement tCurveEle; memset(&tCurveEle, 0, sizeof(TCurveElement)); tCurveEle.bHided = FALSE; tCurveEle.dWidth = 0.0; tCurveEle.gsMark = 0; AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGePoint3d ptMid = TAuxTools::Mid(ptStart, ptEnd); AcGePlane planStd = GetStdPrjPlan(ptMid); double dEdgeWidth(GetEdgeLineWidth()), dCentWidth(GetCentLineWidth()); if (IsSingleLine()) { tCurveEle.dWidth = dEdgeWidth; AutoAppendPt(cplCurve, tCurveEle, ptStart.orthoProject(planStd), ptEnd.orthoProject(planStd), ptEnd.orthoProject(planStd)); return TRUE; } AcGePoint3dArray ptUpArr, ptDownArr; GetTwoSideKeyPoints(ptUpArr, ptDownArr); if (8 != ptUpArr.length() || 8 != ptDownArr.length()) return FALSE; int nEnd1(0), nEnd2(0); GetEndPointIndex(ptUpArr, nEnd1, nEnd2); if(nOutOrIn == 1) { tCurveEle.dWidth = dEdgeWidth; int i(0); for (i = 0; i < ptUpArr.length(); i++) { if (i == nEnd1 || i == nEnd2) continue; AutoAppendPt(cplCurve, tCurveEle, ptDownArr[i].orthoProject(planStd), ptUpArr[i].orthoProject(planStd), ptUpArr[i].orthoProject(planStd)); } if (IsBaseLine()) { tCurveEle.dWidth = dCentWidth; tCurveEle.idSubLay = GetBaseLayerId(); AutoAppendPt(cplCurve, tCurveEle, ptStart.orthoProject(planStd), ptEnd.orthoProject(planStd), ptEnd.orthoProject(planStd)); } } else if (nOutOrIn == 0) { tCurveEle.dWidth = dEdgeWidth; // 端点两边 AutoAppendPt(cplCurve, tCurveEle, ptDownArr[nEnd1].orthoProject(planStd), ptUpArr[nEnd1].orthoProject(planStd), ptUpArr[nEnd1].orthoProject(planStd)); AutoAppendPt(cplCurve, tCurveEle, ptDownArr[nEnd2].orthoProject(planStd), ptUpArr[nEnd2].orthoProject(planStd), ptUpArr[nEnd2].orthoProject(planStd)); // 侧部两边 AutoAppendPt(cplCurve, tCurveEle, ptDownArr[nEnd1].orthoProject(planStd), ptDownArr[nEnd2].orthoProject(planStd), ptDownArr[nEnd2].orthoProject(planStd)); AutoAppendPt(cplCurve, tCurveEle, ptUpArr[nEnd1].orthoProject(planStd), ptUpArr[nEnd2].orthoProject(planStd), ptUpArr[nEnd2].orthoProject(planStd)); } return Acad::eOk; } BOOL THImpHvacOffset::MakeSideVertCircle2DCurves( TComplexCurve& cplCurve, const int &nOutOrIn ) const { TCurveElement tCurveEle; memset(&tCurveEle, 0, sizeof(TCurveElement)); tCurveEle.bHided = FALSE; tCurveEle.dWidth = 0.0; tCurveEle.gsMark = 0; AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); double dRadius(0.0); m_pXDataMap->GetAt(HOFF_Diameter, dRadius); dRadius *= 0.5; AcGePoint3d ptMid = TAuxTools::Mid(ptStart, ptEnd); AcGePlane planStd = GetStdPrjPlan(ptMid); ptStart = ptStart.orthoProject(planStd); ptEnd = ptEnd.orthoProject(planStd); double dEdgeWidth(GetEdgeLineWidth()), dCentWidth(GetCentLineWidth()); if (IsSingleLine()) { tCurveEle.dWidth = dEdgeWidth; AutoAppendPt(cplCurve, tCurveEle, ptStart, ptEnd, ptEnd); return TRUE; } AcGeVector3d vtNormal = normal(); AcGeVector3d vtDirect = ptEnd - ptStart; vtDirect.normalize(); AcGePoint3d ptStartCirSta, ptStartCirMid, ptStartCirEnd; // 起始半圆各点 AcGePoint3d ptEndCirSta, ptEndCirMid, ptEndCirEnd; // 末半圆各点 ptStartCirSta = ptStart + dRadius * vtNormal; ptStartCirEnd = ptStart - dRadius * vtNormal; ptEndCirSta = ptEnd + dRadius * vtNormal; ptEndCirEnd = ptEnd - dRadius * vtNormal; if(nOutOrIn == 1) { tCurveEle.dWidth = dEdgeWidth; // 起始端半圆 ptStartCirMid = ptStart + dRadius * vtDirect; AutoAppendPt(cplCurve, tCurveEle, ptStartCirSta, ptStartCirMid, ptStartCirEnd); // 末端半圆 ptEndCirMid = ptEnd - dRadius * vtDirect; AutoAppendPt(cplCurve, tCurveEle, ptEndCirSta, ptEndCirMid, ptEndCirEnd); if (IsBaseLine()) { tCurveEle.dWidth = dCentWidth; tCurveEle.idSubLay = GetBaseLayerId(); AutoAppendPt(cplCurve, tCurveEle, ptStart, ptEnd, ptEnd); } } else if (nOutOrIn == 0) { tCurveEle.dWidth = dEdgeWidth; // 两边 AutoAppendPt(cplCurve, tCurveEle, ptStartCirSta, ptEndCirSta, ptEndCirSta); AutoAppendPt(cplCurve, tCurveEle, ptStartCirEnd, ptEndCirEnd, ptEndCirEnd); // 两半圆 ptStartCirMid = ptStart - dRadius * vtDirect; AutoAppendPt(cplCurve, tCurveEle, ptStartCirSta, ptStartCirMid, ptStartCirEnd); ptEndCirMid = ptEnd + dRadius * vtDirect; AutoAppendPt(cplCurve, tCurveEle, ptEndCirSta, ptEndCirMid, ptEndCirEnd); } return TRUE; } BOOL THImpHvacOffset::MakeFaceVert2DCurves( TComplexCurve& cplCurve, const int &nOutOrIn ) const { TCurveElement tCurveEle; memset(&tCurveEle, 0, sizeof(TCurveElement)); tCurveEle.bHided = FALSE; tCurveEle.dWidth = 0.0; tCurveEle.gsMark = 0; AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGePoint3d ptMid = TAuxTools::Mid(ptStart, ptEnd); AcGePlane planStd = GetStdPrjPlan(ptMid); AcGePoint3dArray ptUpArr, ptDownArr; GetTwoSideKeyPoints(ptUpArr, ptDownArr); if (8 != ptUpArr.length() || 8 != ptDownArr.length()) return FALSE; double dEdgeWidth(GetEdgeLineWidth()), dCentWidth(GetCentLineWidth()); if (IsSingleLine()) { tCurveEle.dWidth = dEdgeWidth; AutoAppendPt(cplCurve, tCurveEle, ptStart.orthoProject(planStd), ptEnd.orthoProject(planStd), ptEnd.orthoProject(planStd)); return Acad::eOk; } if (nOutOrIn == 1) { // 技术支持反馈，不画端部弧直分隔线 // tCurveEle.dWidth = dEdgeWidth; // AutoAppendPt(cplCurve, tCurveEle, ptDownArr[2].orthoProject(planStd), // ptUpArr[2].orthoProject(planStd), ptUpArr[2].orthoProject(planStd)); // // AutoAppendPt(cplCurve, tCurveEle, ptDownArr[3].orthoProject(planStd), // ptUpArr[3].orthoProject(planStd), ptUpArr[3].orthoProject(planStd)); if (IsBaseLine()) { tCurveEle.dWidth = dCentWidth; tCurveEle.idSubLay = GetBaseLayerId(); AutoAppendPt(cplCurve, tCurveEle, ptStart.orthoProject(planStd), ptEnd.orthoProject(planStd), ptEnd.orthoProject(planStd)); } } else if (nOutOrIn == 0) { tCurveEle.dWidth = dEdgeWidth; AutoAppendPt(cplCurve, tCurveEle, ptUpArr[1].orthoProject(planStd), ptUpArr[4].orthoProject(planStd), ptUpArr[4].orthoProject(planStd)); AutoAppendPt(cplCurve, tCurveEle, ptDownArr[4].orthoProject(planStd), ptDownArr[1].orthoProject(planStd), ptDownArr[1].orthoProject(planStd)); tCurveEle.dWidth = GetEndLineWidth(); m_pXDataMap->GetAt(HVAC_EndLayer, tCurveEle.idSubLay); AutoAppendPt(cplCurve, tCurveEle, ptDownArr[1].orthoProject(planStd), ptUpArr[1].orthoProject(planStd), ptUpArr[1].orthoProject(planStd)); AutoAppendPt(cplCurve, tCurveEle, ptUpArr[4].orthoProject(planStd), ptDownArr[4].orthoProject(planStd), ptDownArr[4].orthoProject(planStd)); // 中间加箭头标示，上升（下降）摇手弯，及气流方向 // 长度为乙子弯长度1/2,三条线均分宽度 // 箭头7.5度 /* 0━━━━━━1 高标高 \ \ Start \ 4 End \ \ \ \ 2━━━━━━━━3 低标高 */ int nDrawMode(0); m_pXDataMap->GetAt(HOFF_VertDrawStyle, nDrawMode); if (1 == nDrawMode) { int nFlowDir(0); m_pXDataMap->GetAt(HVAC_FlowDirect, nFlowDir); AcGePoint3d ptArrorArr[5], ptRectArr[4]; ptRectArr[0] = ptDownArr[1].orthoProject(planStd); ptRectArr[1] = ptUpArr[1].orthoProject(planStd); ptRectArr[2] = ptUpArr[4].orthoProject(planStd); ptRectArr[3] = ptDownArr[4].orthoProject(planStd); double dLen = ptRectArr[0].distanceTo(ptRectArr[3]); double dWidth = ptRectArr[0].distanceTo(ptRectArr[1]); AcGeVector3d vtLen, vtWidth; vtLen = (ptRectArr[3] - ptRectArr[0]).normalize(); vtWidth = (ptRectArr[1] - ptRectArr[0]).normalize(); AcGeVector3d vtHook = vtWidth; double dHookOff = dLen/12 * tan(7.5/180.0*PI); if (dHookOff > dWidth/3) dHookOff = dWidth/3; if (nFlowDir == 0) // 起始点流向终点 { // ptArrorArr[0] = ptRectArr[0] + vtWidth * dWidth/3 + vtLen * dLen/4; // ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; // ptArrorArr[3] = ptRectArr[2] - vtWidth * dWidth/3 - vtLen * dLen/4; // ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6; // ptArrorArr[4] = ptArrorArr[3] - vtLen * dLen/12; // // // 纠正末尾钩子方向 // AcGeVector3d vtDirect = ptArrorArr[3] - ptArrorArr[0]; // vtDirect.rotateBy(PI*0.5, TAuxTools::GetUcsZvt()); // if (vtHook.angleTo(vtDirect) > PI*0.5) // vtHook *= -1; // // ptArrorArr[4] += vtHook * dHookOff; // add by dyw 2015.12.1 绘制乙字弯时上述图形有时不与风管的标高方向一致 TFS9874 // 注：乙字弯的流向在外部没有使用，所以暂未考虑逆向的画法 AcGeVector3d vecTmp = ptEnd - ptStart; if(vecTmp.angleTo(TAuxTools::GetUcsXvt()) - PI * 0.5 < 1E-6) { ptArrorArr[0] = ptRectArr[0] + vtWidth * dWidth/3 + vtLen * dLen/4; ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; ptArrorArr[3] = ptRectArr[2] - vtWidth * dWidth/3 - vtLen * dLen/4; ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6; ptArrorArr[4] = ptArrorArr[3] - vtLen * dLen/12; // 纠正末尾钩子方向 AcGeVector3d vtDirect = ptArrorArr[3] - ptArrorArr[0]; vtDirect.rotateBy(PI*0.5, TAuxTools::GetUcsZvt()); if (vtHook.angleTo(vtDirect) > PI*0.5) vtHook *= -1; ptArrorArr[4] += vtHook * dHookOff; } else { ptArrorArr[0] = ptRectArr[1] - vtWidth * dWidth/3 + vtLen * dLen/4; ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; ptArrorArr[3] = ptRectArr[3] + vtWidth * dWidth/3 - vtLen * dLen/4; ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6; ptArrorArr[4] = ptArrorArr[3] - vtLen * dLen/12; AcGeVector3d vtDirect = ptArrorArr[3] - ptArrorArr[0]; vtDirect.rotateBy(PI*0.5, TAuxTools::GetUcsZvt()); if (vtHook.angleTo(vtDirect) < PI*0.5) vtHook *= -1; ptArrorArr[4] += vtHook * dHookOff; } // add end } else { vtLen *= -1; ptArrorArr[0] = ptRectArr[3] + vtWidth * dWidth/3 + vtLen * dLen/4; ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; ptArrorArr[3] = ptRectArr[1] - vtWidth * dWidth/3 - vtLen * dLen/4; ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6; ptArrorArr[4] = ptArrorArr[3] - vtLen * dLen/12; AcGeVector3d vtDirect = ptArrorArr[3] - ptArrorArr[0]; vtDirect.rotateBy(PI*0.5, TAuxTools::GetUcsZvt()); if (vtHook.angleTo(vtDirect) > PI*0.5) vtHook *= -1; ptArrorArr[4] += vtHook * dHookOff; } tCurveEle.dWidth = dEdgeWidth; tCurveEle.idSubLay.setNull(); AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[0], ptArrorArr[1], ptArrorArr[1]); AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[1], ptArrorArr[2], ptArrorArr[2]); AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[2], ptArrorArr[3], ptArrorArr[3]); AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[3], ptArrorArr[4], ptArrorArr[4]); } else if (2 == nDrawMode) // add by cq 2016-07-12 增加乙字弯样式 TFS14954 { int nFlowDir(0); m_pXDataMap->GetAt(HVAC_FlowDirect, nFlowDir); AcGePoint3d ptArrorArr[5], ptRectArr[4]; ptRectArr[0] = ptDownArr[1].orthoProject(planStd); ptRectArr[1] = ptUpArr[1].orthoProject(planStd); ptRectArr[2] = ptUpArr[4].orthoProject(planStd); ptRectArr[3] = ptDownArr[4].orthoProject(planStd); double dLen = ptRectArr[0].distanceTo(ptRectArr[3]); double dWidth = ptRectArr[0].distanceTo(ptRectArr[1]); AcGeVector3d vtLen, vtWidth; vtLen = (ptRectArr[3] - ptRectArr[0]).normalize(); vtWidth = (ptRectArr[1] - ptRectArr[0]).normalize(); AcGeVector3d vtHook = vtWidth; double dHookOff = dLen/12 * tan(7.5/180.0*PI); if (dHookOff > dWidth/3) dHookOff = dWidth/3; if (nFlowDir == 0) // 起始点流向终点 { // add by dyw 2015.12.1 绘制乙字弯时上述图形有时不与风管的标高方向一致 TFS9874 // 注：乙字弯的流向在外部没有使用，所以暂未考虑逆向的画法 AcGeVector3d vecTmp = ptEnd - ptStart; if(vecTmp.angleTo(TAuxTools::GetUcsXvt()) - PI * 0.5 < 1E-6) { ptArrorArr[0] = ptRectArr[0] + vtWidth * dWidth/3 + vtLen * dLen/4; ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; ptArrorArr[3] = ptRectArr[2] - vtWidth * dWidth/3 - vtLen * dLen/4; ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6; } else { ptArrorArr[0] = ptRectArr[1] - vtWidth * dWidth/3 + vtLen * dLen/4; ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; ptArrorArr[3] = ptRectArr[3] + vtWidth * dWidth/3 - vtLen * dLen/4; ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6; } } else { vtLen *= -1; ptArrorArr[0] = ptRectArr[3] + vtWidth * dWidth/3 + vtLen * dLen/4; ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; ptArrorArr[3] = ptRectArr[1] - vtWidth * dWidth/3 - vtLen * dLen/4; ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6; } tCurveEle.dWidth = dEdgeWidth; tCurveEle.idSubLay.setNull(); AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[0], ptArrorArr[1], ptArrorArr[1]); AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[1], ptArrorArr[2], ptArrorArr[2]); AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[2], ptArrorArr[3], ptArrorArr[3]); } } return Acad::eOk; } AcDbPolyline* THImpHvacOffset::MakeHorizArcuatePolyCurves() const { AcGePoint3dArray ptLeftArr, ptRightArr; if (!GetArcTwoSideKeyPt(ptLeftArr, ptRightArr, IsSingleLine())) return NULL; if (7 != ptLeftArr.length() || 7 != ptRightArr.length()) return NULL; AcGePlane planStd = GetStdPrjPlan(ptLeftArr[0]); double dBulge(0.0); AcDbPolyline* pPolyLine = new AcDbPolyline; pPolyLine->addVertexAt(0, ptLeftArr[0].convert2d(planStd)); dBulge = GetBulge(ptLeftArr[1], ptLeftArr[2], ptLeftArr[3]); pPolyLine->addVertexAt(1, ptLeftArr[1].convert2d(planStd), dBulge); dBulge = GetBulge(ptLeftArr[3], ptLeftArr[4], ptLeftArr[5]); pPolyLine->addVertexAt(2, ptLeftArr[3].convert2d(planStd), dBulge); pPolyLine->addVertexAt(3, ptLeftArr[5].convert2d(planStd)); pPolyLine->addVertexAt(4, ptLeftArr[6].convert2d(planStd)); pPolyLine->addVertexAt(5, ptRightArr[6].convert2d(planStd)); dBulge = GetBulge(ptRightArr[5], ptRightArr[4], ptRightArr[3]); pPolyLine->addVertexAt(6, ptRightArr[5].convert2d(planStd), dBulge); dBulge = GetBulge(ptRightArr[3], ptRightArr[2], ptRightArr[1]); pPolyLine->addVertexAt(7, ptRightArr[3].convert2d(planStd), dBulge); pPolyLine->addVertexAt(8, ptRightArr[1].convert2d(planStd)); pPolyLine->addVertexAt(9, ptRightArr[0].convert2d(planStd)); pPolyLine->setClosed(Adesk::kTrue); pPolyLine->setNormal(planStd.normal()); pPolyLine->setElevation(TAuxTools::GetPlaneEle(planStd)); return pPolyLine; } AcDbPolyline* THImpHvacOffset::MakeHorizLinearPolyCurves() const { AcGePoint3dArray ptArr; GetMidKeyPoints(ptArr, IsSingleLine()); if (8 != ptArr.length()) return NULL; AcGePlane planStd = GetStdPrjPlan(ptArr[0]); AcDbPolyline* pPolyLine = new AcDbPolyline; int i(0); for (i = 0; i < ptArr.length(); i++) { pPolyLine->addVertexAt(i, ptArr[i].convert2d(planStd)); } pPolyLine->setClosed(Adesk::kTrue); pPolyLine->setNormal(planStd.normal()); pPolyLine->setElevation(TAuxTools::GetPlaneEle(planStd)); return pPolyLine; } AcDbPolyline* THImpHvacOffset::MakeSideVertRectPolyCurves() const { AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); BOOL bSingleLine(IsSingleLine()); // if (bSingleLine) // { // double dHideEle(0.0); // 遮挡标高 // m_pXDataMap->GetAt(HVAC_Elevation, dHideEle); // ptStart.z = ptEnd.z = dHideEle; // // } AcGePoint3d ptMid = TAuxTools::Mid(ptStart, ptEnd); AcGePlane planStd = GetStdPrjPlan(ptMid); AcGePoint3dArray ptUpArr, ptDownArr; GetTwoSideKeyPoints(ptUpArr, ptDownArr, bSingleLine); if (8 != ptUpArr.length() || 8 != ptDownArr.length()) return FALSE; int nEnd1(0), nEnd2(0); GetEndPointIndex(ptUpArr, nEnd1, nEnd2); AcDbPolyline* pPolyLine = new AcDbPolyline; pPolyLine->addVertexAt(0, ptUpArr[nEnd1].convert2d(planStd)); pPolyLine->addVertexAt(1, ptDownArr[nEnd1].convert2d(planStd)); pPolyLine->addVertexAt(2, ptDownArr[nEnd2].convert2d(planStd)); pPolyLine->addVertexAt(3, ptUpArr[nEnd2].convert2d(planStd)); pPolyLine->setClosed(Adesk::kTrue); pPolyLine->setElevation(TAuxTools::GetPlaneEle(planStd)); pPolyLine->setNormal(planStd.normal()); return pPolyLine; } AcDbPolyline* THImpHvacOffset::MakeSideVertCirclePolyCurves() const { AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); // BOOL bSingleLine(IsSingleLine()); // if (bSingleLine) // { // double dHideEle(0.0); // 遮挡标高 // m_pXDataMap->GetAt(HVAC_Elevation, dHideEle); // ptStart.z = ptEnd.z = dHideEle; // } double dRadius(0.0); m_pXDataMap->GetAt(HOFF_Diameter, dRadius); dRadius *= 0.5; AcGePoint3d ptMid = TAuxTools::Mid(ptStart, ptEnd); AcGePlane planStd = GetStdPrjPlan(ptMid); ptStart = ptStart.orthoProject(planStd); ptEnd = ptEnd.orthoProject(planStd); AcGeVector3d vtNormal = normal(); AcGeVector3d vtDirect = ptEnd - ptStart; vtDirect.normalize(); // 起始半圆各点 AcGePoint3d ptStartCirSta, ptStartCirMid, ptStartCirEnd; ptStartCirSta = ptStart + dRadius * vtNormal; ptStartCirMid = ptStart - dRadius * vtDirect; ptStartCirEnd = ptStart - dRadius * vtNormal; AcGePoint3d ptEndCirSta, ptEndCirMid, ptEndCirEnd; ptEndCirSta = ptEnd + dRadius * vtNormal; ptEndCirEnd = ptEnd - dRadius * vtNormal; ptEndCirMid = ptEnd + dRadius * vtDirect; AcDbPolyline* pPolyLine = new AcDbPolyline; double dBulge(0.0); pPolyLine->addVertexAt(0, ptStartCirSta.convert2d(planStd)); dBulge = GetBulge(ptEndCirSta, ptEndCirMid, ptEndCirEnd); pPolyLine->addVertexAt(1, ptEndCirSta.convert2d(planStd), dBulge); pPolyLine->addVertexAt(2, ptEndCirEnd.convert2d(planStd)); dBulge = GetBulge(ptStartCirEnd, ptStartCirMid, ptStartCirSta); pPolyLine->addVertexAt(3, ptStartCirEnd.convert2d(planStd), dBulge); pPolyLine->setClosed(Adesk::kTrue); pPolyLine->setNormal(planStd.normal()); pPolyLine->setElevation(TAuxTools::GetPlaneEle(planStd)); return pPolyLine; } AcDbPolyline* THImpHvacOffset::MakeFaceVertPolyCurves() const { BOOL bSingleLine(IsSingleLine()); AcGePoint3dArray ptUpArr, ptDownArr; GetTwoSideKeyPoints(ptUpArr, ptDownArr, bSingleLine); if (8 != ptUpArr.length() || 8 != ptDownArr.length()) return NULL; AcGePoint3d ptStart, ptEnd, ptMid; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); // if (bSingleLine) // { // double dHideEle(0.0); // 遮挡标高 // m_pXDataMap->GetAt(HVAC_Elevation, dHideEle); // ptStart.z = ptEnd.z = dHideEle; // } ptMid = TAuxTools::Mid(ptStart, ptEnd); AcGePlane planStd = GetStdPrjPlan(ptMid); AcDbPolyline* pPolyLine = new AcDbPolyline; pPolyLine->addVertexAt(0, ptUpArr[1].convert2d(planStd)); pPolyLine->addVertexAt(1, ptUpArr[4].convert2d(planStd)); pPolyLine->addVertexAt(2, ptDownArr[4].convert2d(planStd)); pPolyLine->addVertexAt(3, ptDownArr[1].convert2d(planStd)); pPolyLine->setClosed(Adesk::kTrue); pPolyLine->setNormal(planStd.normal()); pPolyLine->setElevation(TAuxTools::GetPlaneEle(planStd)); return pPolyLine; } BOOL THImpHvacOffset::MakeHorizArcuateCurvesFaces( AcDbVoidPtrArray& arFaces ) const { AcGePoint3dArray ptLeftArr, ptRightArr; GetAllMinAnglePt(ptLeftArr, ptRightArr, IsSingleLine()); if (ptLeftArr.length() != ptRightArr.length() || 7 > ptLeftArr.length()) return FALSE; int i(0); for (i = 0; i < ptLeftArr.length()-1; i++) { AcDbFace* pFace = new AcDbFace; pFace->setVertexAt(0, ptLeftArr[i]); pFace->setVertexAt(1, ptLeftArr[i+1]); pFace->setVertexAt(2, ptRightArr[i+1]); pFace->setVertexAt(3, ptRightArr[i]); arFaces.append(pFace); } return arFaces.length() > 0; } BOOL THImpHvacOffset::MakeHorizLinearCurvesFaces( AcDbVoidPtrArray& arFaces ) const { AcGePoint3dArray ptArr; GetMidKeyPoints(ptArr, IsSingleLine()); if (8 != ptArr.length()) return FALSE; AcDbFace* pFace = new AcDbFace; pFace->setVertexAt(0, ptArr[0]); pFace->setVertexAt(1, ptArr[1]); pFace->setVertexAt(2, ptArr[2]); pFace->setVertexAt(3, ptArr[7]); arFaces.append(pFace); pFace = new AcDbFace; pFace->setVertexAt(0, ptArr[2]); pFace->setVertexAt(1, ptArr[3]); pFace->setVertexAt(2, ptArr[6]); pFace->setVertexAt(3, ptArr[7]); arFaces.append(pFace); pFace = new AcDbFace; pFace->setVertexAt(0, ptArr[3]); pFace->setVertexAt(1, ptArr[4]); pFace->setVertexAt(2, ptArr[5]); pFace->setVertexAt(3, ptArr[6]); arFaces.append(pFace); return arFaces.length() > 0; } BOOL THImpHvacOffset::MakeSideVertRectCurvesFaces( AcDbVoidPtrArray& arFaces ) const { AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); // if (bSingleLine) // { // double dHideEle(0.0); // 遮挡标高 // m_pXDataMap->GetAt(HVAC_Elevation, dHideEle); // ptStart.z = ptEnd.z = dHideEle; // } AcGePoint3d ptMid = TAuxTools::Mid(ptStart, ptEnd); AcGePlane planStd = GetStdPrjPlan(ptMid); AcGePoint3dArray ptUpArr, ptDownArr; BOOL bSingleLine(IsSingleLine()); GetTwoSideKeyPoints(ptUpArr, ptDownArr, bSingleLine); if (8 != ptUpArr.length() || 8 != ptDownArr.length()) return FALSE; int nEnd1(0), nEnd2(0); GetEndPointIndex(ptUpArr, nEnd1, nEnd2); AcDbFace* pFace = new AcDbFace; pFace->setVertexAt(0, ptUpArr[nEnd1].orthoProject(planStd)); pFace->setVertexAt(1, ptDownArr[nEnd1].orthoProject(planStd)); pFace->setVertexAt(2, ptDownArr[nEnd2].orthoProject(planStd)); pFace->setVertexAt(3, ptUpArr[nEnd2].orthoProject(planStd)); arFaces.append(pFace); return arFaces.length() > 0; } BOOL THImpHvacOffset::MakeSideVertCircleCurvesFaces( AcDbVoidPtrArray& arFaces ) const { AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); // BOOL bSingleLine(IsSingleLine()); // if (bSingleLine) // { // double dHideEle(0.0); // 遮挡标高 // m_pXDataMap->GetAt(HVAC_Elevation, dHideEle); // ptStart.z = ptEnd.z = dHideEle; // } double dRadius(0.0); m_pXDataMap->GetAt(HOFF_Diameter, dRadius); dRadius *= 0.5; AcGePoint3d ptMid = TAuxTools::Mid(ptStart, ptEnd); AcGePlane planStd = GetStdPrjPlan(ptMid); ptStart = ptStart.orthoProject(planStd); ptEnd = ptEnd.orthoProject(planStd); AcGeVector3d vtNormal = normal(); AcGeVector3d vtDirect = ptEnd - ptStart; vtDirect.normalize(); // 起始半圆各点 AcGePoint3d ptStartCirSta, ptStartCirMid, ptStartCirEnd; ptStartCirSta = ptStart + dRadius * vtNormal; ptStartCirMid = ptStart - dRadius * vtDirect; ptStartCirEnd = ptStart - dRadius * vtNormal; AcGePoint3d ptEndCirSta, ptEndCirMid, ptEndCirEnd; ptEndCirSta = ptEnd + dRadius * vtNormal; ptEndCirEnd = ptEnd - dRadius * vtNormal; ptEndCirMid = ptEnd + dRadius * vtDirect; // 中间矩形Face AcDbFace* pFace = new AcDbFace; pFace->setVertexAt(0, ptStartCirSta); pFace->setVertexAt(1, ptStartCirEnd); pFace->setVertexAt(2, ptEndCirEnd); pFace->setVertexAt(3, ptEndCirSta); arFaces.append(pFace); double dMinAngle(TAuxTools::GetMinDiffAngle()); int nPart = (int)(PI / dMinAngle) + 1; dMinAngle = PI / nPart; // 首端半圆 AcGePoint3d ptNow = ptStartCirSta; AcGeVector3d vtRotAixs = AcGeVector3d(ptStartCirMid - ptStart).crossProduct(vtNormal); int i(0); for (i = 0; i < nPart; i++) { AcDbFace* pFace = new AcDbFace; pFace->setVertexAt(0, ptStart); pFace->setVertexAt(1, ptNow); ptNow.rotateBy(-dMinAngle, vtRotAixs, ptStart); pFace->setVertexAt(2, ptNow); pFace->setVertexAt(3, ptStart); arFaces.append(pFace); } // 末端半圆 ptNow = ptEndCirSta; vtRotAixs = AcGeVector3d(ptEndCirMid - ptEnd).crossProduct(vtNormal); for (i = 0; i < nPart; i++) { AcDbFace* pFace = new AcDbFace; pFace->setVertexAt(0, ptEnd); pFace->setVertexAt(1, ptNow); ptNow.rotateBy(-dMinAngle, vtRotAixs, ptEnd); pFace->setVertexAt(2, ptNow); pFace->setVertexAt(3, ptEnd); arFaces.append(pFace); } return arFaces.length() > 0; } BOOL THImpHvacOffset::MakeFaceVertCurvesFaces( AcDbVoidPtrArray& arFaces ) const { BOOL bSingleLine(IsSingleLine()); AcGePoint3dArray ptUpArr, ptDownArr; GetTwoSideKeyPoints(ptUpArr, ptDownArr, bSingleLine); if (8 != ptUpArr.length() || 8 != ptDownArr.length()) return FALSE; AcGePoint3d ptStart, ptEnd, ptMid; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); // if (bSingleLine) // { // double dHideEle(0.0); // 遮挡标高 // m_pXDataMap->GetAt(HVAC_Elevation, dHideEle); // ptStart.z = ptEnd.z = dHideEle; // } ptMid = TAuxTools::Mid(ptStart, ptEnd); AcGePlane planStd = GetStdPrjPlan(ptMid); AcDbFace* pFace = new AcDbFace; pFace->setVertexAt(0, ptUpArr[1].orthoProject(planStd)); pFace->setVertexAt(1, ptUpArr[4].orthoProject(planStd)); pFace->setVertexAt(2, ptDownArr[4].orthoProject(planStd)); pFace->setVertexAt(3, ptDownArr[1].orthoProject(planStd)); arFaces.append(pFace); return arFaces.length() > 0; } /* 0━7 ┃ \ ┃ \ S ┃ \ ┃ \ ┃ \ 1━2 6━ 5 \ ┃ \ ┃ \ ┃ \ ┃ E \ ┃ 3━4 */ void THImpHvacOffset::GetMidKeyPoints( AcGePoint3dArray &ptArr, BOOL bSingleLine /*= FALSE*/ ) const { ASSERT(NULL != m_pXDataMap); AcGePoint3d ptS, ptE; m_pXDataMap->GetAt(HOFF_StartPoint, ptS); m_pXDataMap->GetAt(HOFF_EndPoint, ptE); AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()); AcGeVector3d vtStaSide(vtStart), vtEndSide(vtEnd); AcGeVector3d vtPerl = normal(); vtStaSide.rotateBy(PI*0.5, vtPerl); vtEndSide.rotateBy(PI*0.5, vtPerl); double dStaWidth(0.0), dEndWidth(0.0), dHeigh(0.0), dPluse(0); m_pXDataMap->GetAt(HOFF_Thick, dHeigh); m_pXDataMap->GetAt(HVAC_PlusEdge, dPluse); if (bSingleLine) { GetGlobalContext()->GetAt(KEY_HIDEWIDTH, dStaWidth); // 遮挡宽度 dEndWidth = dStaWidth; // double dHideEle(0.0); // 遮挡标高 // m_pXDataMap->GetAt(HVAC_Elevation, dHideEle); // ptS.z = ptE.z = dHideEle; } else { m_pXDataMap->GetAt(HOFF_StartWidth, dStaWidth); m_pXDataMap->GetAt(HOFF_EndWidth, dEndWidth); HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); if (eSectType == eCircular) dEndWidth = dStaWidth; } AcGePoint3d ptTempArr[8]; ptTempArr[0] = ptS - dStaWidth * 0.5 * vtStaSide; ptTempArr[1] = ptTempArr[0] + dStaWidth * vtStaSide; ptTempArr[4] = ptE - dEndWidth * 0.5 * vtEndSide; ptTempArr[5] = ptTempArr[4] + dEndWidth * vtEndSide; ptTempArr[2] = ptTempArr[1] - dPluse * vtStart; ptTempArr[7] = ptTempArr[0] - dPluse * vtStart; ptTempArr[3] = ptTempArr[4] - dPluse * vtEnd; ptTempArr[6] = ptTempArr[5] - dPluse * vtEnd; int i(0); for (i = 0; i < 8; i++) { ptArr.append(ptTempArr[i]); } } BOOL THImpHvacOffset::GetTwoSideKeyPoints( AcGePoint3dArray &ptUpArr, AcGePoint3dArray &ptDownArr, BOOL bSingleLine /*= FALSE*/ ) const { GetMidKeyPoints(ptUpArr, bSingleLine); if (ptUpArr.length() < 1) return FALSE; AcGeVector3d vtPerl = normal(); double dThick(0.0); m_pXDataMap->GetAt(HOFF_Thick, dThick); HvacSectType eSect = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect); if (eSect == eCircular) m_pXDataMap->GetAt(HOFF_Diameter, dThick); AcGeVector3d vtOffSet = dThick * vtPerl * 0.5; int i(0); for (i = 0; i < ptUpArr.length(); i++) { ptDownArr.append(ptUpArr[i] - vtOffSet); ptUpArr[i] += vtOffSet; } return TRUE; } BOOL THImpHvacOffset::GetArcBaseKeyPt( AcGePoint3dArray &ptKeyArr ) const { AcGePoint3d ptStart, ptEnd, ptMid; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); ptMid = TAuxTools::Mid(ptStart, ptEnd); AcGeVector3d vtUserZAixs = normal(); AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()); double dPluse(0.0); m_pXDataMap->GetAt(HVAC_PlusEdge, dPluse); AcGePoint3d ptStartArc = ptStart - dPluse * vtStart; // 起始端弧开始点 AcGePoint3d ptEndArc = ptEnd - dPluse * vtEnd; //末端弧开始点 // 起始端弧 AcGeVector3d vtStartPer(vtStart); vtStartPer.rotateBy(PI * 0.5, vtUserZAixs); AcGeLine3d lineStaPer(ptStartArc, ptStartArc + 100 * vtStartPer); AcGePoint3d ptStaMid = TAuxTools::Mid(ptStartArc, ptMid); AcGeVector3d vtMidPer = ptEndArc - ptStartArc; vtMidPer.rotateBy(PI * 0.5, vtUserZAixs); vtMidPer.normalize(); AcGeLine3d lineStartMidPer(ptStaMid, ptStaMid + 100 * vtMidPer); AcGePoint3d ptStaCenter; // 起始端弧圆心 if (lineStaPer.intersectWith(lineStartMidPer, ptStaCenter) != Adesk::kTrue) return FALSE; AcGeVector3d vtStartArc = ptStaMid - ptStaCenter; if (vtStartArc.angleTo(vtStart) < PI * 0.5) vtStartArc *= -1; vtStartArc.normalize(); double dStartRadius = ptStartArc.distanceTo(ptStaCenter); AcGePoint3d ptStarArcMid = ptStaCenter + dStartRadius * vtStartArc; // 起始端弧中点 // 末端弧 AcGeVector3d vtEndPer(vtEnd); vtEndPer.rotateBy(PI * 0.5, vtUserZAixs); AcGeLine3d lineEndPer(ptEndArc, ptEndArc + 100 * vtEndPer); AcGePoint3d ptEndMid = TAuxTools::Mid(ptEndArc, ptMid); AcGeLine3d lineEndMidPer(ptEndMid, ptEndMid + 100 * vtMidPer); AcGePoint3d ptEndCenter; // 末端弧圆心 if (lineEndPer.intersectWith(lineEndMidPer, ptEndCenter) != Adesk::kTrue) return FALSE; AcGeVector3d vtEndArc = ptEndMid - ptEndCenter; if (vtEndArc.angleTo(vtEnd) < PI * 0.5) vtEndArc *= -1; vtEndArc.normalize(); double dEndRadius = ptEndArc.distanceTo(ptEndCenter); AcGePoint3d ptEndArcMid = ptEndCenter + dEndRadius * vtEndArc; // 末端弧中点 ptKeyArr.append(ptStart); ptKeyArr.append(ptStartArc); ptKeyArr.append(ptStarArcMid); ptKeyArr.append(ptMid); ptKeyArr.append(ptEndArcMid); ptKeyArr.append(ptEndArc); ptKeyArr.append(ptEnd); return TRUE; } BOOL THImpHvacOffset::GetArcTwoSideKeyPt( AcGePoint3dArray &ptArrLeft, AcGePoint3dArray &ptArrRight, BOOL bSingleLine /*= FALSE*/ ) const { AcGePoint3dArray ptBaseArr; if (!GetArcBaseKeyPt(ptBaseArr)) return FALSE; AcGePoint3d ptStart, ptEnd, ptMid; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); ptMid = TAuxTools::Mid(ptStart, ptEnd); double dHalfStartWidth(0.0), dHalfEndWidth(0.0); if (bSingleLine) { GetGlobalContext()->GetAt(KEY_HIDEWIDTH, dHalfStartWidth); // 遮挡宽度 dHalfEndWidth = dHalfStartWidth; // double dHideEle(0.0); // 遮挡标高 // m_pXDataMap->GetAt(HVAC_Elevation, dHideEle); // ptStart.z = ptEnd.z = ptMid.z = dHideEle; // // int i(0); // for (i = 0; i < ptBaseArr.length(); i++) // { // ptBaseArr[i].z = dHideEle; // } } else { m_pXDataMap->GetAt(HOFF_StartWidth, dHalfStartWidth); m_pXDataMap->GetAt(HOFF_EndWidth, dHalfEndWidth); HvacSectType eSectType = eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType); if (eSectType == eCircular) m_pXDataMap->GetAt(HOFF_Diameter, dHalfEndWidth); } dHalfStartWidth *= 0.5; dHalfEndWidth *= 0.5; AcGeVector3d vtUserZAixs = normal(); AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()); AcGeVector3d vtMidPer = ptEnd - ptStart; vtMidPer.rotateBy(PI * 0.5, vtUserZAixs); vtMidPer.normalize(); AcGeVector3d vtStartPer(vtStart), vtEndPer(vtEnd); vtStartPer.rotateBy(PI * 0.5, vtUserZAixs); vtEndPer.rotateBy(PI * 0.5, vtUserZAixs); // 左边（从起始端法向方向 往末端法向看） double dEverWidth = (dHalfStartWidth + dHalfEndWidth) * 0.5; AcGeCircArc3d arc(ptBaseArr[1], ptBaseArr[2], ptBaseArr[3]); AcGePoint3d ptCenter = arc.center(); AcGeVector3d vtMid = ptMid - ptCenter; vtMid.normalize(); AcGeVector3d vtStartMid = ptBaseArr[2] - ptCenter; // 起始端弧中点到圆心的向量 vtStartMid.normalize(); if (vtStartMid.angleTo(vtStartPer) > PI * 0.5) { vtStartMid *= -1; vtMid *= -1; } ptArrLeft.append(ptStart - dHalfStartWidth * vtStartPer); ptArrLeft.append(ptBaseArr[1] - dHalfStartWidth * vtStartPer); ptArrLeft.append(ptBaseArr[2] - dEverWidth * vtStartMid); ptArrLeft.append(ptMid - dHalfEndWidth * vtMid); arc.set(ptBaseArr[3], ptBaseArr[4], ptBaseArr[5]); ptCenter = arc.center(); AcGeVector3d vtEndMid = ptBaseArr[4] - ptCenter; // 末端弧中点到圆心的向量 vtEndMid.normalize(); if (vtEndMid.angleTo(vtEndPer) > PI * 0.5) { vtEndMid *= -1; } ptArrLeft.append(ptBaseArr[4] + dHalfEndWidth * vtEndMid); ptArrLeft.append(ptBaseArr[5] + dHalfEndWidth * vtEndPer); ptArrLeft.append(ptEnd + dHalfEndWidth * vtEndPer); // 右边 vtStartMid *= -1; vtMid *= -1; vtEndMid *= -1; ptArrRight.append(ptStart + dHalfStartWidth * vtStartPer); ptArrRight.append(ptBaseArr[1] + dHalfStartWidth * vtStartPer); ptArrRight.append(ptBaseArr[2] - dEverWidth * vtStartMid); ptArrRight.append(ptMid - dHalfEndWidth * vtMid); ptArrRight.append(ptBaseArr[4] + dHalfEndWidth * vtEndMid); ptArrRight.append(ptBaseArr[5] - dHalfEndWidth * vtEndPer); ptArrRight.append(ptEnd - dHalfEndWidth * vtEndPer); return TRUE; } void THImpHvacOffset::GetAllMinAnglePt( AcGePoint3dArray &ptArrLeftPart, AcGePoint3dArray &ptArrRightPart, BOOL bSingleLine /*= FALSE*/ ) const { AcGePoint3dArray ptLeftArr, ptRightArr; if (!GetArcTwoSideKeyPt(ptLeftArr, ptRightArr, bSingleLine)) return; if (7 != ptLeftArr.length() || 7 != ptRightArr.length()) return; AcGeVector3d vtNormal = normal(); double dMinAngle(TAuxTools::GetMinDiffAngle()); // 首端法兰边直部分 ptArrLeftPart.append(ptLeftArr[0]); ptArrLeftPart.append(ptLeftArr[1]); ptArrRightPart.append(ptRightArr[0]); ptArrRightPart.append(ptRightArr[1]); // 起始端左侧 AcGeCircArc3d arcStartLeft(ptLeftArr[1], ptLeftArr[2], ptLeftArr[3]); AcGePoint3d ptStaLeftCent = arcStartLeft.center(); double dStaLeftAngle = arcStartLeft.endAng() - arcStartLeft.startAng(); int nStartLeftPartNum = int(dStaLeftAngle / dMinAngle) + 1; // 起始端右侧 AcGeCircArc3d arcStartRight(ptRightArr[1], ptRightArr[2], ptRightArr[3]); AcGePoint3d ptStaRightCent = arcStartRight.center(); double dStaRightAngle = arcStartRight.endAng() - arcStartRight.startAng(); int nStartRightPartNum = int(dStaRightAngle / dMinAngle) + 1; // 按最大数目划分 int nStartMaxNum = nStartLeftPartNum > nStartRightPartNum ? nStartLeftPartNum : nStartRightPartNum; double dStartLeftMinAngle = dStaLeftAngle / nStartMaxNum; DOUBLE dStartRightMinAngle = dStaRightAngle / nStartMaxNum; AcGePoint3d ptLeftNow, ptRightNow; ptLeftNow = ptLeftArr[1]; ptRightNow = ptRightArr[1]; int i(0); for (i = 0; i < nStartMaxNum - 1; i++) { ptLeftNow.rotateBy(dStartLeftMinAngle, -vtNormal, ptStaLeftCent); ptRightNow.rotateBy(dStartRightMinAngle, -vtNormal, ptStaRightCent); ptArrLeftPart.append(ptLeftNow); ptArrRightPart.append(ptRightNow); } ptArrLeftPart.append(ptLeftArr[3]); ptArrRightPart.append(ptRightArr[3]); // 末端左侧 AcGeCircArc3d arcEndLeft(ptLeftArr[3], ptLeftArr[4], ptLeftArr[5]); AcGePoint3d ptEndLeftCent = arcEndLeft.center(); double dEndLeftAngle = arcEndLeft.endAng() - arcEndLeft.startAng(); int nEndLeftPartNum = int(dEndLeftAngle / dMinAngle) + 1; double dEndLeftMinAngle = dEndLeftAngle / nEndLeftPartNum; // 末端右侧 AcGeCircArc3d arcEndRight(ptRightArr[3], ptRightArr[4], ptRightArr[5]); AcGePoint3d ptEndRightCent = arcEndRight.center(); double dEndRightAngle = arcEndRight.endAng() - arcEndRight.startAng(); int nEndRightPartNum = int(dEndRightAngle / dMinAngle) + 1; double dEndRightMinAngle = dEndRightAngle / nEndRightPartNum; // 按最大数目划分 int nEndMaxNum = nEndLeftPartNum > nEndRightPartNum ? nEndLeftPartNum : nEndRightPartNum; dEndLeftMinAngle = dEndLeftAngle / nEndMaxNum; dEndRightMinAngle = dEndRightAngle / nEndMaxNum; ptLeftNow = ptLeftArr[3]; ptRightNow = ptRightArr[3]; for (i = 0; i < nEndMaxNum - 1; i++) { ptLeftNow.rotateBy(dEndLeftMinAngle, vtNormal, ptEndLeftCent); ptRightNow.rotateBy(dEndRightMinAngle, vtNormal, ptEndRightCent); ptArrLeftPart.append(ptLeftNow); ptArrRightPart.append(ptRightNow); } // 末端法兰部分 ptArrLeftPart.append(ptLeftArr[5]); ptArrLeftPart.append(ptLeftArr[6]); ptArrRightPart.append(ptRightArr[5]); ptArrRightPart.append(ptRightArr[6]); } BOOL THImpHvacOffset::IsCanDraw() const { if (NULL == m_pXDataMap) return FALSE; // 增加控制形态判断。2010.04.08 if (!IsHorzAlignment() && !IsSideVertAlignment() && !IsFaceVertAlignment()) return FALSE; AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); if (ptStart.distanceTo(ptEnd) < 1e-3) return FALSE; // 首尾法向量必须不同向平行 AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()); if (!vtStart.isParallelTo(vtEnd) || vtStart.isCodirectionalTo(vtEnd)) return FALSE; // 首尾点方向与首尾法向量判断 AcGeVector3d vtDirect = ptEnd - ptStart; double dMaxAngle(PI * 0.5 - 0.1), dMinAngle(1e-3); if (vtDirect.angleTo(vtEnd) > dMaxAngle || vtDirect.angleTo(vtEnd) < dMinAngle) return FALSE; HvacOffsetType eType = eArcuateLink; m_pXDataMap->GetAt(HOFF_Type, (int&)eType); if (eType == eArcuateLink) { AcGePoint3dArray ptLeftArr, ptRightArr; if (!GetArcTwoSideKeyPt(ptLeftArr, ptRightArr)) return FALSE; double dSmallDist = ptLeftArr[3].distanceTo(ptStart); double dBigDist = ptLeftArr[4].distanceTo(ptStart); if (dBigDist < dSmallDist) return FALSE; // 因为起始端有可能有变径，右侧也判断一下 dSmallDist = ptRightArr[1].distanceTo(ptStart); dBigDist = ptRightArr[2].distanceTo(ptStart); if (dBigDist < dSmallDist) return FALSE; } return TRUE; } // 注意：pXMap == NULL表示不想得到返回值，只是判断数据是否合理 // 先取出m_pXDataMap中数据进行判断是否合理，返回判断结果 BOOL THImpHvacOffset::IsValid(TDbXDataMap* pXMap) { ASSERT(NULL != m_pXDataMap); AcGePoint3d ptOrigEnd, ptEnd; m_pXDataMap->GetAt(HOFF_EndPoint, ptOrigEnd); HvacOffsetComType eType = TDb::eOffComRatio; m_pXDataMap->GetAt(HOFF_ComputeType, (int&)eType); if (TDb::eOffComLength == eType) ptEnd = GetEndPtByLength(); else ptEnd = GetEndPointByAngle(); m_pXDataMap->SetAt(HOFF_EndPoint, ptEnd); if (IsCanDraw()) { if (NULL != m_pOwnerEnt) UpdateInterfaceRec(m_pOwnerEnt->objectId(), ptOrigEnd, ptEnd); if (NULL != pXMap) pXMap->SetAt(HOFF_EndPoint, ptEnd); return TRUE; } else m_pXDataMap->SetAt(HOFF_EndPoint, ptOrigEnd); return FALSE; } AcDbObjectId THImpHvacOffset::GetBaseLayerId() const { AcDbObjectId idBaseLayer(AcDbObjectId::kNull); TDbFittingBase* pFit = TDbFittingBase::cast(m_pOwnerEnt); if (NULL != pFit) idBaseLayer = pFit->CenterLayer(); return idBaseLayer; } double THImpHvacOffset::GetEdgeLineWidth() const { BOOL bShow(FALSE); GetGlobalContext( HVAC_SHOWWIDTH, bShow); // add by hh 2011-01-05 从图纸中读取加粗标识 避免全局参数对不同的图纸间的影响 TAuxTools::GetTHvacDataFromDwg(HVAC_SHOWWIDTH, bShow); if (!bShow) return 0.0; ASSERT(NULL != m_pXDataMap); double dWidth(0.0); m_pXDataMap->GetAt(HVAC_EdgeWidth, dWidth); return dWidth; } double THImpHvacOffset::GetCentLineWidth() const { BOOL bShow(FALSE); GetGlobalContext( HVAC_SHOWWIDTH, bShow); // add by hh 2011-01-05 从图纸中读取加粗标识 避免全局参数对不同的图纸间的影响 TAuxTools::GetTHvacDataFromDwg(HVAC_SHOWWIDTH, bShow); if (!bShow) return 0.0; ASSERT(NULL != m_pXDataMap); double dWidth(0.0); m_pXDataMap->GetAt(HVAC_CentWidth, dWidth); return dWidth; } double THImpHvacOffset::GetEndLineWidth() const { BOOL bShow(FALSE); GetGlobalContext( HVAC_SHOWWIDTH, bShow); // add by hh 2011-01-05 从图纸中读取加粗标识 避免全局参数对不同的图纸间的影响 TAuxTools::GetTHvacDataFromDwg(HVAC_SHOWWIDTH, bShow); if (!bShow) return 0.0; ASSERT(NULL != m_pXDataMap); double dWidth(0.0); m_pXDataMap->GetAt(HVAC_EndWidth, dWidth); return dWidth; } int THImpHvacOffset::GetXBaseShell( TXShell& xShell ) { ASSERT(NULL != m_pXDataMap); //设置精度，并恢复精度 double dOrigMinDiffAng = PI/12, dTempMinDiffAng = PI/4; GetGlobalContext()->GetAt(KEY_MINDIFFANG, dOrigMinDiffAng); GetGlobalContext()->SetAt(KEY_MINDIFFANG, dTempMinDiffAng); AcDbVoidPtrArray entSet; XExplodeStream dc(entSet); ExplodeOrDraw3d(dc); int nLen = entSet.length(); int i(0); AcDbEntity *pEnt = NULL; for(i = 0; i < nLen; i++) { pEnt = (AcDbEntity*)entSet[i]; if(NULL != pEnt && pEnt->isKindOf(AcDbFace::desc())) { xShell.AppendFace((AcDbFace*)pEnt); } } //计算开始和END端部的face GetEndSideShell(xShell); GetGlobalContext()->SetAt(KEY_MINDIFFANG, dOrigMinDiffAng); return 1; } int THImpHvacOffset::GetEndSideShell( TXShell& xShell ) { ASSERT(NULL != m_pXDataMap); AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGeVector3d vtStart = StartVect(); AcGeVector3d vtEnd = EndVect(); AcGeVector3d vtNormal = normal(); HvacSectType eSect = TDb::eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect); if (eSect == TDb::eRectangular) { double dStartWidh(0.0), dEndWidth(0.0), dThick(0.0); m_pXDataMap->GetAt(HOFF_StartWidth, dStartWidh); m_pXDataMap->GetAt(HOFF_EndWidth, dEndWidth); m_pXDataMap->GetAt(HOFF_Thick, dThick); TAuxTools::BuildRecFace(ptStart, dStartWidh, dThick, vtNormal, vtStart, xShell); TAuxTools::BuildRecFace(ptEnd, dEndWidth, dThick, vtNormal, vtEnd, xShell); } else if (eSect == TDb::eCircular) { double dDia(0.0); m_pXDataMap->GetAt(HOFF_Diameter, dDia); TAuxTools::BuildCirFace(ptStart, dDia, vtNormal, vtStart, xShell); TAuxTools::BuildCirFace(ptEnd, dDia, vtNormal, vtEnd, xShell); } return 1; } int THImpHvacOffset::GetBodyBox( AcDbExtents& ext ) { ASSERT(NULL != m_pXDataMap); //设置精度，并恢复精度 double dOrigMinDiffAng = PI/12, dTempMinDiffAng = PI/4; GetGlobalContext()->GetAt(KEY_MINDIFFANG, dOrigMinDiffAng); GetGlobalContext()->SetAt(KEY_MINDIFFANG, dTempMinDiffAng); AcGePoint3dArray ptArr; GetMidKeyPoints(ptArr); TAuxTools::BuildMinRectangle(ptArr, ext); GetGlobalContext()->SetAt(KEY_MINDIFFANG, dOrigMinDiffAng); return 1; } double THImpHvacOffset::GetAngle() { ASSERT(NULL != m_pXDataMap); // 基本参数 HvacOffsetType eType = TDb::eArcuateLink; m_pXDataMap->GetAt(HOFF_Type, (int&)eType); double dFlangPlus(0.0); m_pXDataMap->GetAt(HVAC_PlusEdge, dFlangPlus); AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGeVector3d vtStart, vtEnd, vtOffSet; m_pXDataMap->GetAt(HOFF_StartDir, vtStart); m_pXDataMap->GetAt(HOFF_EndDir, vtEnd); // 先反求角度，再根据角度求末点，角度不变 AcGePoint3d ptArcStart = ptStart - vtStart * dFlangPlus; AcGePoint3d ptArcEnd = ptEnd - vtEnd * dFlangPlus; double dAngle = (ptArcEnd - ptArcStart).angleTo(vtEnd); if (dAngle > PI*0.5) dAngle = PI - dAngle; if (TDb::eArcuateLink == eType) // 双弧Angle：表示弯头角度 { dAngle = PI*0.5 - dAngle; dAngle = PI - dAngle * 2; } return dAngle; } AcGePoint3d THImpHvacOffset::GetEndPointByAngle() { ASSERT(NULL != m_pXDataMap); // 基本参数 HvacOffsetType eType = TDb::eArcuateLink; m_pXDataMap->GetAt(HOFF_Type, (int&)eType); double dAngle(0.0), dFlangPlus(0.0); m_pXDataMap->GetAt(HVAC_PlusEdge, dFlangPlus); m_pXDataMap->GetAt(HOFF_Angle, dAngle); AcGePoint3d ptStart, ptEnd; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); AcGeVector3d vtStart, vtOffSet; m_pXDataMap->GetAt(HOFF_StartDir, vtStart); vtOffSet = ptEnd - ptStart; vtOffSet = vtOffSet.orthoProject(vtStart); // 求末点 double dPerlDist = vtOffSet.length(); // 向下偏移的距离 double dHorizLen(0.0); // 水平偏移距离 if (TDb::eArcuateLink == eType) // 双弧Angle：表示弯头角度 dHorizLen = dPerlDist / tan(dAngle * 0.5); // 水平偏移距离 else if (TDb::eLinearLink == eType) // 角接时，dAngle：表示倾斜角度 dHorizLen = dPerlDist / tan(dAngle); AcGePoint3d ptArcSta = ptStart - dFlangPlus * vtStart; // 弧开始点 ptEnd = ptArcSta + vtOffSet - (dHorizLen + dFlangPlus) * vtStart; return ptEnd; } AcGePoint3d THImpHvacOffset::GetEndPtByLength() { ASSERT(NULL != m_pXDataMap); // 基本参数 HvacOffsetType eType = TDb::eArcuateLink; m_pXDataMap->GetAt(HOFF_Type, (int&)eType); double dLength(0.0), dOffset(0.0), dFlangPlus(0.0); m_pXDataMap->GetAt(HVAC_PlusEdge, dFlangPlus); m_pXDataMap->GetAt(HOFF_Length, dLength); m_pXDataMap->GetAt(HOFF_Offset, dOffset); double dOffsetArcLength = dLength - 2 * dFlangPlus; if (dOffsetArcLength > 0.1) { double dAngle = atan(dOffset / dOffsetArcLength); if (TDb::eArcuateLink == eType) dAngle *= 2; m_pXDataMap->SetAt(HOFF_Angle, dAngle); return GetEndPointByAngle(); } return AcGePoint3d::kOrigin; } // 导出XML // CString THImpHvacOffset::GetXml() const // { // if (NULL == m_pXDataMap || NULL == m_pOwnerEnt) // return _T(""); // // int nValue(0); // double dValue(0.0); // int nSizePreci = 3; // 尺寸精度 // int nPtPreci = 6; // 位置精度 // int nWhPreci = 0; // 宽度、高度精度 // // TXmlTree xmlTree; // CString csText; // CString csX, csY, csZ; // AcGePoint3d pt; // AcGeVector3d vt; // POSITION posRoot = xmlTree.Insert(_T("ATS_DBHFITTING"), NULL, NULL); // { // xmlTree.SetAttribute(posRoot, _T("name"), _T("乙字弯")); // xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称")); // } // // POSITION posItemDrawStyle = xmlTree.Insert(_T("DrawStyle"), posRoot, NULL); // { // xmlTree.SetAttribute(posItemDrawStyle, _T("name"), _T("绘制样式")); // xmlTree.SetAttribute(posItemDrawStyle, _T("comment"), _T("绘制表现形式1:双弧,2:角接,3…")); // m_pXDataMap->GetAt(HOFF_Type, nValue); // csText.Format(_T("%d"), nValue); // xmlTree.SetItemText(posItemDrawStyle, csText); // } // // POSITION posItemSect = xmlTree.Insert(_T("SectionType"), posRoot, posItemDrawStyle); // { // xmlTree.SetAttribute(posItemSect, _T("name"), _T("截面类型")); // xmlTree.SetAttribute(posItemSect, _T("comment"), _T("截面的形状0:矩形,1:圆形")); // m_pXDataMap->GetAt(HVAC_SectType, nValue); // csText.Format(_T("%d"), nValue); // xmlTree.SetItemText(posItemSect, csText); // } // // POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemSect); // { // xmlTree.SetAttribute(posItemNorDir, _T("name"), _T("法向量")); // vt = normal(); // 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 posItemStartPt = xmlTree.Insert(_T("Start_point"), posRoot, posItemNorDir); // { // xmlTree.SetAttribute(posItemStartPt, _T("name"), _T("起点位置")); // m_pXDataMap->GetAt(HOFF_StartPoint, 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(posItemStartPt, csText); // } // // POSITION posItemStartDir = xmlTree.Insert(_T("Start_direction"), posRoot, posItemStartPt); // { // xmlTree.SetAttribute(posItemStartDir, _T("name"), _T("起点方向")); // m_pXDataMap->GetAt(HOFF_StartDir, 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(posItemStartDir, csText); // } // // POSITION posItemEndPt = xmlTree.Insert(_T("End_point"), posRoot, posItemStartDir); // { // xmlTree.SetAttribute(posItemEndPt, _T("name"), _T("终点位置")); // m_pXDataMap->GetAt(HOFF_EndPoint, 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(posItemEndPt, csText); // } // // POSITION posItemEndDir = xmlTree.Insert(_T("End_direction"), posRoot, posItemEndPt); // { // xmlTree.SetAttribute(posItemEndDir, _T("name"), _T("终点方向")); // m_pXDataMap->GetAt(HOFF_EndDir, 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(posItemEndDir, csText); // } // // POSITION posItemWidthStr = xmlTree.Insert(_T("Width_Start"), posRoot, posItemEndDir); // { // xmlTree.SetAttribute(posItemWidthStr, _T("name"), _T("起始端宽度")); // m_pXDataMap->GetAt(HOFF_StartWidth, dValue); // TAuxTools::DoubleToString(dValue, nWhPreci, csText); // xmlTree.SetItemText(posItemWidthStr, csText); // } // // POSITION posItemWidthEnd = xmlTree.Insert(_T("Width_End"), posRoot, posItemWidthStr); // { // xmlTree.SetAttribute(posItemWidthEnd, _T("name"), _T("终止端宽度")); // m_pXDataMap->GetAt(HOFF_EndWidth, dValue); // TAuxTools::DoubleToString(dValue, nWhPreci, csText); // xmlTree.SetItemText(posItemWidthEnd, csText); // } // // POSITION posItemHghStr = xmlTree.Insert(_T("Height_Start"), posRoot, posItemWidthEnd); // { // xmlTree.SetAttribute(posItemHghStr, _T("name"), _T("起始端高度")); // m_pXDataMap->GetAt(HOFF_Thick, dValue); // TAuxTools::DoubleToString(dValue, nWhPreci, csText); // xmlTree.SetItemText(posItemHghStr, csText); // } // // POSITION posItemHghEnd = xmlTree.Insert(_T("Height_End"), posRoot, posItemHghStr); // { // xmlTree.SetAttribute(posItemHghEnd, _T("name"), _T("终止端高度")); // m_pXDataMap->GetAt(HOFF_Thick, dValue); // ??? // TAuxTools::DoubleToString(dValue, nWhPreci, csText); // xmlTree.SetItemText(posItemHghEnd, csText); // } // // POSITION posPlusEdge = xmlTree.Insert(_T("PlusEdge"), posRoot, posItemHghEnd); // { // xmlTree.SetAttribute(posPlusEdge, _T("name"),_T("咬口法兰翻边余量")); // m_pXDataMap->GetAt(HVAC_PlusEdge, dValue); // TAuxTools::DoubleToString(dValue, 1, csText); // xmlTree.SetItemText(posPlusEdge, csText); // } // // POSITION posObjId = xmlTree.Insert(_T("Object_ID"), posRoot, posPlusEdge); // { // xmlTree.SetAttribute(posObjId, _T("name"),_T("ID")); // xmlTree.SetAttribute(posObjId, _T("comment"),_T("乙字弯ID")); // // csText.Format(_T("%ld"), 0x7FFFFFFF & m_pOwnerEnt->objectId().asOldId()); // xmlTree.SetItemText(posObjId, csText); // } // // CString csXml = xmlTree.GetXml(); // // return csXml; // } CString THImpHvacOffset::GetXml(const AcGeMatrix3d& mat) const { if (NULL == m_pXDataMap || NULL == m_pOwnerEnt) return _T(""); int nValue(0); double dValue(0.0); int nSizePreci = 3; // 尺寸精度 int nPtPreci = 6; // 位置精度 int nWhPreci = 0; // 宽度、高度精度 TXmlTree xmlTree; CString csText; CString csX, csY, csZ; AcGePoint3d pt; AcGeVector3d vt; POSITION posRoot = xmlTree.Insert(_T("ATS_DBHFITTING"), NULL, NULL); { xmlTree.SetAttribute(posRoot, _T("name"), _T("乙字弯")); xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称")); } POSITION posItemDrawStyle = xmlTree.Insert(_T("DrawStyle"), posRoot, NULL); { xmlTree.SetAttribute(posItemDrawStyle, _T("name"), _T("绘制样式")); xmlTree.SetAttribute(posItemDrawStyle, _T("comment"), _T("绘制表现形式1:双弧,2:角接,3…")); m_pXDataMap->GetAt(HOFF_Type, nValue); csText.Format(_T("%d"), nValue); xmlTree.SetItemText(posItemDrawStyle, csText); } POSITION posItemSect = xmlTree.Insert(_T("SectionType"), posRoot, posItemDrawStyle); { xmlTree.SetAttribute(posItemSect, _T("name"), _T("截面类型")); xmlTree.SetAttribute(posItemSect, _T("comment"), _T("截面的形状0:矩形,1:圆形")); m_pXDataMap->GetAt(HVAC_SectType, nValue); csText.Format(_T("%d"), nValue); xmlTree.SetItemText(posItemSect, csText); } POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemSect); { xmlTree.SetAttribute(posItemNorDir, _T("name"), _T("法向量")); vt = normal(); 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 posItemStartPt = xmlTree.Insert(_T("Start_point"), posRoot, posItemNorDir); { xmlTree.SetAttribute(posItemStartPt, _T("name"), _T("起点位置")); m_pXDataMap->GetAt(HOFF_StartPoint, pt); pt.transformBy(mat); 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(posItemStartPt, csText); } POSITION posItemStartDir = xmlTree.Insert(_T("Start_direction"), posRoot, posItemStartPt); { xmlTree.SetAttribute(posItemStartDir, _T("name"), _T("起点方向")); m_pXDataMap->GetAt(HOFF_StartDir, 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(posItemStartDir, csText); } POSITION posItemEndPt = xmlTree.Insert(_T("End_point"), posRoot, posItemStartDir); { xmlTree.SetAttribute(posItemEndPt, _T("name"), _T("终点位置")); m_pXDataMap->GetAt(HOFF_EndPoint, pt); pt.transformBy(mat); 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(posItemEndPt, csText); } POSITION posItemEndDir = xmlTree.Insert(_T("End_direction"), posRoot, posItemEndPt); { xmlTree.SetAttribute(posItemEndDir, _T("name"), _T("终点方向")); m_pXDataMap->GetAt(HOFF_EndDir, 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(posItemEndDir, csText); } POSITION posItemWidthStr = xmlTree.Insert(_T("Width_Start"), posRoot, posItemEndDir); { xmlTree.SetAttribute(posItemWidthStr, _T("name"), _T("起始端宽度")); m_pXDataMap->GetAt(HOFF_StartWidth, dValue); TAuxTools::DoubleToString(dValue, nWhPreci, csText); xmlTree.SetItemText(posItemWidthStr, csText); } POSITION posItemWidthEnd = xmlTree.Insert(_T("Width_End"), posRoot, posItemWidthStr); { xmlTree.SetAttribute(posItemWidthEnd, _T("name"), _T("终止端宽度")); m_pXDataMap->GetAt(HOFF_EndWidth, dValue); TAuxTools::DoubleToString(dValue, nWhPreci, csText); xmlTree.SetItemText(posItemWidthEnd, csText); } POSITION posItemHghStr = xmlTree.Insert(_T("Height_Start"), posRoot, posItemWidthEnd); { xmlTree.SetAttribute(posItemHghStr, _T("name"), _T("起始端高度")); m_pXDataMap->GetAt(HOFF_Thick, dValue); TAuxTools::DoubleToString(dValue, nWhPreci, csText); xmlTree.SetItemText(posItemHghStr, csText); } POSITION posItemHghEnd = xmlTree.Insert(_T("Height_End"), posRoot, posItemHghStr); { xmlTree.SetAttribute(posItemHghEnd, _T("name"), _T("终止端高度")); m_pXDataMap->GetAt(HOFF_Thick, dValue); // ??? TAuxTools::DoubleToString(dValue, nWhPreci, csText); xmlTree.SetItemText(posItemHghEnd, csText); } POSITION posPlusEdge = xmlTree.Insert(_T("PlusEdge"), posRoot, posItemHghEnd); { xmlTree.SetAttribute(posPlusEdge, _T("name"),_T("咬口法兰翻边余量")); m_pXDataMap->GetAt(HVAC_PlusEdge, dValue); TAuxTools::DoubleToString(dValue, 1, csText); xmlTree.SetItemText(posPlusEdge, csText); } POSITION posObjId = xmlTree.Insert(_T("Object_ID"), posRoot, posPlusEdge); { xmlTree.SetAttribute(posObjId, _T("name"),_T("ID")); xmlTree.SetAttribute(posObjId, _T("comment"),_T("乙字弯ID")); csText.Format(_T("%ld"), 0x7FFFFFFF & m_pOwnerEnt->objectId().asOldId()); xmlTree.SetItemText(posObjId, csText); } // begin // add by wc 13-12-13 POSITION posSysName = xmlTree.Insert(_T("System"), posRoot, posObjId); { xmlTree.SetAttribute(posSysName, _T("name"), _T("管线类型")); xmlTree.SetAttribute(posSysName, _T("comment"), _T("回风/送风/通风...")); m_pXDataMap->GetAt(HVAC_System, csText); xmlTree.SetItemText(posSysName, csText); } POSITION posSingleLine = xmlTree.Insert(_T("IsSingleLine"), posRoot, posSysName); { xmlTree.SetAttribute(posSingleLine, _T("name"), _T("单线")); xmlTree.SetAttribute(posSingleLine, _T("comment"), _T("是否是单线: 1/是, 0/不是")); csText.Format(_T("%d"), (int)IsSingleLine()); xmlTree.SetItemText(posSingleLine, csText); } POSITION posHasLiningLine = xmlTree.Insert(_T("HasLiningLine"), posRoot, posSingleLine); { xmlTree.SetAttribute(posHasLiningLine, _T("name"), _T("内衬线")); xmlTree.SetAttribute(posHasLiningLine, _T("comment"), _T("是否有内衬线:0/不是, 1/是")); if (!m_pXDataMap->GetAt(HVAC_HasLining, nValue)) nValue = 0; csText.Format(_T("%d"), nValue); xmlTree.SetItemText(posHasLiningLine, csText); } POSITION posLiningLineType = xmlTree.Insert(_T("LiningLineType"), posRoot, posHasLiningLine); { AcDbObjectId idType; AcDbObject *pObjType = NULL; ACHAR *pChar = NULL; xmlTree.SetAttribute(posLiningLineType, _T("name"), _T("内衬线型")); xmlTree.SetAttribute(posLiningLineType, _T("comment"), _T("内衬线型的名称")); m_pXDataMap->GetAt(HVAC_LiningLine, idType); if (Acad::eOk != acdbOpenObject(pObjType, idType, AcDb::kForRead)) { } if (NULL != pObjType) { AcDbLinetypeTableRecord *pRec = AcDbLinetypeTableRecord::cast(pObjType); pRec->getName(pChar); pRec->close(); pObjType->close(); csText.Format(_T("%s"), pChar); delete pChar; } else csText.Empty(); xmlTree.SetItemText(posLiningLineType, csText); } POSITION posIsEdgeWidth = xmlTree.Insert(_T("IsEdgeWidth"), posRoot, posLiningLineType); { xmlTree.SetAttribute(posIsEdgeWidth, _T("name"), _T("边线是否加粗")); xmlTree.SetAttribute(posIsEdgeWidth, _T("comment"), _T("0/不加粗, 1/加粗")); if (!m_pXDataMap->GetAt(HVAC_EdgeWeight, nValue)) nValue = 0; csText.Format(_T("%d"), nValue); xmlTree.SetItemText(posIsEdgeWidth, csText); } POSITION posIsCentWidth = xmlTree.Insert(_T("IsCentWidth"), posRoot, posIsEdgeWidth); { xmlTree.SetAttribute(posIsCentWidth, _T("name"), _T("中线是否加粗")); xmlTree.SetAttribute(posIsCentWidth, _T("comment"), _T("0/不加粗, 1/加粗")); if (!m_pXDataMap->GetAt(HVAC_CentWeight, nValue)) nValue = 0; csText.Format(_T("%d"), nValue); xmlTree.SetItemText(posIsCentWidth, csText); } POSITION posIsEndWidth = xmlTree.Insert(_T("IsEndWidth"), posRoot, posIsCentWidth); { xmlTree.SetAttribute(posIsEndWidth, _T("name"), _T("端线是否加粗")); xmlTree.SetAttribute(posIsEndWidth, _T("comment"), _T("0/不加粗, 1/加粗")); if (!m_pXDataMap->GetAt(HVAC_EndWeight, nValue)) nValue = 0; csText.Format(_T("%d"), nValue); xmlTree.SetItemText(posIsEndWidth, csText); } POSITION posEdgeWidth = xmlTree.Insert(_T("EdgeWidth"), posRoot, posIsEndWidth); { xmlTree.SetAttribute(posEdgeWidth, _T("name"), _T("边线加粗量")); xmlTree.SetAttribute(posEdgeWidth, _T("comment"), _T("边线加粗的数值")); m_pXDataMap->GetAt(HVAC_EdgeWidth, dValue); csText.Format(_T("%f"), dValue); xmlTree.SetItemText(posEdgeWidth, csText); } POSITION posCentWidth = xmlTree.Insert(_T("CentWidth"), posRoot, posEdgeWidth); { xmlTree.SetAttribute(posCentWidth, _T("name"), _T("中线加粗量")); xmlTree.SetAttribute(posCentWidth, _T("comment"), _T("中线加粗的数值")); m_pXDataMap->GetAt(HVAC_CentWidth, dValue); csText.Format(_T("%f"), dValue); xmlTree.SetItemText(posCentWidth, csText); } POSITION posEndWidth = xmlTree.Insert(_T("EndWidth"), posRoot, posCentWidth); { xmlTree.SetAttribute(posEndWidth, _T("name"), _T("端线加粗量")); xmlTree.SetAttribute(posEndWidth, _T("comment"), _T("端线加粗的数值")); m_pXDataMap->GetAt(HVAC_EndWidth, dValue); csText.Format(_T("%f"), dValue); xmlTree.SetItemText(posEndWidth, csText); } // end CString csXml = xmlTree.GetXml(); return csXml; } bool THImpHvacOffset::GetSection(const AcDbFace &face, const AcGeVector3d &vtPlaneSecDir, std::vector §ionRecord, AcDbVoidPtrArray& arFillPtrs) const { if (NULL == m_pOwnerEnt || NULL == m_pXDataMap) return false; // 基本参数 AcDbObjectId idObj = m_pOwnerEnt->objectId(); AcDbObjectId idLayer = m_pOwnerEnt->layerId(); TGGeSectionPlane section_pln(face, vtPlaneSecDir); // 构造一个辅助剖面 int i = 0; double dElevation = 0; for(i = 0; i < 4; i++) { TGGePoly2D plOutline; if(Make3DOutline(plOutline, i + 1)) { TGGePoly2D poly; dElevation = SectionUtility::Projection_poly2plane(section_pln, plOutline, poly); if(!!poly) // add by hh 2011-03-11 增加投影后的Poly2D有效型判断 sectionRecord.push_back(TObjSectionRecord(idObj, idLayer, TObjSectionRecord::eTCH_DBHFITTING, dElevation, poly)); } } return true; } Acad::ErrorStatus THImpHvacOffset::GetExtents(TADSGePoint3d &ptLow, TADSGePoint3d &ptUp) const { if (NULL == m_pXDataMap) return Acad::eNotImplementedYet; AcGePoint3d ptStart, ptEnd; double dThick = 0; m_pXDataMap->GetAt(HOFF_StartPoint, ptStart); m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd); HvacSectType eSect = TDb::eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect); if(eRectangular == eSect) m_pXDataMap->GetAt(HOFF_Thick, dThick); else m_pXDataMap->GetAt(HOFF_Diameter, dThick); dThick *= 0.5; AcGeVector3d vtNor = normal(); if(IsHorzAlignment()) { if (ptStart.z < ptEnd.z) { ptLow = ptStart - vtNor * dThick; ptUp = ptEnd + vtNor * dThick; } else { ptLow = ptEnd - vtNor * dThick; ptUp = ptStart + vtNor * dThick; } } else { vtNor = TAuxTools::GetUcsZvt(); if (ptStart.z < ptEnd.z) { ptLow = ptStart - vtNor * dThick; ptUp = ptEnd + vtNor * dThick; } else { ptLow = ptEnd - vtNor * dThick; ptUp = ptStart + vtNor * dThick; } } return Acad::eOk; } // 生成3D轮廓PL线 iFlag: 1 顶面 2 底面 3 前面 4 背面 BOOL THImpHvacOffset::Make3DOutline(TGGePoly2D& poly, int iFlag) const { if(NULL == m_pXDataMap) return FALSE; HvacSectType eSect = TDb::eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect); // 圆形乙字弯暂按方形处理 //if(TDb::eRectangular == eSect) //{ return MakeRect3DOutline(poly, iFlag); //} //else //{ // return MakeCirc3DOutline(poly, iFlag); //} return TRUE; } BOOL THImpHvacOffset::MakeRect3DOutline(TGGePoly2D& poly, int iFlag) const { HvacOffsetType eOffType = eArcuateLink; m_pXDataMap->GetAt(HOFF_Type, (int&)eOffType); int i = 0; switch(eOffType){ case eArcuateLink: case eObliqueLink: { // 获取中截面所有的点 AcGePoint3dArray arPtLeft, arPtRight; GetAllMinAnglePt(arPtRight, arPtLeft, FALSE); int nPtCount = arPtLeft.length(); if(nPtCount != arPtRight.length()) return FALSE; // 取得偏移长度及方向 HvacSectType eSect = TDb::eRectangular; m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect); double dHalfThick = 0; if(eRectangular == eSect) m_pXDataMap->GetAt(HOFF_Thick, dHalfThick); else m_pXDataMap->GetAt(HOFF_Diameter, dHalfThick); dHalfThick *= 0.5; AcGeVector3d vtNor = normal(); if(1 == iFlag || 2 == iFlag){ // 顶&底 if(2 == iFlag) vtNor *= -1; for(i = 0; i < nPtCount; i++) { poly.AppendNode(arPtLeft[i] + vtNor * dHalfThick); } for(i = nPtCount - 1; i >= 0; i--) { poly.AppendNode(arPtRight[i] + vtNor * dHalfThick); } }else if(3 == iFlag){ // 前面 for(i = 0; i < nPtCount; i++) { poly.AppendNode(arPtLeft[i] + vtNor * dHalfThick); } for(i = nPtCount - 1; i >= 0; i--) { poly.AppendNode(arPtLeft[i] - vtNor * dHalfThick); } }else if(4 == iFlag){ // 背面 for(i = 0; i < nPtCount; i++) { poly.AppendNode(arPtRight[i] + vtNor * dHalfThick); } for(i = nPtCount - 1; i >= 0; i--) { poly.AppendNode(arPtRight[i] - vtNor * dHalfThick); } }else{ return FALSE; } poly.SetClosed(); } break; case eLinearLink: { AcGePoint3dArray arPtUp, arPtDown; // 获取上下两面的关键点 if(!GetTwoSideKeyPoints(arPtUp, arPtDown)) return FALSE; if(8 != arPtUp.length() || 8 != arPtDown.length()) return FALSE; if(1 == iFlag || 2 == iFlag){ // 顶&底 AcGePoint3dArray* pArr = &arPtUp; if(2 == iFlag) pArr = &arPtDown; for(i = 0; i < 8; i++) { poly.AppendNode(pArr->at(i)); } }else if(3 == iFlag){ // 前面 poly.AppendNode(arPtUp[1]); poly.AppendNode(arPtUp[2]); poly.AppendNode(arPtUp[3]); poly.AppendNode(arPtUp[4]); poly.AppendNode(arPtDown[4]); poly.AppendNode(arPtDown[3]); poly.AppendNode(arPtDown[2]); poly.AppendNode(arPtDown[1]); }else if(4 == iFlag){ // 背面 poly.AppendNode(arPtUp[0]); poly.AppendNode(arPtUp[7]); poly.AppendNode(arPtUp[6]); poly.AppendNode(arPtUp[5]); poly.AppendNode(arPtDown[5]); poly.AppendNode(arPtDown[6]); poly.AppendNode(arPtDown[7]); poly.AppendNode(arPtDown[0]); }else{ return FALSE; } poly.SetClosed(); } break; default: return FALSE; } return TRUE; } BOOL THImpHvacOffset::MakeCirc3DOutline(TGGePoly2D& poly, int iFlag) const { return FALSE; } // add by hh 2014-08-06 支持管件与水管遮挡 Acad::ErrorStatus THImpHvacOffset::GetClipBoundary(TGGePoly2D& poly)const { AcDbPolyline* pLine = MakePolyCurve(); if(NULL == pLine) return Acad::eNotImplementedYet; double dBrWidth = 0; if(!TAuxTools::GetTHvacDataFromDwg(HVAC_PIPEHIDEWIDTH, dBrWidth)) GetGlobalContext()->GetAt(HVAC_PIPEHIDEWIDTH, dBrWidth); if(EQUAL_ZERO(dBrWidth)) { PolyConvert(*pLine, poly); } else { AcDbVoidPtrArray arPLines; pLine->getOffsetCurves(dBrWidth, arPLines); if(0 == arPLines.length()) { PolyConvert(*pLine, poly); } else { PolyConvert(*((AcDbPolyline*)arPLines[0]), poly); for(int i = 0; i < arPLines.length(); i++) { if(NULL != arPLines[i]) delete (AcDbEntity*)arPLines[i]; } } } delete pLine; return Acad::eOk; } bool THImpHvacOffset::IsMeClip() const { return true; } bool THImpHvacOffset::IsClipMe(const TEntityBase* pEnt)const//ok是否被裁剪 { if(NULL == pEnt) return false; //add by dyw 20150409 当图纸复杂时，遮挡的更改影响水管的绘制速度，暂时屏蔽掉 return false; //add end CString sClassName = pEnt->GetMe()->isA()->name(); if(0 == sClassName.Compare(_T("TDbPipe"))) // 水管 { TInterfaceModifyMsg iMsg; iMsg.SetInterfaceOper(TDb::eUpdateCover); iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId()); // 写入接口更改消息 TDbInterfaceMsgWrite msgWrite; msgWrite.WriteInterfaceMsg(iMsg); return true; } return false; }