3751 lines
89 KiB
C++
3751 lines
89 KiB
C++
#include "stdafx.h"
|
|
#include "resource.h"
|
|
#include "DrawThunder3D.h"
|
|
#include "CaculateResult.h"
|
|
#include "ThunderXData.h"
|
|
#include "dbgroup.h"
|
|
#include "ThunderCmdGroup.h"
|
|
#include "LightningRodData.h"
|
|
#include "ktsetting.h"
|
|
#include "ThunderCaculate.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[]=__FILE__;
|
|
#define new DEBUG_NEW
|
|
#endif
|
|
|
|
#define DSPACE 0.05
|
|
#define GRADUALLY_COUNT 10
|
|
|
|
TGDrawThunder::TGDrawThunder()
|
|
{
|
|
m_strLayer2d = LAY_EL_THUNDER_2D;
|
|
m_strLayer3d = LAY_EL_THUNDER_3D;
|
|
m_nSinglePinColorIndex = 256;
|
|
m_nMultiPinColorIndex = 256;
|
|
|
|
}
|
|
|
|
TGDrawThunder::~TGDrawThunder()
|
|
{
|
|
|
|
}
|
|
|
|
AcGePoint3d TGDrawThunder::Mid2Point(const AcGePoint3d& pt1, const AcGePoint3d& pt2)
|
|
{
|
|
return AcGePoint3d((pt1.x+pt2.x)/2,(pt1.y+pt2.y)/2,(pt1.z+pt2.z)/2);
|
|
}
|
|
|
|
//画3D避雷区域
|
|
void TGDrawThunder::DrawThunder3DArea(LPCTSTR pszGroupNo, lstCltResult& lstData, BOOL bPreview)
|
|
{
|
|
//生成新的实体
|
|
MakeThunderEntity(pszGroupNo,lstData, bPreview);
|
|
|
|
CThunderXData xd;
|
|
AcDbObjectId id;
|
|
|
|
if (bPreview)
|
|
{
|
|
for (int i = 0;i < m_arPreview.length();++i)
|
|
{
|
|
id = AddToCurrentSpace((AcDbEntity*)m_arPreview[i],Adesk::kTrue);
|
|
xd.SetXData(id, TEL_GROUP_NO, pszGroupNo);
|
|
ThunderContainer->AppendPreview3DSolid(pszGroupNo, id);
|
|
}
|
|
m_arPreview.setLogicalLength(0);
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < m_arRegSolid.length(); ++i)
|
|
{
|
|
id = AddToCurrentSpace((AcDbEntity*)m_arRegSolid[i],Adesk::kTrue);
|
|
xd.SetXData(id, TEL_GROUP_NO, pszGroupNo);
|
|
ThunderContainer->Append3DSolid(pszGroupNo, id);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TGDrawThunder::DocGetMeterUnitDraw()
|
|
{
|
|
struct resbuf rb;
|
|
acedGetVar(_T("INSUNITS"),&rb);
|
|
|
|
if (rb.resval.rint == AcDb::kUnitsMeters)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//画2D保护区域
|
|
void TGDrawThunder::DrawThunder2DArea(const AcGeDoubleArray& arHeight, LPCTSTR pszGroupNo)
|
|
{
|
|
if (pszGroupNo == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 清理旧的实体
|
|
DeleteAllEntities(pszGroupNo);
|
|
|
|
AcDbObjectIdArray arID;
|
|
if (ThunderContainer->GetGroupThunder(pszGroupNo, arID) < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
KTSetting::InitLayer(LAY_EL_THUNDER_2D);
|
|
KTSetting::InitLayer(LAY_EL_THUNDER_3D);
|
|
|
|
CRegProperty regProp(GetRegLocation(), TEL_OBJECTKEY);
|
|
regProp.SetTopRootKey(HKEY_CURRENT_USER);
|
|
regProp.GetValue(KEY_SINGLEPRO_COLOR,m_nSinglePinColorIndex);
|
|
regProp.GetValue(KEY_UNIONPRO_COLOR,m_nMultiPinColorIndex);
|
|
|
|
if (arHeight.length() < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CTGTempTol locTol(0.1, 0.1);
|
|
|
|
// 绘制保护圆
|
|
DrawThunderCircle(arHeight, pszGroupNo, arID);
|
|
|
|
// 计算避雷针数据
|
|
lstCltResult lstData;
|
|
CalcThunderData(pszGroupNo, arHeight, arID, lstData);
|
|
|
|
// 绘制三维
|
|
DrawThunder3DArea(pszGroupNo, lstData);
|
|
|
|
// 根据三维绘制二维
|
|
double dScale = 1.0;
|
|
if (!DocGetMeterUnitDraw())
|
|
dScale = 1000.0;
|
|
|
|
AcDbObjectId id;
|
|
AcGePoint3d ptOrg;
|
|
AcGePlane plan;
|
|
AcGeDoubleArray arTemp;
|
|
CThunderXData thunderXData;
|
|
AcDbRegion *pFirstReg = NULL;
|
|
AcDbRegion *pReg = NULL;
|
|
CString sTemp;
|
|
|
|
for (int j = 0; j < arHeight.length(); ++j)
|
|
{
|
|
ptOrg.set(0,0,arHeight[j]*dScale);
|
|
plan.set(ptOrg,AcGeVector3d::kXAxis,AcGeVector3d::kYAxis);
|
|
|
|
if (m_arRegSolid.length() > 0)
|
|
{
|
|
((AcDb3dSolid*)m_arRegSolid[0])->getSection(plan,pFirstReg);
|
|
}
|
|
|
|
if (pFirstReg != NULL)
|
|
{
|
|
for (int i = 1;i < m_arRegSolid.length();++i)
|
|
{
|
|
((AcDb3dSolid*)m_arRegSolid[i])->getSection(plan,pReg);
|
|
if (pReg != NULL)
|
|
{
|
|
pFirstReg->booleanOper(AcDb::kBoolUnite,pReg);
|
|
delete pReg;
|
|
pReg = NULL;
|
|
}
|
|
}
|
|
|
|
pFirstReg->setLayer(m_strLayer2d);
|
|
pFirstReg->setColorIndex(m_nMultiPinColorIndex);
|
|
id = AddToCurrentSpace(pFirstReg,Adesk::kTrue);
|
|
pFirstReg = NULL;
|
|
|
|
// 二维区域写入保护高度扩展数据
|
|
arTemp.setLogicalLength(0);
|
|
arTemp.append(arHeight[j]);
|
|
sTemp.Format(_T("%g"),arHeight[j]);
|
|
thunderXData.SetXData(id,TEL_GROUP_NO,pszGroupNo);
|
|
thunderXData.SetXData(id,TEL_CURRENT_PROHEIGHT,sTemp);
|
|
thunderXData.SetProtectHeightToObjEx(id, arHeight);
|
|
ThunderContainer->AppendRegion(pszGroupNo, id);
|
|
}
|
|
}
|
|
}
|
|
|
|
void TGDrawThunder::DrawThunderLine(LPCTSTR pszGroupNo, const AcGeDoubleArray& arHeight)
|
|
{
|
|
// 清理旧的实体
|
|
DeleteThunLineEntities(pszGroupNo);
|
|
if (pszGroupNo != NULL && arHeight.length() > 0)
|
|
{
|
|
KTSetting::InitLayer(LAY_EL_THUNDER_2D);
|
|
KTSetting::InitLayer(LAY_EL_THUNDER_3D);
|
|
|
|
CRegProperty regProp(GetRegLocation(), TEL_OBJECTKEY);
|
|
regProp.SetTopRootKey(HKEY_CURRENT_USER);
|
|
regProp.GetValue(KEY_SINGLEPRO_COLOR,m_nSinglePinColorIndex);
|
|
regProp.GetValue(KEY_UNIONPRO_COLOR,m_nMultiPinColorIndex);
|
|
|
|
AcDbObjectIdArray arID;
|
|
ThunderContainer->GetGroupThunderLine(pszGroupNo, arID);
|
|
if (arHeight.length() < 1 ||
|
|
arID.length() < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CTGTempTol locTol(0.1, 0.1);
|
|
|
|
// 计算数据
|
|
MapThunderLineCltResult mapData;
|
|
CalcThunLineData(pszGroupNo, arHeight, arID, mapData);
|
|
|
|
// 绘制避雷线三维
|
|
DrawThunLine3D(pszGroupNo, mapData);
|
|
|
|
// 添加到模型空间
|
|
AcDbObjectId id;
|
|
AcDbEntity* p3dEnt = NULL;
|
|
MapThunderLinePtr::iterator itT;
|
|
for (itT = m_mapThunLinePtr.begin();itT != m_mapThunLinePtr.end();++itT)
|
|
{
|
|
m_arCollector.append(itT->second);
|
|
}
|
|
|
|
for (int i = 0; i < m_arCollector.length(); ++i)
|
|
{
|
|
p3dEnt = (AcDbEntity*)m_arCollector[i];
|
|
if (p3dEnt != NULL)
|
|
{
|
|
p3dEnt->setLayer(LAY_EL_THUNDER_3D);
|
|
p3dEnt->setColorIndex(m_nMultiPinColorIndex);
|
|
id = AddToCurrentSpace(p3dEnt,Adesk::kTrue);
|
|
ThunderContainer->AppendLine3DSolid(pszGroupNo, id);
|
|
}
|
|
}
|
|
|
|
// 根据三维实体生成二维区域
|
|
double dScale = 1.0;
|
|
if (!DocGetMeterUnitDraw())
|
|
dScale = 1000.0;
|
|
|
|
AcGePoint3d ptOrg;
|
|
AcGePlane plan;
|
|
AcGeDoubleArray arTemp;
|
|
CThunderXData thunderXData;
|
|
AcDbRegion *pFirstReg = NULL;
|
|
AcDbRegion *pReg = NULL;
|
|
CString sTemp;
|
|
MapUnionLine::iterator itUnion;
|
|
AcDbVoidPtrArray arPtrTemp;
|
|
for (int j = 0; j < arHeight.length(); ++j)
|
|
{
|
|
arPtrTemp.setLogicalLength(0);
|
|
|
|
ptOrg.set(0,0,arHeight[j]*dScale);
|
|
plan.set(ptOrg,AcGeVector3d::kXAxis,AcGeVector3d::kYAxis);
|
|
|
|
//1.单个避雷线reg
|
|
for (itT = m_mapThunLinePtr.begin();itT != m_mapThunLinePtr.end();++itT)
|
|
{
|
|
arPtrTemp = itT->second;
|
|
if (arPtrTemp.length() > 0)
|
|
{
|
|
((AcDb3dSolid*)arPtrTemp[0])->getSection(plan,pFirstReg);
|
|
if (pFirstReg != NULL)
|
|
{
|
|
for (int i = 1;i < arPtrTemp.length();++i)
|
|
{
|
|
((AcDb3dSolid*)arPtrTemp[i])->getSection(plan,pReg);
|
|
if (pReg != NULL)
|
|
{
|
|
pFirstReg->booleanOper(AcDb::kBoolUnite,pReg);
|
|
delete pReg;
|
|
pReg = NULL;
|
|
}
|
|
}
|
|
|
|
pFirstReg->setLayer(m_strLayer2d);
|
|
pFirstReg->setColorIndex(m_nSinglePinColorIndex);
|
|
id = AddToCurrentSpace(pFirstReg,Adesk::kTrue);
|
|
pFirstReg = NULL;
|
|
|
|
// 二维区域写入保护高度扩展数据
|
|
arTemp.setLogicalLength(0);
|
|
arTemp.append(arHeight[j]);
|
|
sTemp.Format(_T("%g"),arHeight[j]);
|
|
thunderXData.SetXData(id,KEY_LINE_GROUP_NO,pszGroupNo);
|
|
thunderXData.SetXData(id,TEL_CURRENT_PROHEIGHT,sTemp);
|
|
thunderXData.SetProtectHeightToObjEx(id, arHeight);
|
|
ThunderContainer->AppendLineRegion(pszGroupNo, id);
|
|
}
|
|
}
|
|
}
|
|
|
|
//1.联合避雷线reg
|
|
for (itUnion = m_mapLineUnRegSolid.begin();itUnion != m_mapLineUnRegSolid.end();++itUnion)
|
|
{
|
|
arPtrTemp = itUnion->second;
|
|
if (arPtrTemp.length() > 0)
|
|
{
|
|
((AcDb3dSolid*)arPtrTemp[0])->getSection(plan,pFirstReg);
|
|
if (pFirstReg != NULL)
|
|
{
|
|
for (int i = 1;i < arPtrTemp.length();++i)
|
|
{
|
|
((AcDb3dSolid*)arPtrTemp[i])->getSection(plan,pReg);
|
|
if (pReg != NULL)
|
|
{
|
|
pFirstReg->booleanOper(AcDb::kBoolUnite,pReg);
|
|
delete pReg;
|
|
pReg = NULL;
|
|
}
|
|
}
|
|
|
|
pFirstReg->setLayer(m_strLayer2d);
|
|
pFirstReg->setColorIndex(m_nMultiPinColorIndex);
|
|
id = AddToCurrentSpace(pFirstReg,Adesk::kTrue);
|
|
pFirstReg = NULL;
|
|
|
|
// 二维区域写入保护高度扩展数据
|
|
arTemp.setLogicalLength(0);
|
|
arTemp.append(arHeight[j]);
|
|
sTemp.Format(_T("%g"),arHeight[j]);
|
|
thunderXData.SetXData(id,KEY_LINE_GROUP_NO,pszGroupNo);
|
|
thunderXData.SetXData(id,TEL_CURRENT_PROHEIGHT,sTemp);
|
|
thunderXData.SetProtectHeightToObjEx(id, arHeight);
|
|
ThunderContainer->AppendLineRegion(pszGroupNo, id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
m_arCollector.setLogicalLength(0);
|
|
m_mapThunLinePtr.clear();
|
|
m_mapLineUnRegSolid.clear();
|
|
}
|
|
}
|
|
|
|
void TGDrawThunder::DeleteThunLineEntities(LPCTSTR pszGNo)
|
|
{
|
|
ThunderContainer->EreaseSpecGNoLineRegion(pszGNo);
|
|
ThunderContainer->EreaseSpecGNoLine3dSolid(pszGNo);
|
|
}
|
|
|
|
void TGDrawThunder::ClassifyThunderLines(const AcDbObjectIdArray& arID, LstParallelTLine& lstID)
|
|
{
|
|
lstID.clear();
|
|
|
|
int nPos = -1;
|
|
AcDbObjectIdArray arLoc,arTmp;
|
|
arLoc.append(arID);
|
|
|
|
while (arLoc.length() > 0)
|
|
{
|
|
arTmp.append(arLoc[0]);
|
|
for (int i = 1;i < arLoc.length();++i)
|
|
{
|
|
if (CheckIsEqualLineTLine(arLoc[0], arLoc[i]))
|
|
{
|
|
arTmp.append(arLoc[i]);
|
|
}
|
|
}
|
|
|
|
lstID.push_back(arTmp);
|
|
|
|
for (int j = 0;j < arTmp.length();++j)
|
|
{
|
|
arLoc.find(arTmp[j],nPos);
|
|
if (nPos >= 0 && nPos < arLoc.length())
|
|
{
|
|
arLoc.removeAt(nPos);
|
|
}
|
|
}
|
|
|
|
arTmp.setLogicalLength(0);
|
|
}
|
|
}
|
|
|
|
BOOL TGDrawThunder::CheckIsEqualLineTLine(const AcDbObjectId& id1,const AcDbObjectId& id2)
|
|
{
|
|
BOOL bSuc = FALSE;
|
|
|
|
if (id1.isValid() && id2.isValid())
|
|
{
|
|
CString sGRadius,sGRadius2,sHeight,sHeight2;
|
|
CThunderXData xd;
|
|
OPENOBJ_BEGIN(id1,AcDb::kForRead,AcDbPolyline,pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
OPENOBJ_BEGIN(id2,AcDb::kForRead,AcDbPolyline,pLine2);
|
|
if (pLine2 != NULL)
|
|
{
|
|
// 比较扩展数据
|
|
xd.GetXData(pLine,KEY_LINE_PRO_RADIUS,sGRadius);
|
|
xd.GetXData(pLine,KEY_LINE_HEIGHT,sHeight);
|
|
xd.GetXData(pLine2,KEY_LINE_PRO_RADIUS,sGRadius2);
|
|
xd.GetXData(pLine2,KEY_LINE_HEIGHT,sHeight2);
|
|
if (fabs(_tstof(sGRadius)-_tstof(sGRadius2)) < 1e-3 &&
|
|
fabs(_tstof(sHeight)-_tstof(sHeight2)) < 1e-3 )
|
|
{
|
|
AcGePoint3d ptS,ptE,ptS2,ptE2;
|
|
pLine->getStartPoint(ptS);
|
|
pLine->getEndPoint(ptE);
|
|
pLine2->getStartPoint(ptS2);
|
|
pLine2->getEndPoint(ptE2);
|
|
AcGeVector3d vt1 = ptE - ptS;
|
|
AcGeVector3d vt2 = ptE2 - ptS2;
|
|
if (vt1.isParallelTo(vt2)) // 平行
|
|
{
|
|
// 共线
|
|
if (CheckPtIsOnLine(ptS,pLine2) ||
|
|
CheckPtIsOnLine(ptE,pLine2) ||
|
|
CheckPtIsOnLine(ptS2,pLine) ||
|
|
CheckPtIsOnLine(ptE2,pLine) )
|
|
{
|
|
bSuc = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
return bSuc;
|
|
}
|
|
|
|
BOOL TGDrawThunder::CheckPtIsOnLine(const AcGePoint3d& pt, AcDbPolyline* pLine)
|
|
{
|
|
if (pLine != NULL)
|
|
{
|
|
AcGePoint3d ptOn;
|
|
pLine->getClosestPointTo(pt, ptOn);
|
|
if (pt.distanceTo(ptOn) < 1e-3)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void TGDrawThunder::GetThunderLineMaxPort(const AcDbObjectIdArray& arID, AcGePoint3d& ptS,AcGePoint3d& ptE)
|
|
{
|
|
// 前提：所有Pl平行且共线
|
|
AcGePoint3d ptT;
|
|
std::list<double> lstX,lstY,lstZ;
|
|
for (int i = 0;i < arID.length();++i)
|
|
{
|
|
OPENOBJ_BEGIN(arID[i],AcDb::kForRead,AcDbPolyline,pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->getStartPoint(ptT);
|
|
lstX.push_back(ptT.x);
|
|
lstY.push_back(ptT.y);
|
|
lstZ.push_back(ptT.z);
|
|
|
|
pLine->getEndPoint(ptT);
|
|
lstX.push_back(ptT.x);
|
|
lstY.push_back(ptT.y);
|
|
lstZ.push_back(ptT.z);
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
if (lstX.size() > 0 &&
|
|
lstY.size() > 0 &&
|
|
lstZ.size() > 0)
|
|
{
|
|
lstX.sort();
|
|
lstY.sort();
|
|
lstZ.sort();
|
|
|
|
ptS.x = lstX.front();
|
|
ptS.y = lstY.front();
|
|
ptS.z = lstZ.front();
|
|
|
|
ptE.x = lstX.back();
|
|
ptE.y = lstY.back();
|
|
ptE.z = lstZ.back();
|
|
}
|
|
}
|
|
|
|
int TGDrawThunder::CalcThunLineData(LPCTSTR pszGNo, const AcGeDoubleArray& arProHeight, const AcDbObjectIdArray& arID, MapThunderLineCltResult& mapData)
|
|
{
|
|
mapData.clear();
|
|
if (pszGNo != NULL && arID.length() > 0)
|
|
{
|
|
CThunderXData thundXData;
|
|
for (int p = 0;p < arID.length();++p)
|
|
{
|
|
thundXData.SetProtectHeightToObjEx(arID[p], arProHeight);
|
|
}
|
|
|
|
AcDbObjectIdArray arLoc(arID);
|
|
// 检查是否存在避雷针编号重复
|
|
AcDbObjectIdArray arRepeate;
|
|
if (CheckHasRepeatNum(arLoc,arRepeate))
|
|
{
|
|
acutPrintf(_T("\n 存在重复的避雷线编号,请修改编号。"));
|
|
}
|
|
|
|
// LstParallelTLine lstID;
|
|
// LstParallelTLine::iterator it;
|
|
// ClassifyThunderLines(arLoc, lstID);
|
|
|
|
CStringArray arsXData;
|
|
TGLightningRodData ltnData;
|
|
TGThunderCaculate caculate;
|
|
AcGePoint3d ptStart,ptEnd;
|
|
lstCltResult lstTemp;
|
|
CString sGRadius,sHeight,sNum,sGNo;
|
|
|
|
for (int i = 0;i < arLoc.length();++i)
|
|
{
|
|
if (!arLoc[i].isValid())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// GetThunderLineMaxPort(arIDTemp, ptStart, ptEnd);
|
|
// ptStart.z = 0;
|
|
// ptEnd.z = 0;
|
|
|
|
lstTemp.clear();
|
|
OPENOBJ_BEGIN(arLoc[i],AcDb::kForRead,AcDbPolyline,pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->getStartPoint(ptStart);
|
|
pLine->getEndPoint(ptEnd);
|
|
ptStart.z = 0;
|
|
ptEnd.z = 0;
|
|
|
|
thundXData.GetXData(pLine,KEY_LINE_PRO_RADIUS,sGRadius);
|
|
thundXData.GetXData(pLine,KEY_LINE_HEIGHT,sHeight);
|
|
thundXData.GetXData(pLine,KEY_LINE_GROUP_NO,sGNo);
|
|
thundXData.GetXData(pLine,TEL_ORDER_NUMBER,sNum);
|
|
|
|
ltnData.SetGroundRadius(_tstof(sGRadius));
|
|
ltnData.SetHeight(_tstof(sHeight));
|
|
ltnData.SetNumber(_ttoi(sNum));
|
|
ltnData.SetGroupNO(_ttoi(sGNo));
|
|
ltnData.SetInsertPoint(ptStart);
|
|
ltnData.m_arProtecedHeight.setLogicalLength(0);
|
|
ltnData.m_arProtecedHeight.append(arProHeight);
|
|
caculate.CaculateThunderData(<nData);
|
|
lstTemp.push_back(caculate.m_result);
|
|
|
|
ltnData.SetGroundRadius(_tstof(sGRadius));
|
|
ltnData.SetHeight(_tstof(sHeight));
|
|
ltnData.SetNumber(_ttoi(sNum));
|
|
ltnData.SetGroupNO(_ttoi(sGNo));
|
|
ltnData.SetInsertPoint(ptEnd);
|
|
ltnData.m_arProtecedHeight.setLogicalLength(0);
|
|
ltnData.m_arProtecedHeight.append(arProHeight);
|
|
caculate.CaculateThunderData(<nData);
|
|
lstTemp.push_back(caculate.m_result);
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
mapData.insert(std::make_pair(arLoc[i],lstTemp));
|
|
}
|
|
}
|
|
|
|
return (mapData.size() > 0);
|
|
}
|
|
|
|
void TGDrawThunder::DrawThunLine3D(LPCTSTR pszGNo,MapThunderLineCltResult& mapData, BOOL bPreview)
|
|
{
|
|
AcDb3dSolid *pSolid = NULL;
|
|
CThunderXData thundXData;
|
|
lstCltResult::iterator it;
|
|
MapThunderLineCltResult::iterator itMap;
|
|
lstCltResult lstData;
|
|
AcDbRegion* pSecReg = NULL;
|
|
AcGePlane plan;
|
|
AcGePoint3d ptPos;
|
|
AcGeVector3d vtHor = AcGeVector3d::kZAxis,vtVer,vtNor;
|
|
AcDbVoidPtrArray arPtr;
|
|
|
|
// 绘制单个避雷线
|
|
for (itMap = mapData.begin();itMap != mapData.end();++itMap)
|
|
{
|
|
lstData = itMap->second;
|
|
if (lstData.size() != 2)
|
|
continue;
|
|
|
|
ptPos = lstData.front().m_ptInsert;
|
|
ptPos.z = 0.0;
|
|
vtNor = lstData.back().m_ptInsert - lstData.front().m_ptInsert;
|
|
vtVer = vtHor;
|
|
vtVer.rotateBy(PI/2,vtNor);
|
|
plan.set(ptPos,vtHor,vtVer);
|
|
|
|
pSolid = Create3DSolid(lstData.front());
|
|
if (pSolid == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
arPtr.setLogicalLength(0);
|
|
arPtr.append(pSolid);
|
|
|
|
// 实体截面
|
|
pSolid->getSection(plan, pSecReg);
|
|
if (pSecReg != NULL)
|
|
{
|
|
pSolid = ExtrudeSolid(pSecReg, vtNor.normal(), vtNor.length());
|
|
if (pSolid != NULL)
|
|
{
|
|
arPtr.append(pSolid);
|
|
}
|
|
delete pSecReg;
|
|
}
|
|
|
|
pSolid = Create3DSolid(lstData.back());
|
|
if (pSolid != NULL)
|
|
{
|
|
arPtr.append(pSolid);
|
|
|
|
for (int t = 0;t < arPtr.length();++t)
|
|
{
|
|
thundXData.SetXData((AcDbEntity*)arPtr[t], KEY_LINE_GROUP_NO, pszGNo);
|
|
}
|
|
|
|
// 添加预览
|
|
if (bPreview)
|
|
{
|
|
m_arLinePreview.append(arPtr);
|
|
}
|
|
else
|
|
{
|
|
m_mapThunLinePtr.insert(std::make_pair(itMap->first,arPtr));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int t = 0;t < arPtr.length();++t)
|
|
{
|
|
delete (AcDbEntity*)arPtr[t];
|
|
}
|
|
}
|
|
}
|
|
|
|
// 生成联合保护区域
|
|
AcDbVoidPtrArray arTemp;
|
|
AcDbVoidPtrArray arUnions;
|
|
MapThunderLinePtr::iterator itFind;
|
|
MapUnionLine::iterator itApFind;
|
|
MapThunderLineCltResult::iterator itSub;
|
|
AcDbObjectIdArray arSubGroup;
|
|
MapGrouping mapGroup;
|
|
MapGrouping::iterator itGroup;
|
|
int nIndex = 0;
|
|
|
|
for (itMap = mapData.begin();itMap != mapData.end();++itMap)
|
|
{
|
|
arTemp.setLogicalLength(0);
|
|
arSubGroup.setLogicalLength(0);
|
|
|
|
itSub = itMap;
|
|
itSub++;
|
|
|
|
for (itSub;itSub != mapData.end();++itSub)
|
|
{
|
|
if (CheckIsSuitToCreate(itMap->first,itMap->second,itSub->first,itSub->second))
|
|
{
|
|
CreateUnionRegion(itMap->first,itMap->second,itSub->first,itSub->second,arUnions);
|
|
if (arUnions.length() > 0)
|
|
{
|
|
if (bPreview)
|
|
{
|
|
m_arLinePreview.append(arUnions);
|
|
arSubGroup.append(itSub->first);
|
|
}
|
|
else
|
|
{
|
|
m_arCollector.append(arUnions);
|
|
arTemp.append(arUnions);
|
|
arSubGroup.append(itSub->first);
|
|
}
|
|
arUnions.setLogicalLength(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (arSubGroup.length() > 0)
|
|
{
|
|
arSubGroup.append(itMap->first);
|
|
BOOL bAppend = FALSE;
|
|
for (itGroup = mapGroup.begin();itGroup != mapGroup.end();++itGroup)
|
|
{
|
|
if (FindSubArray(itGroup->second, arSubGroup)) // 已经存在
|
|
{
|
|
if ((itApFind = m_mapLineUnRegSolid.find(itGroup->first)) != m_mapLineUnRegSolid.end())
|
|
{
|
|
itApFind->second.append(arTemp);
|
|
bAppend = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bAppend)
|
|
{
|
|
for (int t = 0;t < arSubGroup.length();++t)
|
|
{
|
|
if ((itFind = m_mapThunLinePtr.find(arSubGroup[t])) != m_mapThunLinePtr.end())
|
|
{
|
|
arTemp.append(itFind->second);
|
|
}
|
|
}
|
|
|
|
nIndex++;
|
|
if (arTemp.length() > 0)
|
|
{
|
|
m_mapLineUnRegSolid.insert(std::make_pair(nIndex,arTemp));
|
|
}
|
|
// m_mapLineUnRegSolid.insert(std::make_pair(nIndex,arTempty));
|
|
mapGroup.insert(std::make_pair(nIndex,arSubGroup));
|
|
}
|
|
}
|
|
}
|
|
|
|
// 端点处生成避雷针联合保护区域
|
|
AcDbVoidPtrArray arPtrs;
|
|
for (itGroup = mapGroup.begin();itGroup != mapGroup.end();++itGroup)
|
|
{
|
|
Create2PortsUnionSolids(pszGNo, itGroup->second, mapData, arPtrs);
|
|
if (arPtrs.length() > 0)
|
|
{
|
|
if (bPreview)
|
|
{
|
|
m_arLinePreview.append(arPtrs);
|
|
}
|
|
else
|
|
{
|
|
if ((itApFind = m_mapLineUnRegSolid.find(itGroup->first)) != m_mapLineUnRegSolid.end())
|
|
{
|
|
m_arCollector.append(arPtrs); // 添加到模型空间
|
|
itApFind->second.append(arPtrs); // 添加到联合保护区域实体集
|
|
}
|
|
else
|
|
{
|
|
ReleasePtrArray(arPtrs);
|
|
}
|
|
}
|
|
|
|
arPtrs.setLogicalLength(0);
|
|
}
|
|
}
|
|
|
|
if (bPreview)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
AcDbObjectId id;
|
|
for (int i = 0;i < m_arLinePreview.length();++i)
|
|
{
|
|
pEnt = (AcDbEntity*)m_arLinePreview[i];
|
|
if (pEnt != NULL)
|
|
{
|
|
pEnt->setLayer(LAY_PREVIEW_THUNDER);
|
|
pEnt->setColorIndex(m_nMultiPinColorIndex);
|
|
id = AddToCurrentSpace(pEnt,Adesk::kTrue);
|
|
thundXData.SetXData(id, KEY_LINE_GROUP_NO, pszGNo);
|
|
ThunderContainer->AppendPreview3DSolid(pszGNo, id);
|
|
}
|
|
}
|
|
m_arLinePreview.setLogicalLength(0);
|
|
}
|
|
}
|
|
|
|
void TGDrawThunder::Create2PortsUnionSolids(LPCTSTR pszGNO, const AcDbObjectIdArray& arLine, MapThunderLineCltResult& mapData, AcDbVoidPtrArray& arSolids)
|
|
{
|
|
if (arLine.length() < 3 ||
|
|
mapData.size() < 1 ||
|
|
pszGNO == NULL )
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcGePoint3dArray arPtPort1,arPtPort2;
|
|
AcGeVector3d vtDir;
|
|
AcGePoint3d ptS,ptE;
|
|
CCaculateResult rstTmp,rstTmp2;
|
|
lstCltResult lstData1,lstData2;
|
|
MapThunderLineCltResult::iterator it;
|
|
|
|
OPENOBJ_BEGIN(arLine[0],AcDb::kForRead,AcDbPolyline,pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->getStartPoint(ptS);
|
|
pLine->getEndPoint(ptE);
|
|
|
|
if ((it = mapData.find(arLine[0])) != mapData.end())
|
|
{
|
|
arPtPort1.append(ptS);
|
|
GetCltResultByPosition(it->second, ptS, rstTmp);
|
|
lstData1.push_back(rstTmp);
|
|
|
|
arPtPort2.append(ptE);
|
|
GetCltResultByPosition(it->second, ptE, rstTmp);
|
|
lstData2.push_back(rstTmp);
|
|
}
|
|
|
|
vtDir = ptS - ptE;
|
|
vtDir.normalize();
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
for (int i = 1;i < arLine.length();++i)
|
|
{
|
|
OPENOBJ_BEGIN(arLine[i],AcDb::kForRead,AcDbPolyline,pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->getStartPoint(ptS);
|
|
pLine->getEndPoint(ptE);
|
|
|
|
if ((it = mapData.find(arLine[i])) != mapData.end())
|
|
{
|
|
GetCltResultByPosition(it->second, ptS, rstTmp);
|
|
GetCltResultByPosition(it->second, ptE, rstTmp2);
|
|
|
|
if (vtDir.isCodirectionalTo(ptS - ptE)) // 同向
|
|
{
|
|
arPtPort1.append(ptS);
|
|
lstData1.push_back(rstTmp);
|
|
arPtPort2.append(ptE);
|
|
lstData2.push_back(rstTmp2);
|
|
}
|
|
else
|
|
{
|
|
arPtPort1.append(ptE);
|
|
lstData1.push_back(rstTmp2);
|
|
arPtPort2.append(ptS);
|
|
lstData2.push_back(rstTmp);
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
// 生成避雷针联合实体
|
|
Make3CenThunderEntity(pszGNO, lstData1,FALSE,&arSolids);
|
|
Make3CenThunderEntity(pszGNO, lstData2,FALSE,&arSolids);
|
|
}
|
|
|
|
BOOL TGDrawThunder::FindSubArray(const AcDbObjectIdArray& arSrc, const AcDbObjectIdArray& arSub)
|
|
{
|
|
if (arSrc.length() < 1|| arSub.length() < 1)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
int nIndex = 0;
|
|
for (int i = 0;i < arSub.length();++i)
|
|
{
|
|
if (!arSrc.find(arSub[i], nIndex))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
AcDb3dSolid* TGDrawThunder::ExtrudeSolid(AcDbRegion* pDepReg, const AcGeVector3d& vtDirTo, double dLength)
|
|
{
|
|
AcDb3dSolid* pSolid = NULL;
|
|
|
|
if (pDepReg != NULL)
|
|
{
|
|
AcGeVector3d vtDir(vtDirTo);
|
|
|
|
int nScale = 1;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
nScale *= 1000;
|
|
}
|
|
|
|
AcGeVector3d vtNor;
|
|
pDepReg->getNormal(vtNor);
|
|
|
|
int nDir = 1;
|
|
if (!vtNor.isCodirectionalTo(vtDir))
|
|
{
|
|
nDir = -1;
|
|
}
|
|
|
|
pSolid = new AcDb3dSolid;
|
|
|
|
AcGeVector3d vtOff;
|
|
AcGeMatrix3d mat;
|
|
AcDb3dSolid* pTemp = new AcDb3dSolid;
|
|
AcDb3dSolid* pTemp2 = new AcDb3dSolid;
|
|
|
|
int nCount = (int)dLength / (EXTRUDE_MAX_SIZE*nScale);
|
|
double dSpare = dLength - (nCount * EXTRUDE_MAX_SIZE*nScale);
|
|
|
|
if (nCount > 0)
|
|
{
|
|
pSolid->extrude(pDepReg, EXTRUDE_MAX_SIZE*nScale*nDir, 0);
|
|
pTemp2->copyFrom(pSolid);
|
|
}
|
|
|
|
for (int t = 1;t < nCount;++t)
|
|
{
|
|
vtOff = vtDir.normal() * t * EXTRUDE_MAX_SIZE*nScale;
|
|
mat.setToTranslation(vtOff);
|
|
pTemp->cleanBody();
|
|
pTemp->copyFrom(pTemp2);
|
|
pTemp->transformBy(mat);
|
|
pSolid->booleanOper(AcDb::kBoolUnite, pTemp);
|
|
}
|
|
|
|
if (dSpare > 0)
|
|
{
|
|
vtOff = vtDir.normal() * nCount * EXTRUDE_MAX_SIZE*nScale;
|
|
mat.setToTranslation(vtOff);
|
|
pDepReg->transformBy(mat);
|
|
pTemp->cleanBody();
|
|
pTemp->extrude(pDepReg,dSpare*nDir,0);
|
|
pSolid->booleanOper(AcDb::kBoolUnite, pTemp);
|
|
}
|
|
|
|
delete pTemp;
|
|
delete pTemp2;
|
|
}
|
|
|
|
return pSolid;
|
|
}
|
|
|
|
AcDb3dSolid* TGDrawThunder::ExtrudeSolidAlongPath(AcDbRegion* pDepReg, AcDbCurve* pCve)
|
|
|
|
{
|
|
AcDb3dSolid* pSolid = NULL;
|
|
|
|
if (pDepReg != NULL && pCve != NULL)
|
|
{
|
|
int nScale = 1;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
nScale *= 1000;
|
|
}
|
|
|
|
pSolid = new AcDb3dSolid;
|
|
|
|
AcGePoint3d ptS,ptE;
|
|
CalcLinePorts(pDepReg, pCve, ptS, ptE);
|
|
double dLength = ptS.distanceTo(ptE);
|
|
AcGeVector3d vtDir = ptE - ptS;
|
|
vtDir.normalize();
|
|
|
|
AcGeVector3d vtOff;
|
|
AcGeMatrix3d mat;
|
|
AcDb3dSolid* pTemp = new AcDb3dSolid;
|
|
AcDb3dSolid* pTemp2 = new AcDb3dSolid;
|
|
AcDbLine* pLine = NULL;
|
|
AcDbObjectId idTmp;
|
|
Acad::ErrorStatus es;
|
|
|
|
int nCount = (int)dLength / (EXTRUDE_ALONGPATH_MAX_SIZE*nScale);
|
|
double dSpare = dLength - (nCount * EXTRUDE_ALONGPATH_MAX_SIZE*nScale);
|
|
|
|
if (nCount > 0)
|
|
{
|
|
ptE = ptS + vtDir * EXTRUDE_ALONGPATH_MAX_SIZE*nScale;
|
|
pLine = new AcDbLine(ptS,ptE);
|
|
idTmp = AddToCurrentSpace(pLine,Adesk::kTrue);
|
|
es = pSolid->extrudeAlongPath(pDepReg, pLine);
|
|
pTemp2->copyFrom(pSolid);
|
|
EreaseObj(idTmp);
|
|
}
|
|
|
|
// 由于端点处截取的reg是不规则的
|
|
// 因此需要重新截取新的reg
|
|
for (int t = 1;t < nCount;++t)
|
|
{
|
|
vtOff = vtDir.normal() * t * EXTRUDE_ALONGPATH_MAX_SIZE*nScale;
|
|
mat.setToTranslation(vtOff);
|
|
pTemp->cleanBody();
|
|
pTemp->copyFrom(pTemp2);
|
|
pTemp->transformBy(mat);
|
|
pSolid->booleanOper(AcDb::kBoolUnite, pTemp);
|
|
}
|
|
|
|
if (dSpare > 0)
|
|
{
|
|
ptS += vtDir.normal() * nCount * EXTRUDE_ALONGPATH_MAX_SIZE*nScale;
|
|
ptE = ptS + vtDir * dSpare;
|
|
pLine = new AcDbLine(ptS, ptE);
|
|
idTmp = AddToCurrentSpace(pLine,Adesk::kTrue);
|
|
|
|
if (nCount < 1)
|
|
{
|
|
pTemp->cleanBody();
|
|
es = pTemp->extrudeAlongPath(pDepReg, pLine);
|
|
pSolid->booleanOper(AcDb::kBoolUnite, pTemp);
|
|
}
|
|
else
|
|
{
|
|
AcGePoint3d ptTmp = ptS - vtDir.normal() * nScale;
|
|
AcGeVector3d vtT = vtDir.crossProduct(AcGeVector3d::kZAxis);
|
|
AcGePlane plan;
|
|
plan.set(ptTmp,vtT,AcGeVector3d::kZAxis);
|
|
|
|
AcDbRegion* pReg = NULL;
|
|
pSolid->getSection(plan,pReg);
|
|
if (pReg != NULL)
|
|
{
|
|
pTemp->cleanBody();
|
|
es = pTemp->extrudeAlongPath(pReg, pLine);
|
|
delete pReg;
|
|
pSolid->booleanOper(AcDb::kBoolUnite, pTemp);
|
|
}
|
|
}
|
|
|
|
EreaseObj(idTmp);
|
|
}
|
|
|
|
delete pTemp;
|
|
delete pTemp2;
|
|
}
|
|
|
|
return pSolid;
|
|
}
|
|
|
|
void TGDrawThunder::CalcLinePorts(AcDbRegion* pReg, AcDbCurve* pCve, AcGePoint3d& ptS, AcGePoint3d& ptE)
|
|
{
|
|
if (pReg != NULL && pCve != NULL)
|
|
{
|
|
pCve->getStartPoint(ptS);
|
|
pCve->getEndPoint(ptE);
|
|
|
|
AcDbVoidPtrArray arPtr;
|
|
pReg->explode(arPtr);
|
|
|
|
AcGePoint3d ptOn;
|
|
AcDbCurve* pL = NULL;
|
|
for (int i = 0;i < arPtr.length();++i)
|
|
{
|
|
pL = AcDbCurve::cast((AcDbEntity*)arPtr[i]);
|
|
if (pL != NULL)
|
|
{
|
|
pL->getClosestPointTo(ptS, ptOn);
|
|
if (ptS.distanceTo(ptOn) < 1e-3)
|
|
{
|
|
break;
|
|
}
|
|
|
|
pL->getClosestPointTo(ptE, ptOn);
|
|
if (ptE.distanceTo(ptOn) < 1e-3)
|
|
{
|
|
ptOn = ptE;
|
|
ptE = ptS;
|
|
ptS = ptOn;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int j = 0;j < arPtr.length();++j)
|
|
{
|
|
delete (AcDbEntity*)arPtr[j];
|
|
}
|
|
}
|
|
}
|
|
|
|
AcGeVector3d TGDrawThunder::CalcRegionNormal(const AcGePoint3d& pt, AcDbRegion* pReg)
|
|
{
|
|
AcGeVector3d vtNor;
|
|
if (pReg != NULL)
|
|
{
|
|
AcGePlane plan;
|
|
pReg->getPlane(plan);
|
|
|
|
AcGePoint3d ptOn = pt.orthoProject(plan);
|
|
vtNor = pt - ptOn;
|
|
|
|
}
|
|
return vtNor;
|
|
}
|
|
|
|
BOOL TGDrawThunder::CheckIsSuitToCreate(const AcDbObjectId& id1, lstCltResult& lstData1, const AcDbObjectId& id2, lstCltResult& lstData2)
|
|
{
|
|
BOOL bSuit = FALSE;
|
|
|
|
// 只处理0< h <= hr的情况
|
|
if (lstData1.size() < 1 ||
|
|
lstData2.size() < 1)
|
|
{
|
|
return bSuit;
|
|
}
|
|
|
|
double dGRadius = lstData1.begin()->m_dGroundRadius;
|
|
double dHeight = lstData1.begin()->m_dHeight;
|
|
if (dHeight < 0 ||
|
|
dHeight > dGRadius)
|
|
{
|
|
return bSuit;
|
|
}
|
|
|
|
dGRadius = lstData2.begin()->m_dGroundRadius;
|
|
dHeight = lstData2.begin()->m_dHeight;
|
|
if (dHeight < 0 ||
|
|
dHeight > dGRadius)
|
|
{
|
|
return bSuit;
|
|
}
|
|
|
|
if (id1.isValid() && id2.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id1,AcDb::kForRead,AcDbPolyline,pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
OPENOBJ_BEGIN(id2,AcDb::kForRead,AcDbPolyline,pLine2);
|
|
if (pLine2 != NULL)
|
|
{
|
|
AcGePoint3d ptS,ptE,ptS2,ptE2;
|
|
AcGeVector3d vt1,vt2;
|
|
pLine->getStartPoint(ptS);
|
|
pLine->getEndPoint(ptE);
|
|
ptS.z = 0;
|
|
ptE.z = 0;
|
|
vt1 = ptS - ptE;
|
|
pLine2->getStartPoint(ptS2);
|
|
pLine2->getEndPoint(ptE2);
|
|
ptS2.z = 0;
|
|
ptE2.z = 0;
|
|
vt2 = ptS2 - ptE2;
|
|
|
|
if (vt1.isParallelTo(vt2)) // 平行
|
|
{
|
|
AcDbLine ln(ptS,ptE);
|
|
AcGePoint3d ptOn;
|
|
ln.getClosestPointTo(ptS2, ptOn, Adesk::kTrue);
|
|
double dDist = ptS2.distanceTo(ptOn);
|
|
if (dDist > 1e-3) //不共线
|
|
{
|
|
CString sGroundRadius,sHeight;
|
|
CThunderXData xd;
|
|
xd.GetXData(pLine, KEY_LINE_PRO_RADIUS, sGroundRadius);
|
|
xd.GetXData(pLine, KEY_LINE_HEIGHT, sHeight);
|
|
double dScale = 1.0;
|
|
if (!DocGetMeterUnitDraw())
|
|
dScale *= 1000;
|
|
|
|
double dD = 2*pow(_tstof(sHeight)*dScale*(2*_tstof(sGroundRadius)*dScale-_tstof(sHeight)*dScale),0.5);
|
|
if (dDist < dD)
|
|
{
|
|
bSuit = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
return bSuit;
|
|
}
|
|
|
|
static AcDbObjectId ShowPoint(const AcGePoint3d& pt, Adesk::UInt16 nColorIndex)
|
|
{
|
|
AcDbCircle* pCir = new AcDbCircle(pt, AcGeVector3d::kZAxis, 1000);
|
|
pCir->setColorIndex(nColorIndex);
|
|
return AddToCurrentSpace(pCir, Adesk::kTrue);
|
|
}
|
|
|
|
BOOL TGDrawThunder::CreatePortUnionSolid(const AcDbObjectId& id1,lstCltResult& lstData1,const AcDbObjectId& id2,lstCltResult& lstData2,AcDbVoidPtrArray& arSolids)
|
|
{
|
|
if (id1.isValid() && id2.isValid())
|
|
{
|
|
CCaculateResult data1,data2;
|
|
OPENOBJ_BEGIN(id1,AcDb::kForRead,AcDbPolyline,pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
OPENOBJ_BEGIN(id2,AcDb::kForRead,AcDbPolyline,pLine2);
|
|
if (pLine2 != NULL)
|
|
{
|
|
AcGePoint3d ptS,ptE,ptS2,ptE2;
|
|
pLine->getStartPoint(ptS);
|
|
pLine->getEndPoint(ptE);
|
|
pLine2->getStartPoint(ptS2);
|
|
pLine2->getEndPoint(ptE2);
|
|
|
|
double dDist = 0.0;
|
|
std::map<double,LinePtPair> mapPt;
|
|
LinePtPair ptPair;
|
|
|
|
dDist = ptS.distanceTo(ptS2);
|
|
ptPair.pt1 = ptS;
|
|
ptPair.pt2 = ptS2;
|
|
mapPt.insert(std::make_pair(dDist,ptPair));
|
|
|
|
dDist = ptS.distanceTo(ptE2);
|
|
ptPair.pt1 = ptS;
|
|
ptPair.pt2 = ptE2;
|
|
mapPt.insert(std::make_pair(dDist,ptPair));
|
|
|
|
dDist = ptE.distanceTo(ptS2);
|
|
ptPair.pt1 = ptE;
|
|
ptPair.pt2 = ptS2;
|
|
mapPt.insert(std::make_pair(dDist,ptPair));
|
|
|
|
dDist = ptE.distanceTo(ptE2);
|
|
ptPair.pt1 = ptE;
|
|
ptPair.pt2 = ptE2;
|
|
mapPt.insert(std::make_pair(dDist,ptPair));
|
|
|
|
lstCltResult lstLoc;
|
|
lstLoc.insert(lstLoc.end(),lstData1.begin(),lstData1.end());
|
|
lstLoc.insert(lstLoc.end(),lstData2.begin(),lstData2.end());
|
|
|
|
ptS = mapPt.begin()->second.pt1;
|
|
ptE = mapPt.begin()->second.pt2;
|
|
|
|
GetCltResultByPosition(lstLoc, ptS, data1);
|
|
GetCltResultByPosition(lstLoc, ptE, data2);
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
AcDb3dSolid* pSolid = GetThunderAreaBy2Pin(data1, data2, TRUE);
|
|
if (pSolid != NULL)
|
|
{
|
|
arSolids.append(pSolid);
|
|
}
|
|
}
|
|
|
|
return (arSolids.length() > 0);
|
|
}
|
|
|
|
BOOL TGDrawThunder::CreateUnionRegion(const AcDbObjectId& id1,lstCltResult& lstData1,const AcDbObjectId& id2,lstCltResult& lstData2,AcDbVoidPtrArray& arSolids)
|
|
{
|
|
if (id1.isValid() && id2.isValid() &&
|
|
lstData1.size() == 2 &&
|
|
lstData2.size() == 2 )
|
|
{
|
|
int nScale = 1;
|
|
if (!DocGetMeterUnitDraw())
|
|
nScale *= 1000;
|
|
|
|
// 计算两线共线部分
|
|
T3DNODE node1,node2;
|
|
if (!Get2LinePublicSegment(id1, id2, node1, node2))
|
|
{
|
|
// 两避雷线不存在共线时单独处理距离较近的一端
|
|
return CreatePortUnionSolid(id1, lstData1, id2, lstData2, arSolids);
|
|
}
|
|
|
|
// 绑定数据
|
|
T3DCALCNODE data1,data2;
|
|
AttachThunderData(lstData1, lstData2, node1, node2, data1, data2);
|
|
|
|
// 创建两端端点避雷针联合保护区域
|
|
AcDb3dSolid* pInt1 = GetThunderAreaBy2Pin(data1.rstPort, data1.rstPro, FALSE);
|
|
AcDb3dSolid* pInt2 = GetThunderAreaBy2Pin(data2.rstPort, data2.rstPro, FALSE);
|
|
if (pInt1 != NULL && pInt2 != NULL)
|
|
{
|
|
// 创建共线部分实体
|
|
// 共线实体拉伸方向(以data1为拉伸起始点)
|
|
AcGeVector3d vtDir = GetPubleSolidExDir(id1, data1, data2);
|
|
|
|
// 生成共线实体的实体
|
|
AcDb3dSolid* pIntPubSolid = GetThunderAreaBy2Pin(data1.rstPro, data1.rstVF, FALSE);
|
|
AcDb3dSolid* pIntPubSolid2 = GetThunderAreaBy2Pin(data2.rstPro, data2.rstVF, FALSE);
|
|
if (pIntPubSolid != NULL && pIntPubSolid2 != NULL)
|
|
{
|
|
AcDb3dSolid* pRetSolid = CreatePublicSolid(pIntPubSolid, data1.rstPro, data1.rstVF, vtDir);
|
|
if (pRetSolid != NULL)
|
|
{
|
|
double dHeight = lstData1.front().m_dHeight;
|
|
if (dHeight < lstData2.front().m_dHeight)
|
|
{
|
|
dHeight = lstData2.front().m_dHeight;
|
|
}
|
|
|
|
AcDb3dSolid* pPortSolid = CreateScissorSolid(data1, pIntPubSolid, pInt1, AcGeVector3d::kZAxis, dHeight*nScale);
|
|
if (pPortSolid != NULL)
|
|
{
|
|
arSolids.append(pPortSolid);
|
|
}
|
|
|
|
pPortSolid = CreateScissorSolid(data2, pIntPubSolid2, pInt2, AcGeVector3d::kZAxis, dHeight*nScale);
|
|
if (pPortSolid != NULL)
|
|
{
|
|
arSolids.append(pPortSolid);
|
|
}
|
|
|
|
arSolids.append(pRetSolid);
|
|
}
|
|
}
|
|
|
|
if (pIntPubSolid != NULL)
|
|
delete pIntPubSolid;
|
|
if (pIntPubSolid2 != NULL)
|
|
delete pIntPubSolid2;
|
|
|
|
arSolids.append(pInt1);
|
|
arSolids.append(pInt2);
|
|
}
|
|
else
|
|
{
|
|
if (pInt1 != NULL)
|
|
delete pInt1;
|
|
if (pInt2 != NULL)
|
|
delete pInt2;
|
|
}
|
|
}
|
|
|
|
return (arSolids.length() > 0);
|
|
}
|
|
|
|
AcDb3dSolid* TGDrawThunder::CreateScissorSolid(T3DCALCNODE& data, AcDb3dSolid* pPub, AcDb3dSolid* pPort, const AcGeVector3d& vtDir, double dLength)
|
|
{
|
|
AcDb3dSolid* pRetSolid = NULL;
|
|
|
|
if (pPub != NULL && pPort != NULL)
|
|
{
|
|
if (data.rstPort.m_ptInsert.distanceTo(data.rstVF.m_ptInsert) < 1e-3)
|
|
{
|
|
return pRetSolid;
|
|
}
|
|
|
|
// 创建三点实体
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(data.rstPort.m_ptInsert);
|
|
arPts.append(data.rstPro.m_ptInsert);
|
|
arPts.append(data.rstVF.m_ptInsert);
|
|
|
|
// 整体
|
|
pRetSolid = CreateExtendSolid(arPts, vtDir, dLength);
|
|
if (pRetSolid != NULL)
|
|
{
|
|
// 被削减体
|
|
AcDbArc* pArc1 = GetSolidTopArc(pPub, data.rstPro, data.rstVF);
|
|
AcDbArc* pArc2 = GetSolidTopArc(pPort, data.rstPro, data.rstPort);
|
|
if (pArc1 != NULL && pArc2 != NULL)
|
|
{
|
|
AcGePoint3d ptTmp = data.rstPro.m_ptInsert;
|
|
ptTmp.z += data.rstPro.m_dHeight;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
ptTmp.z *= 1000;
|
|
}
|
|
|
|
AcDbVoidPtrArray arFace;
|
|
|
|
CreateSliceFace(pArc1,ptTmp, pArc2, ptTmp, arFace);
|
|
AcDb3dSolid* pRemoveSolid = CreateRemovedSolid(pRetSolid, arFace, pArc1->center());
|
|
ReleasePtrArray(arFace);
|
|
|
|
CreateSliceFace(pArc2,ptTmp, pArc1, ptTmp, arFace);
|
|
AcDb3dSolid* pRemoveSolid2 = CreateRemovedSolid(pRetSolid, arFace, pArc2->center());
|
|
ReleasePtrArray(arFace);
|
|
|
|
AcDb3dSolid* pBackUp = new AcDb3dSolid;
|
|
pBackUp->copyFrom(pRetSolid);
|
|
if (pRemoveSolid != NULL)
|
|
{
|
|
if (pRetSolid->booleanOper(AcDb::kBoolSubtract, pRemoveSolid) != Acad::eOk)
|
|
{
|
|
pRetSolid->copyFrom(pBackUp);
|
|
}
|
|
else
|
|
{
|
|
pBackUp->copyFrom(pRetSolid);
|
|
}
|
|
delete pRemoveSolid;
|
|
}
|
|
|
|
if (pRemoveSolid2 != NULL)
|
|
{
|
|
if (pRetSolid->booleanOper(AcDb::kBoolSubtract, pRemoveSolid2) != Acad::eOk)
|
|
{
|
|
pRetSolid->copyFrom(pBackUp);
|
|
}
|
|
delete pRemoveSolid2;
|
|
}
|
|
delete pBackUp;
|
|
}
|
|
|
|
if (pArc1 != NULL)
|
|
delete pArc1;
|
|
if (pArc2 != NULL)
|
|
delete pArc2;
|
|
}
|
|
}
|
|
|
|
return pRetSolid;
|
|
}
|
|
|
|
AcDb3dSolid* TGDrawThunder::CreatePublicSolid(AcDb3dSolid* pIntPubSolid, CCaculateResult& rst1, CCaculateResult& rst2, const AcGeVector3d& vtDir)
|
|
{
|
|
AcDb3dSolid* pRetSolid = NULL;
|
|
|
|
if (pIntPubSolid != NULL)
|
|
{
|
|
AcGePlane plan;
|
|
AcGeVector3d vtPlan = rst1.m_ptInsert - rst2.m_ptInsert;
|
|
plan.set(rst1.m_ptInsert, vtPlan, AcGeVector3d::kZAxis);
|
|
|
|
AcDbRegion* pReg = NULL;
|
|
pIntPubSolid->getSection(plan, pReg);
|
|
if (pReg != NULL)
|
|
{
|
|
pRetSolid = ExtrudeSolid(pReg, vtDir, vtDir.length());
|
|
delete pReg;
|
|
}
|
|
}
|
|
|
|
return pRetSolid;
|
|
}
|
|
|
|
AcGeVector3d TGDrawThunder::GetPubleSolidExDir(const AcDbObjectId& id, T3DCALCNODE& data1, T3DCALCNODE& data2)
|
|
{
|
|
AcGeVector3d vtDir;
|
|
|
|
if (id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbPolyline, pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
AcGePoint3d ptS, ptE;
|
|
pLine->getClosestPointTo(data2.rstPro.m_ptInsert, ptS);
|
|
pLine->getClosestPointTo(data1.rstPro.m_ptInsert, ptE);
|
|
|
|
vtDir = ptS - ptE;
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
return vtDir;
|
|
}
|
|
|
|
void TGDrawThunder::AttachThunderData(lstCltResult& lstData1, lstCltResult& lstData2, T3DNODE& node1, T3DNODE& node2, T3DCALCNODE& data1, T3DCALCNODE& data2)
|
|
{
|
|
lstCltResult lstFind;
|
|
lstFind.insert(lstFind.end(), lstData1.begin(), lstData1.end());
|
|
lstFind.insert(lstFind.end(), lstData2.begin(), lstData2.end());
|
|
|
|
GetCltResultByPosition(lstFind, node1.ptPort, data1.rstPort);
|
|
GetCltResultByPosition(lstFind, node1.ptPro, data1.rstPro);
|
|
GetCltResultByPosition(lstFind, node2.ptPort, data2.rstPort);
|
|
GetCltResultByPosition(lstFind, node2.ptPro, data2.rstPro);
|
|
|
|
data1.rstVF = data1.rstPort;
|
|
data1.rstVF.m_ptInsert = node1.ptVF;
|
|
data1.rstVF.m_ptInsert.z = 0.0;
|
|
|
|
data2.rstVF = data2.rstPort;
|
|
data2.rstVF.m_ptInsert = node2.ptVF;
|
|
data2.rstVF.m_ptInsert.z = 0.0;
|
|
}
|
|
|
|
BOOL TGDrawThunder::GetCltResultByPosition(lstCltResult& lstSrc, const AcGePoint3d& ptPos, CCaculateResult& data)
|
|
{
|
|
int nScale = 1;
|
|
if (!DocGetMeterUnitDraw())
|
|
nScale *= 1000;
|
|
|
|
AcGePoint3d ptT;
|
|
lstCltResult::const_iterator it;
|
|
for (it = lstSrc.begin();it != lstSrc.end();++it)
|
|
{
|
|
ptT = it->m_ptInsert;
|
|
ptT.z += it->m_dHeight * nScale;
|
|
if (ptPos.distanceTo(ptT) < 1e-3)
|
|
{
|
|
data = *it;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TGDrawThunder::Get2LinePublicSegment(const AcDbObjectId& idLine, const AcDbObjectId& idLine2, T3DNODE& node1, T3DNODE& node2)
|
|
{
|
|
/************************************************************************
|
|
ptPro ptVF ptPort
|
|
+------+------+
|
|
| |
|
|
+----+------+
|
|
ptPort ptVF ptPro
|
|
************************************************************************/
|
|
BOOL bSuc = FALSE;
|
|
|
|
if (idLine.isValid() && idLine2.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(idLine,AcDb::kForRead,AcDbPolyline,pCve1);
|
|
if (pCve1 != NULL)
|
|
{
|
|
OPENOBJ_BEGIN(idLine2,AcDb::kForRead,AcDbPolyline,pCve2);
|
|
if (pCve2 != NULL)
|
|
{
|
|
AcGePoint3d ptS,ptE,ptS2,ptE2;
|
|
pCve1->getStartPoint(ptS);
|
|
pCve1->getEndPoint(ptE);
|
|
pCve2->getStartPoint(ptS2);
|
|
pCve2->getEndPoint(ptE2);
|
|
|
|
AcGePoint3d ptVF,ptVF2;
|
|
AcDbLine ln(ptS,ptE);
|
|
AcDbLine ln2(ptS2,ptE2);
|
|
|
|
if ( CheckPoint2LineVerFootPoint(&ln, ptS2, ptVF) &&
|
|
!CheckPoint2LineVerFootPoint(&ln, ptE2, ptVF2) )
|
|
{
|
|
node1.ptPro = ptS2;
|
|
node1.ptVF = ptVF;
|
|
node1.ptPort = GetVFootLinePort(ptS2 - ptE2, &ln);
|
|
if ( CheckPoint2LineVerFootPoint(&ln2, ptS, ptVF) &&
|
|
!CheckPoint2LineVerFootPoint(&ln2, ptE, ptVF2))
|
|
{
|
|
node2.ptVF = ptVF;
|
|
node2.ptPro = ptS;
|
|
node2.ptPort = GetVFootLinePort(ptS - ptE, &ln2);
|
|
bSuc = TRUE;
|
|
}
|
|
else if ( CheckPoint2LineVerFootPoint(&ln2, ptE, ptVF) &&
|
|
!CheckPoint2LineVerFootPoint(&ln2, ptS, ptVF2))
|
|
{
|
|
node2.ptVF = ptVF;
|
|
node2.ptPro = ptE;
|
|
node2.ptPort = GetVFootLinePort(ptE - ptS, &ln2);
|
|
bSuc = TRUE;
|
|
}
|
|
else if (CheckPoint2LineVerFootPoint(&ln2, ptS, ptVF) &&
|
|
CheckPoint2LineVerFootPoint(&ln2, ptE, ptVF2))
|
|
{
|
|
node1.ptPro = ptS;
|
|
node1.ptVF = ptVF;
|
|
node1.ptPort = GetVFootLinePort(ptS - ptE, &ln2);
|
|
|
|
node2.ptPro = ptE;
|
|
node2.ptVF = ptVF2;
|
|
node2.ptPort = GetVFootLinePort(ptE - ptS, &ln2);
|
|
bSuc = TRUE;
|
|
}
|
|
}
|
|
else if ( CheckPoint2LineVerFootPoint(&ln, ptE2, ptVF) &&
|
|
!CheckPoint2LineVerFootPoint(&ln, ptS2, ptVF2))
|
|
{
|
|
node1.ptVF = ptVF;
|
|
node1.ptPro = ptE2;
|
|
node1.ptPort = GetVFootLinePort(ptE2 - ptS2, &ln);
|
|
if ( CheckPoint2LineVerFootPoint(&ln2, ptS, ptVF) &&
|
|
!CheckPoint2LineVerFootPoint(&ln2, ptE, ptVF2))
|
|
{
|
|
node2.ptVF = ptVF;
|
|
node2.ptPro = ptS;
|
|
node2.ptPort = GetVFootLinePort(ptS - ptE, &ln2);
|
|
bSuc = TRUE;
|
|
}
|
|
else if ( CheckPoint2LineVerFootPoint(&ln2, ptE, ptVF) &&
|
|
!CheckPoint2LineVerFootPoint(&ln2, ptS, ptVF2))
|
|
{
|
|
node2.ptVF = ptVF;
|
|
node2.ptPro = ptE;
|
|
node2.ptPort = GetVFootLinePort(ptE - ptS, &ln2);
|
|
bSuc = TRUE;
|
|
}
|
|
else if (CheckPoint2LineVerFootPoint(&ln2, ptS, ptVF) &&
|
|
CheckPoint2LineVerFootPoint(&ln2, ptE, ptVF2))
|
|
{
|
|
node1.ptPro = ptS;
|
|
node1.ptVF = ptVF;
|
|
node1.ptPort = GetVFootLinePort(ptS - ptE, &ln2);
|
|
|
|
node2.ptPro = ptE;
|
|
node2.ptVF = ptVF2;
|
|
node2.ptPort = GetVFootLinePort(ptE - ptS, &ln2);
|
|
bSuc = TRUE;
|
|
}
|
|
}
|
|
else if (CheckPoint2LineVerFootPoint(&ln, ptS2, ptVF) &&
|
|
CheckPoint2LineVerFootPoint(&ln, ptE2, ptVF2))
|
|
{
|
|
node1.ptPro = ptS2;
|
|
node1.ptVF = ptVF;
|
|
node1.ptPort = GetVFootLinePort(ptS2 - ptE2, &ln);
|
|
|
|
node2.ptPro = ptE2;
|
|
node2.ptVF = ptVF2;
|
|
node2.ptPort = GetVFootLinePort(ptE2 - ptS2, &ln);
|
|
bSuc = TRUE;
|
|
}
|
|
else if (!CheckPoint2LineVerFootPoint(&ln, ptS2, ptVF) &&
|
|
!CheckPoint2LineVerFootPoint(&ln, ptE2, ptVF2))
|
|
{
|
|
if (CheckPoint2LineVerFootPoint(&ln2, ptS, ptVF) &&
|
|
CheckPoint2LineVerFootPoint(&ln2, ptE, ptVF2))
|
|
{
|
|
node1.ptPro = ptS;
|
|
node1.ptVF = ptVF;
|
|
node1.ptPort = GetVFootLinePort(ptS - ptE, &ln2);
|
|
|
|
node2.ptPro = ptE;
|
|
node2.ptVF = ptVF2;
|
|
node2.ptPort = GetVFootLinePort(ptE - ptS, &ln2);
|
|
bSuc = TRUE;
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
return bSuc;
|
|
}
|
|
|
|
AcGePoint3d TGDrawThunder::GetVFootLinePort(const AcGeVector3d& vtDir, AcDbLine* pLine)
|
|
{
|
|
AcGePoint3d ptPort;
|
|
|
|
if (pLine != NULL)
|
|
{
|
|
AcGeVector3d vt = pLine->startPoint() - pLine->endPoint();
|
|
|
|
if (vt.isCodirectionalTo(vtDir))
|
|
{
|
|
ptPort = pLine->startPoint();
|
|
}
|
|
else
|
|
{
|
|
ptPort = pLine->endPoint();
|
|
}
|
|
}
|
|
|
|
return ptPort;
|
|
}
|
|
|
|
BOOL TGDrawThunder::CheckPoint2LineVerFootPoint(AcDbLine* pLine, const AcGePoint3d& pt, AcGePoint3d& ptVF)
|
|
{
|
|
BOOL bSuc = FALSE;
|
|
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->getClosestPointTo(pt, ptVF, Adesk::kTrue);
|
|
|
|
AcGePoint3d ptT;
|
|
pLine->getClosestPointTo(ptVF, ptT, Adesk::kFalse);
|
|
if (ptVF.distanceTo(ptT) < 1e-3)
|
|
{
|
|
bSuc = TRUE;
|
|
}
|
|
}
|
|
|
|
return bSuc;
|
|
}
|
|
|
|
BOOL TGDrawThunder::BooleanOperSolid(AcDb3dSolid* pMainSolid, AcDb3dSolid* pSubSolid, AcDb::BoolOperType nType, const AcGeVector3d& vtDir, double dDist)
|
|
{
|
|
BOOL bSuc = FALSE;
|
|
|
|
if (pMainSolid != NULL &&
|
|
pSubSolid != NULL )
|
|
{
|
|
AcDb3dSolid* pNewMain = new AcDb3dSolid;
|
|
pNewMain->copyFrom(pMainSolid);
|
|
|
|
AcDb3dSolid* pNewSub = new AcDb3dSolid;
|
|
pNewSub->copyFrom(pSubSolid);
|
|
|
|
AcGeVector3d vtOff = vtDir.normal() * dDist;
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(vtOff);
|
|
|
|
pNewSub->transformBy(mat);
|
|
|
|
if (pNewMain->booleanOper(nType, pNewSub) == Acad::eOk)
|
|
{
|
|
pMainSolid->copyFrom(pNewMain);
|
|
bSuc = TRUE;
|
|
}
|
|
|
|
delete pNewMain;
|
|
delete pNewSub;
|
|
}
|
|
|
|
return bSuc;
|
|
}
|
|
|
|
AcDb3dSolid* TGDrawThunder::CreateRemovedSolid(AcDb3dSolid* pSolid, const AcDbVoidPtrArray& arFace, const AcGePoint3d& ptOr)
|
|
{
|
|
AcDb3dSolid* pRetSolid = NULL;
|
|
|
|
if (pSolid != NULL && arFace.length() > 0)
|
|
{
|
|
pRetSolid = new AcDb3dSolid;
|
|
pRetSolid->copyFrom(pSolid);
|
|
|
|
// 分割整个实体
|
|
AcDb3dSolid* pTmpSolid = NULL;
|
|
AcDbFace* pFace = NULL;
|
|
AcGePlane SlicePlan;
|
|
|
|
for (int i = 0;i < arFace.length();++i)
|
|
{
|
|
pFace = AcDbFace::cast((AcRxObject*)arFace[i]);
|
|
if (pFace != NULL)
|
|
{
|
|
GetPlaneFromSpecFace(pFace, ptOr, SlicePlan);
|
|
pRetSolid->getSlice(SlicePlan, Adesk::kFalse, pTmpSolid);
|
|
}
|
|
}
|
|
}
|
|
|
|
return pRetSolid;
|
|
}
|
|
|
|
AcDb3dSolid* TGDrawThunder::GetSolidFromFace(AcDbFace* pFace, double dHeight)
|
|
{
|
|
AcDb3dSolid* pSolid = NULL;
|
|
|
|
if (pFace != NULL)
|
|
{
|
|
AcGePoint3d arPt[4];
|
|
pFace->getVertexAt(0, arPt[0]);
|
|
pFace->getVertexAt(1, arPt[1]);
|
|
pFace->getVertexAt(2, arPt[2]);
|
|
arPt[3] = arPt[0];
|
|
|
|
AcDbLine* pLine = NULL;
|
|
AcDbVoidPtrArray arLines;
|
|
for (int i = 0;i < 3;++i)
|
|
{
|
|
pLine = new AcDbLine(arPt[i],arPt[i+1]);
|
|
arLines.append(pLine);
|
|
}
|
|
|
|
AcDbVoidPtrArray arRegs;
|
|
AcDbRegion::createFromCurves(arLines, arRegs);
|
|
if (arRegs.length() > 0)
|
|
{
|
|
AcDbRegion* pReg = AcDbRegion::cast((AcRxObject*)arRegs[0]);
|
|
if (pReg != NULL)
|
|
{
|
|
pSolid = new AcDb3dSolid;
|
|
pSolid->extrude(pReg, dHeight, 0.0);
|
|
}
|
|
}
|
|
|
|
ReleasePtrArray(arLines);
|
|
ReleasePtrArray(arRegs);
|
|
}
|
|
|
|
return pSolid;
|
|
}
|
|
|
|
void TGDrawThunder::GetPlaneFromSpecFace(AcDbFace* pFace, const AcGePoint3d& ptOr, AcGePlane& plan)
|
|
{
|
|
if (pFace != NULL)
|
|
{
|
|
AcGePoint3d pt1,pt2,pt3;
|
|
pFace->getVertexAt(0, pt1);
|
|
pFace->getVertexAt(1, pt2);
|
|
pFace->getVertexAt(2, pt3);
|
|
|
|
plan.set(pt1, pt2, pt3);
|
|
|
|
AcGePoint3d ptOn;
|
|
ptOn = ptOr.orthoProject(plan);
|
|
AcGeVector3d vtNor = ptOr - ptOn;
|
|
|
|
plan.set(ptOn, vtNor);
|
|
}
|
|
}
|
|
|
|
void TGDrawThunder::CreateSliceFace(AcDbArc* pMainArc, const AcGePoint3d& ptS1, AcDbArc* pSubArc, const AcGePoint3d& ptS2, AcDbVoidPtrArray& arFace)
|
|
{
|
|
if (pMainArc != NULL && pSubArc != NULL)
|
|
{
|
|
// 收集点
|
|
int i,j;
|
|
double dParaS,dParaE,dT;
|
|
AcGePoint3d ptOn;
|
|
AcGePoint3dArray arPt1,arPt2;
|
|
AcGeDoubleArray arDPara;
|
|
|
|
// 弧线1
|
|
pMainArc->getStartParam(dParaS);
|
|
pMainArc->getEndParam(dParaE);
|
|
|
|
int nCount = (int)((dParaE - dParaS)/DSPACE);
|
|
arDPara.append(dParaS);
|
|
for (i = 1;i <= nCount;++i)
|
|
{
|
|
dT = dParaS + DSPACE * i;
|
|
arDPara.append(dT);
|
|
}
|
|
arDPara.append(dParaE);
|
|
|
|
for (j = 0;j < arDPara.length();++j)
|
|
{
|
|
dT = arDPara[j];
|
|
pMainArc->getPointAtParam(dT, ptOn);
|
|
arPt1.append(ptOn);
|
|
}
|
|
|
|
if (arPt1.length() < 2) return;
|
|
|
|
// 弧线2
|
|
arDPara.setLogicalLength(0);
|
|
pSubArc->getStartParam(dParaS);
|
|
pSubArc->getEndParam(dParaE);
|
|
|
|
nCount = (int)((dParaE - dParaS)/DSPACE);
|
|
arDPara.append(dParaS);
|
|
for (i = 1;i < nCount;++i)
|
|
{
|
|
dT = dParaS + DSPACE * i;
|
|
arDPara.append(dT);
|
|
}
|
|
arDPara.append(dParaE);
|
|
|
|
for (j = 0;j < arDPara.length();++j)
|
|
{
|
|
dT = arDPara[j];
|
|
pSubArc->getPointAtParam(dT, ptOn);
|
|
arPt2.append(ptOn);
|
|
}
|
|
|
|
if (arPt2.length() < 2) return;
|
|
|
|
AcGePoint3d ptTmp;
|
|
pMainArc->getStartPoint(ptTmp);
|
|
if (ptTmp.distanceTo(ptS1) > 1e-3)
|
|
{
|
|
arPt1.reverse();
|
|
}
|
|
pSubArc->getStartPoint(ptTmp);
|
|
if (ptTmp.distanceTo(ptS2) > 1e-3)
|
|
{
|
|
arPt2.reverse();
|
|
}
|
|
|
|
if (ptS1.distanceTo(ptS2) < 1e-3)
|
|
{
|
|
arPt2.removeFirst();
|
|
}
|
|
|
|
// 创建face
|
|
AcDbFace* pFace = NULL;
|
|
if (arPt1.length() > arPt2.length())
|
|
{
|
|
for (i = 0;i < arPt1.length()-1;++i)
|
|
{
|
|
if (i >= arPt2.length())
|
|
{
|
|
pFace = new AcDbFace(arPt2.last(),arPt1[i],arPt1[i+1]);
|
|
arFace.append(pFace);
|
|
}
|
|
else
|
|
{
|
|
pFace = new AcDbFace(arPt2[i],arPt1[i],arPt1[i+1]);
|
|
arFace.append(pFace);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = 0;i < arPt1.length()-1;++i)
|
|
{
|
|
pFace = new AcDbFace(arPt2[i],arPt1[i],arPt1[i+1]);
|
|
arFace.append(pFace);
|
|
}
|
|
|
|
for (i;i < arPt2.length()-1;++i)
|
|
{
|
|
pFace = new AcDbFace(arPt1.last(),arPt2[i],arPt2[i+1]);
|
|
arFace.append(pFace);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
AcDbArc* TGDrawThunder::GetSolidTopArc(AcDb3dSolid* pSolid1,const CCaculateResult& result1,const CCaculateResult& result2)
|
|
{
|
|
AcDbArc* pArc = NULL;
|
|
|
|
if (pSolid1 != NULL)
|
|
{
|
|
std::list<LINEPTPAIR> lstPtPair;
|
|
LINEPTPAIR ptPair;
|
|
AcGePoint3d ptS,ptE;
|
|
|
|
int nScale = 1;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
nScale *= 1000;
|
|
}
|
|
|
|
ptPair.pt1 = result1.m_ptInsert;
|
|
ptPair.pt1.z += result1.m_dHeight * nScale;
|
|
ptPair.pt2 = result2.m_ptInsert;
|
|
ptPair.pt2.z += result2.m_dHeight * nScale;
|
|
lstPtPair.push_back(ptPair);
|
|
|
|
pArc = GetSolidTopArcByLoop(pSolid1, lstPtPair);
|
|
}
|
|
|
|
return pArc;
|
|
}
|
|
|
|
AcDbArc* TGDrawThunder::GetSolidTopArcByLoop(AcDbEntity* pEnt, std::list<LINEPTPAIR>& lstPtPair)
|
|
{
|
|
AcDbArc* pRetArc = NULL;
|
|
|
|
if (pEnt != NULL)
|
|
{
|
|
AcDbVoidPtrArray arPtr;
|
|
pEnt->explode(arPtr);
|
|
|
|
AcGePoint3d ptS,ptE;
|
|
AcGePoint3d ptT,ptT2;
|
|
AcDbArc* pArc = NULL;
|
|
for (int i = 0;i < arPtr.length();++i)
|
|
{
|
|
pArc = AcDbArc::cast((AcDbEntity*)arPtr[i]);
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->getStartPoint(ptS);
|
|
pArc->getEndPoint(ptE);
|
|
|
|
std::list<LINEPTPAIR>::iterator it;
|
|
for (it = lstPtPair.begin();it != lstPtPair.end();++it)
|
|
{
|
|
ptT = it->pt1;
|
|
ptT2 = it->pt2;
|
|
|
|
if ((ptS.distanceTo(it->pt1) < 1e-3 &&
|
|
ptE.distanceTo(it->pt2) < 1e-3 ) ||
|
|
(ptS.distanceTo(it->pt2) < 1e-3 &&
|
|
ptE.distanceTo(it->pt1) < 1e-3 ) )
|
|
{
|
|
pRetArc = new AcDbArc;
|
|
pRetArc->copyFrom(pArc);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pRetArc != NULL) break;
|
|
}
|
|
else
|
|
{
|
|
pRetArc = GetSolidTopArcByLoop((AcDbEntity*)arPtr[i], lstPtPair);
|
|
if (pRetArc != NULL)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ReleasePtrArray(arPtr);
|
|
}
|
|
|
|
return pRetArc;
|
|
}
|
|
|
|
AcDb3dSolid* TGDrawThunder::CreateExtendSolid(const AcGePoint3dArray& arPts, const AcGeVector3d& vtDir, double dLength)
|
|
{
|
|
AcDb3dSolid* pRetSolid = NULL;
|
|
|
|
if (arPts.length() > 2)
|
|
{
|
|
AcGePoint3dArray arLoc;
|
|
arLoc.append(arPts);
|
|
arLoc.append(arPts.first());
|
|
|
|
AcDbLine* pLine = NULL;
|
|
AcDbVoidPtrArray arLines,arRegs;
|
|
int nCount = arLoc.length() - 1;
|
|
for (int i = 0;i < nCount;++i)
|
|
{
|
|
pLine = new AcDbLine(arLoc[i], arLoc[i+1]);
|
|
arLines.append(pLine);
|
|
}
|
|
|
|
AcDbRegion::createFromCurves(arLines, arRegs);
|
|
|
|
if (arRegs.length() > 0)
|
|
{
|
|
AcDbRegion* pReg = AcDbRegion::cast((AcRxObject*)arRegs[0]);
|
|
if (pReg != NULL)
|
|
{
|
|
pRetSolid = ExtrudeSolid(pReg, vtDir, dLength);
|
|
}
|
|
}
|
|
|
|
ReleasePtrArray(arLines);
|
|
ReleasePtrArray(arRegs);
|
|
}
|
|
|
|
return pRetSolid;
|
|
}
|
|
|
|
void TGDrawThunder::ReleasePtrArray(AcDbVoidPtrArray& arPtr)
|
|
{
|
|
for (int i = 0;i < arPtr.length();++i)
|
|
{
|
|
delete (AcDbEntity*)arPtr[i];
|
|
}
|
|
|
|
arPtr.setLogicalLength(0);
|
|
}
|
|
|
|
void TGDrawThunder::ShowPtrArray(AcDbVoidPtrArray& arPtr)
|
|
{
|
|
AcDbGroup* pGroup = new AcDbGroup;
|
|
|
|
for (int i = 0;i < arPtr.length();++i)
|
|
{
|
|
pGroup->append(AddToCurrentSpace((AcDbEntity*)arPtr[i], Adesk::kTrue));
|
|
}
|
|
|
|
AcDbDictionary* pGroupDict = NULL;
|
|
acdbHostApplicationServices()->workingDatabase()
|
|
->getGroupDictionary(pGroupDict, AcDb::kForWrite);
|
|
if (pGroupDict != NULL)
|
|
{
|
|
AcDbObjectId id;
|
|
pGroupDict->setAt(_T("*A"),pGroup,id);
|
|
pGroupDict->close();
|
|
pGroup->close();
|
|
}
|
|
else
|
|
{
|
|
delete pGroup;
|
|
}
|
|
|
|
arPtr.setLogicalLength(0);
|
|
}
|
|
|
|
AcDbLine* TGDrawThunder::GetSolidExtrudePath(AcDb3dSolid* pSolid1, AcDb3dSolid* pSolid2, std::list<LINEPTPAIR>& lstPtPair)
|
|
{
|
|
AcDbLine* pLine = NULL;
|
|
|
|
if (pSolid1 != NULL &&
|
|
pSolid2 != NULL &&
|
|
lstPtPair.size() > 0)
|
|
{
|
|
AcGePoint3d ptS,ptE;
|
|
if (GetSolidCopingLowPoint(pSolid1, lstPtPair, ptS) &&
|
|
GetSolidCopingLowPoint(pSolid2, lstPtPair, ptE) )
|
|
{
|
|
pLine = new AcDbLine(ptS, ptE);
|
|
}
|
|
}
|
|
|
|
return pLine;
|
|
}
|
|
|
|
BOOL TGDrawThunder::GetSolidCopingLowPoint(AcDbEntity* pEnt, std::list<LINEPTPAIR>& lstPtPair, AcGePoint3d& ptOut)
|
|
{
|
|
BOOL bSuc = FALSE;
|
|
|
|
if (pEnt != NULL)
|
|
{
|
|
AcDbVoidPtrArray arPtr;
|
|
pEnt->explode(arPtr);
|
|
|
|
AcGePoint3d ptS,ptE;
|
|
AcDbArc* pArc = NULL;
|
|
for (int i = 0;i < arPtr.length();++i)
|
|
{
|
|
pArc = AcDbArc::cast((AcDbEntity*)arPtr[i]);
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->getStartPoint(ptS);
|
|
pArc->getEndPoint(ptE);
|
|
|
|
std::list<LINEPTPAIR>::iterator it;
|
|
for (it = lstPtPair.begin();it != lstPtPair.end();++it)
|
|
{
|
|
if ((ptS.distanceTo(it->pt1) < 1e-3 &&
|
|
ptE.distanceTo(it->pt2) < 1e-3 ) ||
|
|
(ptS.distanceTo(it->pt2) < 1e-3 &&
|
|
ptE.distanceTo(it->pt1) < 1e-3 ) )
|
|
{
|
|
ptOut = GetArcMidPiont(pArc, it->pt1, it->pt2);
|
|
bSuc = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bSuc) break;
|
|
}
|
|
else
|
|
{
|
|
if (GetSolidCopingLowPoint((AcDbEntity*)arPtr[i], lstPtPair, ptOut))
|
|
{
|
|
bSuc = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int j = 0;j < arPtr.length();++j)
|
|
{
|
|
delete (AcDbEntity*)arPtr[j];
|
|
}
|
|
}
|
|
|
|
return bSuc;
|
|
}
|
|
|
|
AcGePoint3d TGDrawThunder::GetArcMidPiont(AcDbArc* pArc, const AcGePoint3d& ptS, const AcGePoint3d& ptE)
|
|
{
|
|
if (pArc != NULL)
|
|
{
|
|
AcDbLine ln(ptS, ptE);
|
|
AcGePoint3d ptOn;
|
|
AcGePoint3d ptCent = pArc->center();
|
|
ln.getClosestPointTo(ptCent, ptOn);
|
|
ln.setStartPoint(ptOn);
|
|
ln.setEndPoint(ptCent);
|
|
|
|
AcGePoint3dArray arPt;
|
|
ln.intersectWith(pArc, AcDb::kExtendThis, arPt);
|
|
if (arPt.length() > 0)
|
|
{
|
|
return arPt.first();
|
|
}
|
|
}
|
|
|
|
return AcGePoint3d::kOrigin;
|
|
}
|
|
|
|
AcDb3dSolid* TGDrawThunder::CreateUnion3DRegion(const AcDb3dSolid* pBaseSolid,CCaculateResult& data1,CCaculateResult& data2,AcDbCurve* pCve)
|
|
{
|
|
if (pBaseSolid == NULL || pCve == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
AcDb3dSolid* pSolid = NULL;
|
|
|
|
// 截取面reg
|
|
AcGeVector3d vt = data2.m_ptInsert - data1.m_ptInsert;
|
|
AcGePlane plan;
|
|
plan.set(data1.m_ptInsert,vt,AcGeVector3d::kZAxis);
|
|
|
|
AcDbRegion* pReg = NULL;
|
|
Acad::ErrorStatus es = pBaseSolid->getSection(plan, pReg);
|
|
if (pReg != NULL)
|
|
{
|
|
pSolid = ExtrudeSolidAlongPath(pReg, pCve);
|
|
delete pReg;
|
|
}
|
|
|
|
return pSolid;
|
|
}
|
|
|
|
AcDb3dSolid* TGDrawThunder::CreateBoolSubtractSolid(const AcDb3dSolid* pBaseSolid,CCaculateResult& data1,CCaculateResult& data2,AcDbCurve* pCve)
|
|
{
|
|
if (pBaseSolid == NULL || pCve == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
AcDb3dSolid* pSolid = NULL;
|
|
|
|
// 创建reg
|
|
AcGePoint3d pt1 = data1.m_ptInsert;
|
|
AcGePoint3d pt2 = data2.m_ptInsert;
|
|
AcGePoint3d pt3 = pt2;
|
|
AcGePoint3d pt4 = pt1;
|
|
|
|
int nScale = 1;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
nScale *= 1000;
|
|
}
|
|
double dH = data1.m_dHeight;
|
|
if (dH < data2.m_dHeight)
|
|
dH = data2.m_dHeight;
|
|
|
|
pt1.z += dH * nScale;
|
|
pt2.z += dH * nScale;
|
|
|
|
AcDbVoidPtrArray arPtr;
|
|
AcDbLine* pLine = NULL;
|
|
pLine = new AcDbLine(pt1, pt2);
|
|
arPtr.append(pLine);
|
|
pLine = new AcDbLine(pt2, pt3);
|
|
arPtr.append(pLine);
|
|
pLine = new AcDbLine(pt3, pt4);
|
|
arPtr.append(pLine);
|
|
pLine = new AcDbLine(pt4, pt1);
|
|
arPtr.append(pLine);
|
|
|
|
AcDbVoidPtrArray arRegions;
|
|
AcDbRegion::createFromCurves(arPtr, arRegions);
|
|
ReleasePtrArray(arPtr);
|
|
|
|
if (arRegions.length() < 1)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
AcDbRegion* pReg = (AcDbRegion*)arRegions[0];
|
|
|
|
if (pReg != NULL)
|
|
{
|
|
AcGePoint3d ptS,ptE;
|
|
CalcLinePorts(pReg, pCve, ptS, ptE);
|
|
AcGeVector3d vt = ptS - ptE;
|
|
ptE = ptS + vt;
|
|
|
|
AcGeVector3d vtNor = CalcRegionNormal(ptE, pReg);
|
|
pSolid = ExtrudeSolid(pReg, vtNor, vt.length());
|
|
}
|
|
|
|
ReleasePtrArray(arRegions);
|
|
|
|
return pSolid;
|
|
}
|
|
|
|
void TGDrawThunder::DrawThunder2DArea(LPCTSTR pszGroupNo, const AcDbObjectIdArray& arID)
|
|
{
|
|
if (pszGroupNo == NULL ||
|
|
arID.length() < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CTGTempTol locTol(0.1, 0.1);
|
|
|
|
// 计算避雷针数据
|
|
AcGeDoubleArray arProHeight;
|
|
CThunderXData xd;
|
|
xd.GetProtectHeightFromObjEx(arID[0], arProHeight);
|
|
|
|
lstCltResult lstData;
|
|
CalcThunderData(pszGroupNo, arProHeight, arID, lstData);
|
|
|
|
// 绘制三维
|
|
DrawThunder3DArea(pszGroupNo, lstData, TRUE);
|
|
}
|
|
|
|
void TGDrawThunder::DrawThunderLine(LPCTSTR pszGroupNo, const AcDbObjectIdArray& arID)
|
|
{
|
|
if (pszGroupNo == NULL ||
|
|
arID.length() < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CTGTempTol locTol(0.1, 0.1);
|
|
|
|
// 计算避雷针数据
|
|
AcGeDoubleArray arProHeight;
|
|
CThunderXData xd;
|
|
xd.GetProtectHeightFromObjEx(arID[0], arProHeight);
|
|
|
|
MapThunderLineCltResult mapData;
|
|
CalcThunLineData(pszGroupNo, arProHeight, arID, mapData);
|
|
|
|
// 绘制避雷线三维
|
|
DrawThunLine3D(pszGroupNo, mapData, TRUE);
|
|
}
|
|
|
|
AcGePoint3d TGDrawThunder::CalcSolidTopPoint(const CCaculateResult& result)
|
|
{
|
|
int nScale = 1;
|
|
if (!DocGetMeterUnitDraw())
|
|
nScale *= 1000;
|
|
|
|
AcGePoint3d ptTop;
|
|
|
|
if (result.m_dHeight < result.m_dGroundRadius)
|
|
{
|
|
ptTop = result.m_ptInsert;
|
|
ptTop.z += result.m_dHeight*nScale;
|
|
}
|
|
else
|
|
{
|
|
AcGePoint3d ptS = result.m_ptInsert;
|
|
AcGePoint3d ptE = ptS;
|
|
ptE.z += result.m_dHeight*nScale;
|
|
|
|
AcDbLine ln(ptS,ptE);
|
|
AcDbCircle cir(result.m_ptGroundCenter,AcGeVector3d::kXAxis,result.m_dGroundRadius*nScale);
|
|
AcGePoint3dArray arPt;
|
|
ln.intersectWith(&cir,AcDb::kOnBothOperands,arPt);
|
|
if (arPt.length() == 1)
|
|
{
|
|
ptTop = arPt.first();
|
|
}
|
|
else if (arPt.length() == 2)
|
|
{
|
|
double dDist1 = ptS.distanceTo(arPt.first());
|
|
double dDist2 = ptS.distanceTo(arPt.last());
|
|
if (dDist1 > dDist2)
|
|
{
|
|
ptTop = arPt.last();
|
|
}
|
|
else
|
|
{
|
|
ptTop = arPt.first();
|
|
}
|
|
}
|
|
}
|
|
|
|
return ptTop;
|
|
}
|
|
|
|
//生成单针的避雷区域实体
|
|
AcDb3dSolid* TGDrawThunder::Create3DSolid(const CCaculateResult& result)
|
|
{
|
|
int nScale = 1;
|
|
if (!DocGetMeterUnitDraw())
|
|
nScale *= 1000;
|
|
|
|
AcGePoint3d ptStart = result.m_ptInsert;
|
|
AcGePoint3d ptEnd = CalcSolidTopPoint(result);
|
|
|
|
AcDbLine* pLine = new AcDbLine;
|
|
pLine->setStartPoint(ptStart);
|
|
pLine->setEndPoint(ptEnd);
|
|
pLine->setNormal(AcGeVector3d::kXAxis);
|
|
// CopyEnt(pLine);
|
|
|
|
//得到需要旋转的REG
|
|
AcGePoint3d ptReg = result.m_ptGroundCenter;
|
|
ptReg.z = 0.0;
|
|
AcDbLine* pLine2 = new AcDbLine;
|
|
pLine2->setStartPoint(ptReg);
|
|
pLine2->setEndPoint(ptStart);
|
|
pLine2->setNormal(AcGeVector3d::kXAxis);
|
|
// CopyEnt(pLine2);
|
|
|
|
AcDbCircle cir(result.m_ptGroundCenter,AcGeVector3d::kXAxis,result.m_dGroundRadius*nScale);
|
|
AcDbArc* pArc = GetArcSegmentFromCircle(&cir, ptEnd, ptReg);
|
|
|
|
// CopyEnt(pArc);
|
|
|
|
AcDbVoidPtrArray arPtrs;
|
|
arPtrs.append(pArc);
|
|
arPtrs.append(pLine);
|
|
arPtrs.append(pLine2);
|
|
|
|
//生成3D实体
|
|
AcDb3dSolid *pSolid = NULL;
|
|
AcDbVoidPtrArray arRegions;
|
|
AcDbRegion::createFromCurves(arPtrs, arRegions);
|
|
|
|
if (arRegions.length() > 0)
|
|
{
|
|
AcDbRegion* pRegion = AcDbRegion::cast((AcDbEntity*)arRegions[0]);
|
|
if (pRegion != NULL)
|
|
{
|
|
AcGeVector3d vtAxis = ptEnd - ptStart;
|
|
|
|
AcDbRevolveOptions rev;
|
|
pSolid = new AcDb3dSolid;
|
|
Acad::ErrorStatus es = pSolid->revolve(pRegion,result.m_ptInsert,vtAxis,2 * PI);
|
|
//acutPrintf(_T("\nrevolve %d!"),es);
|
|
//ZWCAD 不支持，改为微分方式
|
|
//acedAlert(_T("ZRX 开发包目前没有实现AcDb3dSolid 接口!"));
|
|
}
|
|
}
|
|
|
|
ReleasePtrArray(arPtrs);
|
|
ReleasePtrArray(arRegions);
|
|
|
|
return pSolid;
|
|
}
|
|
|
|
AcDbArc* TGDrawThunder::GetArcSegmentFromCircle(AcDbCircle* pCir, const AcGePoint3d& ptS, const AcGePoint3d& ptE, BOOL bInferior)
|
|
{
|
|
AcDbArc* pArc = NULL;
|
|
|
|
if (pCir != NULL)
|
|
{
|
|
double dPara,dPara2;
|
|
pCir->getParamAtPoint(ptS,dPara);
|
|
pCir->getParamAtPoint(ptE,dPara2);
|
|
|
|
if (fabs(dPara-0.0) < 1e-3 &&
|
|
dPara2 > PI )
|
|
{
|
|
dPara = 2*PI;
|
|
}
|
|
else if (fabs(dPara2-0.0) < 1e-3 &&
|
|
dPara > PI)
|
|
{
|
|
dPara2 = 2*PI;
|
|
}
|
|
|
|
if (bInferior) // 劣弧
|
|
{
|
|
if (dPara > dPara2)
|
|
{
|
|
double dT = dPara;
|
|
dPara = dPara2;
|
|
dPara2 = dT;
|
|
}
|
|
}
|
|
else // 优弧
|
|
{
|
|
if (dPara < dPara2)
|
|
{
|
|
double dT = dPara;
|
|
dPara = dPara2;
|
|
dPara2 = dT;
|
|
}
|
|
}
|
|
|
|
pArc = new AcDbArc(pCir->center(), pCir->normal(), pCir->radius(), dPara, dPara2);
|
|
}
|
|
|
|
return pArc;
|
|
}
|
|
|
|
//得到2针的避雷区域
|
|
AcDb3dSolid* TGDrawThunder::GetThunderAreaBy2Pin(const CCaculateResult& result1,const CCaculateResult& result2,BOOL bCheck)
|
|
{
|
|
AcDb3dSolid* pRetInt = NULL;
|
|
|
|
double dHeight1 = 0.0,dHeight2 = 0.0,dGroundRadius = 0.0,dProRadius1 = 0.0,dProRadius2 = 0.0;
|
|
double dScale = 1.0;
|
|
if (!DocGetMeterUnitDraw())
|
|
dScale *= 1000;
|
|
|
|
dHeight1 = result1.m_dHeight*dScale;
|
|
dHeight2 = result2.m_dHeight*dScale;
|
|
dGroundRadius = result1.m_dGroundRadius*dScale;
|
|
dProRadius1 = result1.m_dProRadius*dScale;
|
|
dProRadius2 = result2.m_dProRadius*dScale;
|
|
|
|
//判断两针之间是否有影响
|
|
if (bCheck)
|
|
{
|
|
double dDis = result1.m_ptInsert.distanceTo(result2.m_ptInsert);
|
|
if (fabs(dHeight1 - dHeight2) < 0.01)
|
|
{
|
|
if (dDis >= 2*pow(dHeight2*(2*dGroundRadius-dHeight2),0.5))
|
|
{
|
|
return pRetInt;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dDis >= pow(dHeight1*(2*dGroundRadius-dHeight1),0.5) + pow(dHeight2*(2*dGroundRadius-dHeight2),0.5))
|
|
{
|
|
return pRetInt;
|
|
}
|
|
}
|
|
}
|
|
|
|
AcDb3dSolid *pCircleSolid1 = NULL;
|
|
AcDb3dSolid *pCircleSolid2 = NULL;
|
|
AcDb3dSolid *pTopSolid = NULL;
|
|
//生成滚球实体
|
|
GetSphereSolids(result1.m_ptInsert,result2.m_ptInsert,dProRadius1,dProRadius2,dGroundRadius,pCircleSolid1,pCircleSolid2);
|
|
|
|
if (pCircleSolid1 != NULL && pCircleSolid2 != NULL)
|
|
{
|
|
pTopSolid = GetTopSphereSolid(result1,result2,dGroundRadius);
|
|
pRetInt = Get2DIntersectionArea(result1,result2);
|
|
|
|
if (pRetInt != NULL && pTopSolid != NULL)
|
|
{
|
|
// 如果布尔运算失败则会删除两实体的内部对象
|
|
// 此处要做保留操作
|
|
AcDb3dSolid* pTmpInt = new AcDb3dSolid;
|
|
pTmpInt->copyFrom(pRetInt);
|
|
if (pRetInt->booleanOper(AcDb::kBoolSubtract,pCircleSolid1) != Acad::eOk)
|
|
{
|
|
pRetInt->copyFrom(pTmpInt);
|
|
}
|
|
else
|
|
{
|
|
pTmpInt->copyFrom(pRetInt);
|
|
};
|
|
|
|
if (pRetInt->booleanOper(AcDb::kBoolSubtract,pCircleSolid2) != Acad::eOk)
|
|
{
|
|
pRetInt->copyFrom(pTmpInt);
|
|
}
|
|
else
|
|
{
|
|
pTmpInt->copyFrom(pRetInt);
|
|
}
|
|
|
|
if (fabs(result1.m_dHeight-result2.m_dHeight) < 1e-3)
|
|
{
|
|
if (pRetInt->booleanOper(AcDb::kBoolSubtract,pTopSolid) != Acad::eOk)
|
|
{
|
|
pRetInt->copyFrom(pTmpInt);
|
|
}
|
|
}
|
|
|
|
delete pTmpInt;
|
|
}
|
|
}
|
|
|
|
if (pCircleSolid1 != NULL)
|
|
delete pCircleSolid1;
|
|
|
|
if (pCircleSolid2 != NULL)
|
|
delete pCircleSolid2;
|
|
|
|
if (pTopSolid != NULL)
|
|
delete pTopSolid;
|
|
|
|
return pRetInt;
|
|
}
|
|
|
|
//生成滚球实体
|
|
void TGDrawThunder::GetSphereSolids(const AcGePoint3d& ptInsert1,const AcGePoint3d& ptInsert2,double dProRadius1,double dProRadius2,double dGroundRadius,AcDb3dSolid*& pCircleSolid1,AcDb3dSolid*& pCircleSolid2)
|
|
{
|
|
AcDbCircle circle1(ptInsert1,AcGeVector3d::kZAxis,dProRadius1);
|
|
AcDbCircle circle2(ptInsert2,AcGeVector3d::kZAxis,dProRadius2);
|
|
|
|
AcGePoint3dArray arPt;
|
|
IntersectWith2Circle(&circle1, &circle2, arPt);
|
|
if (arPt.length() != 2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//得到最大保护半径的交点
|
|
AcGeMatrix3d matrix;
|
|
AcGePoint3d ptCen1 = arPt[0];
|
|
AcGePoint3d ptCen2 = arPt[1];
|
|
|
|
ptCen1.z += dGroundRadius;
|
|
ptCen2.z += dGroundRadius;
|
|
|
|
pCircleSolid1 = new AcDb3dSolid;
|
|
if (pCircleSolid1 != NULL)
|
|
{
|
|
pCircleSolid1->createSphere(dGroundRadius);
|
|
matrix.setToTranslation(ptCen1.asVector());
|
|
pCircleSolid1->transformBy(matrix);
|
|
}
|
|
|
|
pCircleSolid2 = new AcDb3dSolid;
|
|
if (pCircleSolid2 != NULL)
|
|
{
|
|
pCircleSolid2->createSphere(dGroundRadius);
|
|
matrix.setToTranslation(ptCen2.asVector());
|
|
pCircleSolid2->transformBy(matrix);
|
|
}
|
|
}
|
|
|
|
//生成2避雷针中间一块区域
|
|
AcDb3dSolid* TGDrawThunder::Get2DIntersectionArea(const CCaculateResult& result1,const CCaculateResult& result2)
|
|
{
|
|
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
|
if (pSolid == NULL)
|
|
return NULL;
|
|
|
|
double dHeight1 = result1.m_dHeight;
|
|
double dHeight2 = result2.m_dHeight;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dHeight1 *= 1000;
|
|
dHeight2 *= 1000;
|
|
}
|
|
|
|
AcDbRegion *pRegion = GetRegionByCircle(result1,result2);
|
|
if (pRegion == NULL)
|
|
{
|
|
delete pSolid;
|
|
return NULL;
|
|
}
|
|
|
|
Acad::ErrorStatus es;
|
|
if (dHeight2 > dHeight1)
|
|
es = pSolid->extrude(pRegion,dHeight2,0);
|
|
else
|
|
es = pSolid->extrude(pRegion,dHeight1,0);
|
|
|
|
delete pRegion;
|
|
|
|
return pSolid;
|
|
}
|
|
|
|
//生成顶部球实体
|
|
AcDb3dSolid* TGDrawThunder::GetTopSphereSolid(const CCaculateResult& result1,const CCaculateResult& result2,double dGroundRadius,AcGePoint3d* pt)
|
|
{
|
|
AcGePoint3d ptCen,ptThunderCen1,ptThunderCen2;
|
|
ptThunderCen1 = result1.m_ptInsert;
|
|
ptThunderCen2 = result2.m_ptInsert;
|
|
|
|
double dHeight1 = 0.0,dHeight2 = 0.0;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dHeight1 = result1.m_dHeight*1000;
|
|
dHeight2 = result2.m_dHeight*1000;
|
|
}
|
|
else
|
|
{
|
|
dHeight1 = result1.m_dHeight;
|
|
dHeight2 = result2.m_dHeight;
|
|
}
|
|
double dDis = result1.m_ptInsert.distanceTo(result2.m_ptInsert);
|
|
double dDisLeft = (pow(dGroundRadius-dHeight2,2) - pow(dGroundRadius-dHeight1,2) + pow(dDis,2))/(2*dDis);
|
|
|
|
AcDbLine line(result1.m_ptInsert,result2.m_ptInsert);
|
|
line.getPointAtDist(dDisLeft,ptCen);
|
|
|
|
ptCen.z += dGroundRadius;
|
|
ptThunderCen1.z += dHeight1;
|
|
ptThunderCen2.z += dHeight2;
|
|
|
|
double dRadius = ptThunderCen1.distanceTo(ptCen);
|
|
|
|
Acad::ErrorStatus es;
|
|
AcDb3dSolid *pSolid = new AcDb3dSolid;
|
|
if (pSolid == NULL)
|
|
return NULL;
|
|
|
|
es = pSolid->createSphere(dRadius);
|
|
AcGeMatrix3d matrix;
|
|
matrix.setCoordSystem(ptCen,AcGeVector3d::kXAxis,AcGeVector3d::kYAxis,AcGeVector3d::kZAxis);
|
|
|
|
pSolid->transformBy(matrix);
|
|
|
|
if (pt != NULL)
|
|
{
|
|
*pt = ptCen;
|
|
}
|
|
|
|
return pSolid;
|
|
}
|
|
|
|
//生成3维实体对象
|
|
void TGDrawThunder::MakeThunderEntity(LPCTSTR pszGroupNo, lstCltResult& lstData, BOOL bPreview)
|
|
{
|
|
AcDb3dSolid *pSolid = NULL;
|
|
CThunderXData thundXData;
|
|
|
|
//单针实体
|
|
lstCltResult::iterator it;
|
|
for (it = lstData.begin();it != lstData.end();++it)
|
|
{
|
|
pSolid = Create3DSolid(*it);
|
|
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setLayer(m_strLayer3d);
|
|
pSolid->setColorIndex(m_nMultiPinColorIndex);
|
|
thundXData.SetXData(pSolid, TEL_GROUP_NO, pszGroupNo);
|
|
if (bPreview)
|
|
{
|
|
pSolid->setLayer(LAY_PREVIEW_THUNDER);
|
|
m_arPreview.append(pSolid);
|
|
}
|
|
else
|
|
{
|
|
m_arRegSolid.append(pSolid);
|
|
}
|
|
}
|
|
}
|
|
|
|
//生成2避雷针的区域
|
|
lstCltResult::iterator itSub;
|
|
for (it = lstData.begin();it != lstData.end();++it)
|
|
{
|
|
itSub = it;
|
|
itSub++;
|
|
for (itSub;itSub != lstData.end();++itSub)
|
|
{
|
|
pSolid = GetThunderAreaBy2Pin(*it,*itSub);
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setLayer(m_strLayer3d);
|
|
pSolid->setColorIndex(m_nMultiPinColorIndex);
|
|
thundXData.SetXData(pSolid, TEL_GROUP_NO, pszGroupNo);
|
|
if (bPreview)
|
|
{
|
|
pSolid->setLayer(LAY_PREVIEW_THUNDER);
|
|
m_arPreview.append(pSolid);
|
|
}
|
|
else
|
|
{
|
|
m_arRegSolid.append(pSolid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//生成3避雷针的区域
|
|
if (lstData.size() >= 3)
|
|
Make3CenThunderEntity(pszGroupNo, lstData, bPreview);
|
|
}
|
|
|
|
//显示层
|
|
void TGDrawThunder::ShowLayer(LPCTSTR lpLayerName,BOOL bShow)
|
|
{
|
|
if (lpLayerName == NULL)
|
|
return;
|
|
|
|
AcDbLayerTable *pLayerTable = NULL;
|
|
acdbHostApplicationServices()->workingDatabase()
|
|
->getSymbolTable(pLayerTable, AcDb::kForRead);
|
|
|
|
AcDbLayerTableRecord *pRecord = NULL;
|
|
AcDbObjectId id;
|
|
pLayerTable->getAt(lpLayerName,pRecord,AcDb::kForWrite);
|
|
pLayerTable->close();
|
|
|
|
if (pRecord == NULL)
|
|
return;
|
|
|
|
if (_tcsicmp(lpLayerName,LAY_PREVIEW_THUNDER) == 0)
|
|
{
|
|
AcCmColor color;
|
|
color.setColorIndex(4);
|
|
pRecord->setColor(color);
|
|
}
|
|
|
|
if (bShow)
|
|
pRecord->setIsOff(FALSE);
|
|
else
|
|
pRecord->setIsOff(TRUE);
|
|
|
|
pRecord->close();
|
|
}
|
|
|
|
//生成3针形成中间的避雷区域
|
|
void TGDrawThunder::Make3CenThunderEntity(LPCTSTR pszGroupNo, lstCltResult& lstData,BOOL bPreview, AcDbVoidPtrArray* pArPtr)
|
|
{
|
|
if (lstData.size() == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcArray<AcGePoint3d> arPtInsert;
|
|
AcGeDoubleArray arRadius;
|
|
lstCltResult::iterator it;
|
|
double dScale = 1.0;
|
|
if (!DocGetMeterUnitDraw())
|
|
dScale *= 1000;
|
|
|
|
for (it = lstData.begin();it != lstData.end();++it)
|
|
{
|
|
arPtInsert.append(it->m_ptInsert);
|
|
arRadius.append(it->m_dProRadius*dScale);
|
|
}
|
|
|
|
Acad::ErrorStatus es;
|
|
AcArray<AcDb3dSolid*> arSolid;
|
|
AcArray<AcGePoint3d> arPt;
|
|
//得到联合区域的边部滚球
|
|
GetSphereSolids(arPtInsert,arRadius,lstData.front().m_dGroundRadius*dScale,arSolid,arPt);
|
|
|
|
AcArray<AcDb3dSolid*> arInterSolid;
|
|
//得到中间区域
|
|
Get3DIntersectionArea(lstData,arPt,arInterSolid);
|
|
if (arInterSolid.length() == 0)
|
|
return;
|
|
|
|
CThunderXData thundXData;
|
|
AcDbVoidPtrArray arTop;
|
|
for (int m = 0; m < arInterSolid.length(); ++m)
|
|
{
|
|
if (m > 0)
|
|
{
|
|
GetSphereSolids(arPtInsert,arRadius,lstData.front().m_dGroundRadius*dScale,arSolid,arPt);
|
|
}
|
|
|
|
for (int k = 0; k < arSolid.length(); k++)
|
|
{
|
|
es = arInterSolid[m]->booleanOper(AcDb::kBoolSubtract,arSolid[k]);
|
|
}
|
|
|
|
GetTopSphereSolid(lstData,arTop);
|
|
|
|
if (arTop.length() < 1)
|
|
{
|
|
arSolid.setLogicalLength(0);
|
|
arPt.setLogicalLength(0);
|
|
delete arInterSolid[m];
|
|
continue;
|
|
}
|
|
|
|
for (int j = 0; j < arTop.length(); j++)
|
|
{
|
|
es = arInterSolid[m]->booleanOper(AcDb::kBoolSubtract,(AcDb3dSolid*)arTop[j]);
|
|
delete (AcDb3dSolid*)arTop[j];
|
|
}
|
|
|
|
arTop.setLogicalLength(0);
|
|
|
|
if (arInterSolid[m] != NULL)
|
|
{
|
|
arInterSolid[m]->setLayer(m_strLayer3d);
|
|
arInterSolid[m]->setColorIndex(m_nMultiPinColorIndex);
|
|
thundXData.SetXData(arInterSolid[m], TEL_GROUP_NO, pszGroupNo);
|
|
if (bPreview)
|
|
{
|
|
arInterSolid[m]->setLayer(LAY_PREVIEW_THUNDER);
|
|
m_arPreview.append(arInterSolid[m]);
|
|
if (pArPtr != NULL)
|
|
{
|
|
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
|
pSolid->copyFrom(arInterSolid[m]);
|
|
pArPtr->append(pSolid);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_arRegSolid.append(arInterSolid[m]);
|
|
if (pArPtr != NULL)
|
|
{
|
|
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
|
pSolid->copyFrom(arInterSolid[m]);
|
|
pArPtr->append(pSolid);
|
|
}
|
|
}
|
|
}
|
|
arPt.setLogicalLength(0);
|
|
}
|
|
}
|
|
|
|
//得到3针滚球球心
|
|
BOOL TGDrawThunder::Get3PinSphereCen(const AcGePoint3d& pt1,const AcGePoint3d& pt2,const AcGePoint3d& pt3,double dGroundRadius,const AcGeVector3d& vecParal,AcGePoint3d& ptCenter,double dProRadius)
|
|
{
|
|
AcGePlane plan(pt1,pt2,pt3);
|
|
AcGeVector3d vecNormal = plan.normal();
|
|
|
|
AcGeVector3d vec12,vec23,vec31;
|
|
vec12 = pt1 - pt2;
|
|
vec23 = pt2 - pt3;
|
|
vec31 = pt3 - pt1;
|
|
|
|
AcGeVector3d vecNormal12,vecNormal23,vecNormal31;
|
|
AcGePlane plan12(pt1,vec12,vecNormal);
|
|
AcGePlane plan23(pt2,vec23,vecNormal);
|
|
AcGePlane plan31(pt3,vec31,vecNormal);
|
|
|
|
vecNormal12 = plan12.normal();
|
|
vecNormal23 = plan23.normal();
|
|
vecNormal31 = plan31.normal();
|
|
vecNormal12.normalize();
|
|
vecNormal23.normalize();
|
|
vecNormal31.normalize();
|
|
|
|
//得到各边中点
|
|
AcGePoint3d ptCen12,ptCen23,ptCen31;
|
|
ptCen12.x = (pt1.x + pt2.x)/2;
|
|
ptCen12.y = (pt1.y + pt2.y)/2;
|
|
ptCen12.z = (pt1.z + pt2.z)/2;
|
|
ptCen23.x = (pt3.x + pt2.x)/2;
|
|
ptCen23.y = (pt3.y + pt2.y)/2;
|
|
ptCen23.z = (pt3.z + pt2.z)/2;
|
|
ptCen31.x = (pt1.x + pt3.x)/2;
|
|
ptCen31.y = (pt1.y + pt3.y)/2;
|
|
ptCen31.z = (pt1.z + pt3.z)/2;
|
|
|
|
AcGePoint3d ptEnd12,ptEnd23,ptEnd31;
|
|
AcGePoint3d ptStart12,ptStart23,ptStart31;
|
|
ptEnd12 = ptCen12 + vecNormal12*dGroundRadius;
|
|
ptEnd23 = ptCen23 + vecNormal23*dGroundRadius;
|
|
ptEnd31 = ptCen31 + vecNormal31*dGroundRadius;
|
|
ptStart12 = ptCen12 - vecNormal12*dGroundRadius;
|
|
ptStart23 = ptCen23 - vecNormal23*dGroundRadius;
|
|
ptStart31 = ptCen31 - vecNormal31*dGroundRadius;
|
|
|
|
AcDbLine line12(ptStart12,ptEnd12);
|
|
AcDbLine line23(ptStart23,ptEnd23);
|
|
|
|
AcGePoint3dArray arPts;
|
|
line12.intersectWith(&line23,AcDb::kExtendBoth,arPts);
|
|
if (arPts.length() != 1)
|
|
return FALSE;
|
|
|
|
//中垂线交点到点距离
|
|
double dDis = arPts[0].distanceTo(pt1);
|
|
if (dDis > dProRadius)
|
|
return FALSE;
|
|
//球心到面的投影距离
|
|
double dDisPer = pow(pow(dGroundRadius,2) - pow(dDis,2),0.5);
|
|
vecNormal.normalize();
|
|
if (vecNormal.angleTo(vecParal) < PI/2)
|
|
ptCenter = arPts[0] + vecNormal*dDisPer;
|
|
else
|
|
ptCenter = arPts[0] - vecNormal*dDisPer;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//生成3避雷针中间一块区域
|
|
AcDb3dSolid* TGDrawThunder::Get3DIntersectionArea(const CCaculateResult& result1,const CCaculateResult& result2,const CCaculateResult& result3 )
|
|
{
|
|
AcArray<AcGePoint3d> arPtInter;
|
|
double dRadius1 = result1.m_dProRadius;
|
|
double dRadius2 = result2.m_dProRadius;
|
|
double dRadius3 = result3.m_dProRadius;
|
|
|
|
if (!DocGetMeterUnitDraw()) //毫米单位
|
|
{
|
|
dRadius1 *= 1000;
|
|
dRadius2 *= 1000;
|
|
dRadius3 *= 1000;
|
|
}
|
|
Get3PeripheryPoints(result1.m_ptInsert,result2.m_ptInsert,result3.m_ptInsert,dRadius1,dRadius2,dRadius3,arPtInter);
|
|
|
|
AcDbVoidPtrArray arRegs;
|
|
AcDbLine line;
|
|
for (int i = 0; i < arPtInter.length(); ++i)
|
|
{
|
|
if (result1.m_ptInsert.distanceTo(arPtInter[i]) - dRadius1 < 0.01)
|
|
{
|
|
AcDbLine *pLine = new AcDbLine(result1.m_ptInsert,arPtInter[i]);
|
|
arRegs.append(pLine);
|
|
}
|
|
|
|
if (result2.m_ptInsert.distanceTo(arPtInter[i]) - dRadius2 < 0.01)
|
|
{
|
|
AcDbLine *pLine = new AcDbLine(result2.m_ptInsert,arPtInter[i]);
|
|
arRegs.append(pLine);
|
|
}
|
|
|
|
if (result3.m_ptInsert.distanceTo(arPtInter[i]) - dRadius3 < 0.01)
|
|
{
|
|
AcDbLine *pLine = new AcDbLine(result3.m_ptInsert,arPtInter[i]);
|
|
pLine->setColorIndex(1);
|
|
arRegs.append(pLine);
|
|
}
|
|
}
|
|
|
|
AcDbVoidPtrArray arRegions;
|
|
arRegions.setPhysicalLength(10);
|
|
arRegions.setGrowLength(1);
|
|
AcDbRegion::createFromCurves(arRegs, arRegions);
|
|
ReleasePtrArray(arRegs);
|
|
|
|
if (arRegions.length() != 1)
|
|
return NULL;
|
|
|
|
AcDbRegion *pReg = AcDbRegion::cast((AcRxObject*)arRegions[0]);
|
|
if (pReg == NULL)
|
|
return NULL;
|
|
|
|
double dHeight1 = result1.m_dHeight;
|
|
double dHeight2 = result2.m_dHeight;
|
|
double dHeight3 = result3.m_dHeight;
|
|
double dGroundRadius = result3.m_dGroundRadius;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dHeight1 *= 1000;
|
|
dHeight2 *= 1000;
|
|
dHeight3 *= 1000;
|
|
dGroundRadius *= 1000;
|
|
}
|
|
|
|
Acad::ErrorStatus es;
|
|
|
|
AcDb3dSolid *pSolid = new AcDb3dSolid;
|
|
if (dHeight1 >= dHeight2 && dHeight1 >= dHeight3)
|
|
es = pSolid->extrude(pReg,dHeight1,0);
|
|
else if (dHeight2 >= dHeight3 && dHeight2 >= dHeight1)
|
|
es = pSolid->extrude(pReg,dHeight2,0);
|
|
else if (dHeight3 >= dHeight2 && dHeight3 >= dHeight1)
|
|
es = pSolid->extrude(pReg,dHeight3,0);
|
|
|
|
ReleasePtrArray(arRegions);
|
|
|
|
return pSolid;
|
|
}
|
|
|
|
//得到两圆圆心到交点连成的REG
|
|
AcDbRegion *TGDrawThunder::GetRegionByCircle(const CCaculateResult& result1,const CCaculateResult& result2)
|
|
{
|
|
AcGePoint3d ptStart,ptEnd;
|
|
ptStart = result1.m_ptInsert;
|
|
ptEnd = result2.m_ptInsert;
|
|
|
|
double dProRadius1 = result1.m_dProRadius;
|
|
double dProRadius2 = result2.m_dProRadius;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dProRadius1 *= 1000;
|
|
dProRadius2 *= 1000;
|
|
}
|
|
|
|
AcDbCircle circle1(ptStart,AcGeVector3d::kZAxis,dProRadius1);
|
|
AcDbCircle circle2(ptEnd,AcGeVector3d::kZAxis,dProRadius2);
|
|
|
|
AcGePoint3dArray arPt;
|
|
IntersectWith2Circle(&circle1, &circle2, arPt);
|
|
if (arPt.length() != 2)
|
|
return NULL;
|
|
|
|
//构造3维体
|
|
AcDbLine line1(arPt[0],result1.m_ptInsert);
|
|
AcDbLine line2(result1.m_ptInsert,arPt[1]);
|
|
AcDbLine line3(arPt[1],result2.m_ptInsert);
|
|
AcDbLine line4(result2.m_ptInsert,arPt[0]);
|
|
|
|
AcDbVoidPtrArray arRegs;
|
|
arRegs.append(&line1);
|
|
arRegs.append(&line2);
|
|
arRegs.append(&line3);
|
|
arRegs.append(&line4);
|
|
|
|
AcDbVoidPtrArray arRegions;
|
|
AcDbRegion::createFromCurves(arRegs, arRegions);
|
|
if (arRegions.length() != 1)
|
|
{
|
|
ReleasePtrArray(arRegions);
|
|
return NULL;
|
|
}
|
|
|
|
AcDbRegion *pRegion= AcDbRegion::cast((AcRxObject*)arRegions[0]);
|
|
|
|
return pRegion;
|
|
}
|
|
|
|
void TGDrawThunder::Get3PeripheryPoints(const AcGePoint3d& ptInsert1,const AcGePoint3d& ptInsert2,const AcGePoint3d& ptInsert3,double dProRadius1,double dProRadius2,double dProRadius3,AcArray<AcGePoint3d>& arPtInter)
|
|
{
|
|
AcGePoint3d ptSphere1,ptSphere2,ptSphere3;
|
|
AcDbCircle circle1(ptInsert1,AcGeVector3d::kZAxis,dProRadius1);
|
|
AcDbCircle circle2(ptInsert2,AcGeVector3d::kZAxis,dProRadius2);
|
|
AcGePoint3dArray arPt1;
|
|
IntersectWith2Circle(&circle1, &circle2, arPt1);
|
|
if (arPt1.length() != 2)
|
|
return;
|
|
if (arPt1[0].distanceTo(ptInsert3) > arPt1[1].distanceTo(ptInsert3))
|
|
ptSphere1 = arPt1[0];
|
|
else
|
|
ptSphere1 = arPt1[1];
|
|
|
|
AcDbCircle circle3(ptInsert2,AcGeVector3d::kZAxis,dProRadius2);
|
|
AcDbCircle circle4(ptInsert3,AcGeVector3d::kZAxis,dProRadius3);
|
|
AcGePoint3dArray arPt2;
|
|
IntersectWith2Circle(&circle3, &circle4, arPt2);
|
|
if (arPt2.length() != 2)
|
|
return;
|
|
if (arPt2[0].distanceTo(ptInsert1) > arPt2[1].distanceTo(ptInsert1))
|
|
ptSphere2 = arPt2[0];
|
|
else
|
|
ptSphere2 = arPt2[1];
|
|
|
|
AcDbCircle circle5(ptInsert3,AcGeVector3d::kZAxis,dProRadius3);
|
|
AcDbCircle circle6(ptInsert1,AcGeVector3d::kZAxis,dProRadius1);
|
|
AcGePoint3dArray arPt3;
|
|
IntersectWith2Circle(&circle5, &circle6, arPt3);
|
|
if (arPt3.length() != 2)
|
|
return;
|
|
|
|
if (arPt3[0].distanceTo(ptInsert2) > arPt3[1].distanceTo(ptInsert2))
|
|
ptSphere3 = arPt3[0];
|
|
else
|
|
ptSphere3 = arPt3[1];
|
|
|
|
arPtInter.append(ptSphere1);
|
|
arPtInter.append(ptSphere2);
|
|
arPtInter.append(ptSphere3);
|
|
}
|
|
|
|
void TGDrawThunder::GetSphereSolids(const AcArray<AcGePoint3d>& arPt,const AcGeDoubleArray& arRadius,double dGroundRadius,AcArray<AcDb3dSolid*>& arSolid,AcArray<AcGePoint3d>& arPtSec)
|
|
{
|
|
if (arPt.length() != arRadius.length())
|
|
return;
|
|
BOOL bHasResult = TRUE;
|
|
for (int i = 0; i < arPt.length(); ++i)
|
|
{
|
|
for (int j = i + 1; j < arPt.length(); ++j)
|
|
{
|
|
AcDbCircle circle1(arPt[i],AcGeVector3d::kZAxis,arRadius[i]);
|
|
AcDbCircle circle2(arPt[j],AcGeVector3d::kZAxis,arRadius[j]);
|
|
|
|
AcGePoint3dArray arPtInter;
|
|
IntersectWith2Circle(&circle1, &circle2, arPtInter);
|
|
if (arPtInter.length() != 2)
|
|
continue;
|
|
|
|
for (int k = 0; k < arPt.length(); ++k)
|
|
{
|
|
if (k == i || k == j)
|
|
continue;
|
|
if (arPtInter[0].distanceTo(arPt[k]) < arRadius[k])
|
|
bHasResult = FALSE;
|
|
}
|
|
if (bHasResult)
|
|
arPtSec.append(arPtInter[0]);
|
|
bHasResult = TRUE;
|
|
for (int l = 0; l < arPt.length(); ++l)
|
|
{
|
|
if (l == i || l == j)
|
|
continue;
|
|
if (arPtInter[1].distanceTo(arPt[l]) < arRadius[l])
|
|
bHasResult = FALSE;
|
|
}
|
|
if (bHasResult)
|
|
arPtSec.append(arPtInter[1]);
|
|
bHasResult = TRUE;
|
|
}
|
|
}
|
|
|
|
AcGePoint3d ptResult;
|
|
for (int m = 0; m < arPtSec.length(); ++m)
|
|
{
|
|
ptResult = arPtSec[m];
|
|
ptResult.z += dGroundRadius;
|
|
|
|
AcDb3dSolid *pSolid = new AcDb3dSolid;
|
|
pSolid->createSphere(dGroundRadius);
|
|
AcGeMatrix3d matrix;
|
|
matrix.setCoordSystem(ptResult,AcGeVector3d::kXAxis,AcGeVector3d::kYAxis,AcGeVector3d::kZAxis);
|
|
pSolid->transformBy(matrix);
|
|
|
|
arSolid.append(pSolid);
|
|
}
|
|
}
|
|
|
|
//生成顶部球体和中间区域
|
|
void TGDrawThunder::GetTopSphereSolid(lstCltResult& arResult, AcDbVoidPtrArray& arTopPtr)
|
|
{
|
|
AcGePoint3dArray arPt;
|
|
if (arResult.size() <= 0)
|
|
return;
|
|
|
|
double dGroundRadius = arResult.front().m_dGroundRadius;
|
|
double dProRadius = 0.0;
|
|
double dScale = 1.0;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dGroundRadius *= 1000;
|
|
dProRadius *= 1000;
|
|
dScale *= 1000;
|
|
}
|
|
|
|
lstCltResult::iterator it,itSub,itThird;
|
|
for (it = arResult.begin();it != arResult.end();++it)
|
|
{
|
|
itSub = it;
|
|
itSub++;
|
|
for (itSub;itSub != arResult.end(); ++itSub)
|
|
{
|
|
itThird = itSub;
|
|
itThird++;
|
|
for (itThird;itThird != arResult.end();++itThird)
|
|
{
|
|
double dHeight1 = it->m_dHeight;
|
|
double dHeight2 = itSub->m_dHeight;
|
|
double dHeight3 = itThird->m_dHeight;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dHeight1 *= 1000;
|
|
dHeight2 *= 1000;
|
|
dHeight3 *= 1000;
|
|
}
|
|
|
|
AcGePoint3d ptTop1 = it->m_ptInsert;
|
|
AcGePoint3d ptTop2 = itSub->m_ptInsert;
|
|
AcGePoint3d ptTop3 = itThird->m_ptInsert;
|
|
ptTop1.z += dHeight1;
|
|
ptTop2.z += dHeight2;
|
|
ptTop3.z += dHeight3;
|
|
AcGeVector3d vecParal = ptTop1 - it->m_ptInsert;
|
|
|
|
AcGePoint3d ptCen;
|
|
double dDis = 0.0;
|
|
|
|
dProRadius = it->m_dProRadius*dScale;
|
|
if (Get3PinSphereCen(ptTop1,ptTop2,ptTop3,dGroundRadius,vecParal,ptCen,dProRadius))
|
|
{
|
|
BOOL bNeedSphere = TRUE;
|
|
AcGePoint3d ptTemp;
|
|
lstCltResult::iterator itL;
|
|
for (itL = arResult.begin();itL != arResult.end();++itL)
|
|
{
|
|
if (itL == it || itL == itThird || itL == itSub)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ptTemp = itL->m_ptInsert;
|
|
if (!DocGetMeterUnitDraw())
|
|
ptTemp.z += 1000*itL->m_dHeight;
|
|
else
|
|
ptTemp.z += itL->m_dHeight;
|
|
|
|
double dDisdis = ptCen.distanceTo(ptTemp);
|
|
if (dGroundRadius - dDisdis > 0.00001)
|
|
{
|
|
bNeedSphere = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bNeedSphere)
|
|
arPt.append(ptCen);
|
|
else
|
|
bNeedSphere = TRUE;
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int m = 0; m < arPt.length(); ++m)
|
|
{
|
|
AcDb3dSolid *pSolid = new AcDb3dSolid;
|
|
pSolid->createSphere(dGroundRadius);
|
|
AcGeMatrix3d matrix;
|
|
matrix.setCoordSystem(arPt[m],AcGeVector3d::kXAxis,AcGeVector3d::kYAxis,AcGeVector3d::kZAxis);
|
|
pSolid->transformBy(matrix);
|
|
|
|
arTopPtr.append(pSolid);
|
|
}
|
|
}
|
|
|
|
//得到中间区域
|
|
void TGDrawThunder::Get3DIntersectionArea(lstCltResult& arResult,const AcArray<AcGePoint3d>& arPtInter,AcArray<AcDb3dSolid*>& arSolid)
|
|
{
|
|
if (arResult.size() <= 0)
|
|
return;
|
|
AcDbVoidPtrArray arRegs;
|
|
double dRadius = 0.0;
|
|
AcGePoint3d ptT,ptInterT;
|
|
lstCltResult::iterator it;
|
|
for (int i = 0; i < arPtInter.length(); ++i)
|
|
{
|
|
for (it = arResult.begin();it != arResult.end();++it)
|
|
{
|
|
if (!DocGetMeterUnitDraw())
|
|
dRadius = it->m_dProRadius*1000;
|
|
else
|
|
dRadius = it->m_dProRadius;
|
|
|
|
if (it->m_ptInsert.distanceTo(arPtInter[i]) - dRadius < 0.01)
|
|
{
|
|
AcDbLine *pLine = new AcDbLine(it->m_ptInsert,arPtInter[i]);
|
|
arRegs.append(pLine);
|
|
}
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus es;
|
|
AcDbVoidPtrArray arRegions;
|
|
es = AcDbRegion::createFromCurves(arRegs, arRegions);
|
|
ReleasePtrArray(arRegs);
|
|
|
|
if (arRegions.length() < 1)
|
|
return;
|
|
|
|
double dGroundRadius = arResult.front().m_dGroundRadius;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dGroundRadius *= 1000;
|
|
}
|
|
|
|
double dArea = 0.0;
|
|
for (int l = 0; l < arRegions.length(); ++l)
|
|
{
|
|
AcDbRegion *pRegTemp = AcDbRegion::cast((AcRxObject*)arRegions[l]);
|
|
AcDb3dSolid *pSolid = new AcDb3dSolid;
|
|
es = pSolid->extrude(pRegTemp,dGroundRadius,0);
|
|
arSolid.append(pSolid);
|
|
}
|
|
|
|
ReleasePtrArray(arRegions);
|
|
}
|
|
|
|
void TGDrawThunder::DeleteAllEntities(LPCTSTR pszGroupNo)
|
|
{
|
|
ThunderContainer->EreaseSpecGNoCircl(pszGroupNo);
|
|
ThunderContainer->EreaseSpecGNoRegion(pszGroupNo);
|
|
ThunderContainer->EreaseSpecGNo3dSolid(pszGroupNo);
|
|
|
|
m_arRegSolid.setLogicalLength(0);
|
|
}
|
|
|
|
// 更改图层
|
|
void TGDrawThunder::Set2dLayer(const CString& strLayer2d)
|
|
{
|
|
m_strLayer2d = strLayer2d;
|
|
}
|
|
|
|
void TGDrawThunder::Set3dLayer(const CString& strLayer3d)
|
|
{
|
|
m_strLayer3d = strLayer3d;
|
|
}
|
|
|
|
int TGDrawThunder::GetNowCaculateResult(lstCltResult& lstData)
|
|
{
|
|
lstData.clear();
|
|
TContainerSingleton::LstGroupIDMap mapData;
|
|
TContainerSingleton::LstGroupIDMap::iterator it;
|
|
|
|
ThunderContainer->GetThunderMap(mapData);
|
|
|
|
CStringArray arsXData;
|
|
CThunderXData thundXData;
|
|
TGLightningRodData ltnData;
|
|
TGThunderCaculate caculate;
|
|
AcGePoint3d ptInsert;
|
|
TContainerSingleton::LstIDData lstID;
|
|
TContainerSingleton::LstIDData::iterator itLst;
|
|
AcGeDoubleArray arProHeight;
|
|
int nMaxProSize = 0;
|
|
|
|
for (it = mapData.begin();it != mapData.end();++it)
|
|
{
|
|
lstID = it->second;
|
|
if (lstID.size() < 1) continue;
|
|
|
|
thundXData.GetProtectHeightFromObjEx(lstID.front(), arProHeight);
|
|
if (arProHeight.length() > nMaxProSize)
|
|
{
|
|
nMaxProSize = arProHeight.length();
|
|
}
|
|
|
|
for (itLst = lstID.begin();itLst != lstID.end();++itLst)
|
|
{
|
|
ptInsert = ThunderContainer->GetThunderInsertPosition(*itLst);
|
|
if (thundXData.GetBaseInformationExData(*itLst, arsXData, TEL_THUNDER_BASEINFOR) )
|
|
{
|
|
ltnData.SetGroundRadius(_tstof(arsXData.GetAt(CThunderXData::eXDataPinRadius)));
|
|
ltnData.SetHeight(_tstof(arsXData.GetAt(CThunderXData::eXDataPinHeight)));
|
|
ltnData.SetNumber(_ttoi(arsXData.GetAt(CThunderXData::eXDataPinNum)));
|
|
ltnData.SetInsertPoint(ptInsert);
|
|
ltnData.SetObjectID(*itLst);
|
|
ltnData.SetGroupNO(_ttoi(it->first));
|
|
ltnData.m_arProtecedHeight.setLogicalLength(0);
|
|
ltnData.m_arProtecedHeight.append(arProHeight);
|
|
caculate.CaculateThunderData(<nData);
|
|
lstData.push_back(caculate.m_result);
|
|
}
|
|
}
|
|
}
|
|
|
|
return nMaxProSize;
|
|
}
|
|
|
|
BOOL TGDrawThunder::CheckHasRepeatNum(AcDbObjectIdArray& arID, AcDbObjectIdArray& arIDRepeated)
|
|
{
|
|
arIDRepeated.setLogicalLength(0);
|
|
if (arID.length() < 1)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
std::list<int> lstNum;
|
|
std::list<int>::iterator it;
|
|
|
|
CString sNum;
|
|
CThunderXData xd;
|
|
AcDbObjectIdArray arLoc;
|
|
for (int i = 0;i < arID.length();++i)
|
|
{
|
|
if (arID[i].isValid())
|
|
{
|
|
xd.GetXData(arID[i], TEL_ORDER_NUMBER, sNum);
|
|
if ((it = std::find(lstNum.begin(),lstNum.end(),_ttoi(sNum))) != lstNum.end())
|
|
{
|
|
arIDRepeated.append(arID[i]);
|
|
}
|
|
else
|
|
{
|
|
lstNum.push_back(_ttoi(sNum));
|
|
arLoc.append(arID[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
arID.setLogicalLength(0);
|
|
arID.append(arLoc);
|
|
|
|
return arIDRepeated.length() > 0;
|
|
}
|
|
|
|
void TGDrawThunder::DrawThunderCircle(const AcGeDoubleArray& arProHeight, LPCTSTR pszGroupNo, const AcDbObjectIdArray& arID)
|
|
{
|
|
if (pszGroupNo == NULL || arID.length() < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 绘制圆
|
|
CThunderXData thunderXData;
|
|
AcDbObjectId idCir;
|
|
AcDbObjectIdArray arThun,arCir;
|
|
CStringArray arXData;
|
|
CString sTemp;
|
|
AcGePoint3d ptInsert;
|
|
|
|
for (int i = 0;i < arID.length();++i)
|
|
{
|
|
ptInsert = ThunderContainer->GetThunderInsertPosition(arID[i]);
|
|
thunderXData.SetProtectHeightToObjEx(arID[i], arProHeight);
|
|
thunderXData.GetBaseInformationExData(arID[i], arXData, TEL_THUNDER_BASEINFOR);
|
|
for (int j = 0;j < arProHeight.length();++j)
|
|
{
|
|
idCir = DrawCircleRingThunder(arXData, ptInsert, arProHeight[j]);
|
|
if (idCir.isValid())
|
|
{
|
|
sTemp.Format(_T("%g"),arProHeight[j]);
|
|
thunderXData.SetXData(idCir,TEL_CURRENT_PROHEIGHT,sTemp);
|
|
thunderXData.SetXData(idCir, TEL_GROUP_NO, pszGroupNo);
|
|
thunderXData.SetProtectHeightToObjEx(idCir, arProHeight);
|
|
arCir.append(idCir);
|
|
}
|
|
}
|
|
|
|
// 将避雷针id存入多个圆的扩展数据
|
|
arThun.append(arID[i]);
|
|
for (int k = 0;k < arCir.length();++k)
|
|
{
|
|
thunderXData.SetEntityIdToExData(arThun, arCir[k], TEL_THUNDER_ID);
|
|
}
|
|
|
|
// 将多个圆存入避雷针的扩展数据
|
|
thunderXData.SetEntityIdToExData(arCir, arID[i], TEL_THUNDER_ID);
|
|
|
|
ThunderContainer->AppendCircle(pszGroupNo, arCir);
|
|
|
|
arCir.setLogicalLength(0);
|
|
arThun.setLogicalLength(0);
|
|
}
|
|
}
|
|
|
|
// 在避雷针的周围画圆
|
|
AcDbObjectId TGDrawThunder::DrawCircleRingThunder(const CStringArray& arXData, AcGePoint3d& ptInsert, double dProHt)
|
|
{
|
|
AcDbObjectId idCir = AcDbObjectId::kNull;
|
|
|
|
if (arXData.GetSize() < 3)
|
|
{
|
|
return idCir;
|
|
}
|
|
|
|
AcDbCircle* pCircle = NULL;
|
|
double dRadius = 0.0;
|
|
double dScale = 1.0;
|
|
if (!DocGetMeterUnitDraw())
|
|
dScale = 1000.0;
|
|
else
|
|
dScale = 1.0;
|
|
|
|
dRadius = pow((_tstof(arXData.GetAt(CThunderXData::eXDataPinHeight))) *
|
|
(2 * (_tstof(arXData.GetAt(CThunderXData::eXDataPinRadius))) -
|
|
(_tstof(arXData.GetAt(CThunderXData::eXDataPinHeight)))), 0.5) -
|
|
pow((dProHt) *
|
|
(2 * (_tstof(arXData.GetAt(CThunderXData::eXDataPinRadius))) - dProHt), 0.5);
|
|
|
|
double dValue = 0.0;
|
|
dValue = dProHt * dScale;
|
|
ptInsert[Z] = dValue;
|
|
pCircle = new AcDbCircle(ptInsert, AcGeVector3d::kZAxis, dRadius * dScale);
|
|
if (pCircle == NULL)
|
|
{
|
|
return idCir;
|
|
}
|
|
|
|
pCircle->setLayer(LAY_EL_THUNDER_2D);
|
|
pCircle->setColorIndex(m_nSinglePinColorIndex);
|
|
idCir = AddToCurrentSpace(pCircle, Adesk::kTrue);
|
|
|
|
return idCir;
|
|
}
|
|
|
|
BOOL TGDrawThunder::CalcThunderData(LPCTSTR pszGNo, const AcGeDoubleArray& arProHeight, const AcDbObjectIdArray& arID, lstCltResult& lstData)
|
|
{
|
|
lstData.clear();
|
|
if (pszGNo != NULL && arID.length() > 0)
|
|
{
|
|
AcDbObjectIdArray arLoc(arID);
|
|
// 检查是否存在避雷针编号重复
|
|
AcDbObjectIdArray arRepeate;
|
|
if (CheckHasRepeatNum(arLoc,arRepeate))
|
|
{
|
|
acutPrintf(_T("\n 存在重复的避雷针编号,请修改编号。"));
|
|
}
|
|
|
|
CStringArray arsXData;
|
|
CThunderXData thundXData;
|
|
TGLightningRodData ltnData;
|
|
TGThunderCaculate caculate;
|
|
AcGePoint3d ptInsert;
|
|
|
|
for (int i = 0;i < arLoc.length();++i)
|
|
{
|
|
ptInsert = ThunderContainer->GetThunderInsertPosition(arLoc[i]);
|
|
if (thundXData.GetBaseInformationExData(arLoc[i], arsXData, TEL_THUNDER_BASEINFOR) )
|
|
{
|
|
ltnData.SetGroundRadius(_tstof(arsXData.GetAt(CThunderXData::eXDataPinRadius)));
|
|
ltnData.SetHeight(_tstof(arsXData.GetAt(CThunderXData::eXDataPinHeight)));
|
|
ltnData.SetNumber(_ttoi(arsXData.GetAt(CThunderXData::eXDataPinNum)));
|
|
ltnData.SetInsertPoint(ptInsert);
|
|
ltnData.SetObjectID(arLoc[i]);
|
|
ltnData.SetGroupNO(_ttoi(pszGNo));
|
|
ltnData.m_arProtecedHeight.setLogicalLength(0);
|
|
ltnData.m_arProtecedHeight.append(arProHeight);
|
|
caculate.CaculateThunderData(<nData);
|
|
lstData.push_back(caculate.m_result);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (lstData.size() > 0);
|
|
}
|
|
|
|
void TGDrawThunder::PickupSymbolBySpecGroupNO(PickSet& ssSymbol, LPCTSTR pszGroupNo)
|
|
{
|
|
if (pszGroupNo != NULL && _ttoi(pszGroupNo) > 0)
|
|
{
|
|
PickSet ssTmp(SS_FREE);
|
|
|
|
CThunderXData thundXData;
|
|
CString sGroupNo;
|
|
for (long i = 0;i < ssSymbol.Length();++i)
|
|
{
|
|
OPENOBJ_BEGIN(ssSymbol[i],AcDb::kForRead,AcDbEntity,pEnt);
|
|
if (pEnt != NULL)
|
|
{
|
|
thundXData.GetXData(pEnt, TEL_GROUP_NO, sGroupNo);
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
if (sGroupNo.CompareNoCase(pszGroupNo) == 0)
|
|
{
|
|
ssTmp += ssSymbol[i];
|
|
sGroupNo.Empty();
|
|
}
|
|
}
|
|
|
|
ssSymbol.Free();
|
|
ssSymbol += ssTmp;
|
|
}
|
|
}
|
|
|
|
AcDbObjectId TGDrawThunder::CopyEnt(AcDbEntity* pEnt)
|
|
{
|
|
AcDbObjectId id;
|
|
if (pEnt)
|
|
{
|
|
AcDbEntity* pNew = CopyEntPtr(pEnt);
|
|
if (pNew)
|
|
{
|
|
id = AddToCurrentSpace(pNew,Adesk::kTrue);
|
|
}
|
|
}
|
|
return id;
|
|
}
|
|
|
|
AcDbEntity* TGDrawThunder::CopyEntPtr(AcDbEntity* pEnt)
|
|
{
|
|
AcDbEntity* pLoc = NULL;
|
|
if (pEnt)
|
|
{
|
|
AcDb3dSolid* pp = AcDb3dSolid::cast(pEnt);
|
|
if (pp)
|
|
{
|
|
pLoc = new AcDb3dSolid;
|
|
pLoc->copyFrom(pEnt);
|
|
}
|
|
|
|
AcDbLine* p2 = AcDbLine::cast(pEnt);
|
|
if (p2)
|
|
{
|
|
pLoc = new AcDbLine;
|
|
pLoc->copyFrom(pEnt);
|
|
}
|
|
|
|
AcDbArc* p3 = AcDbArc::cast(pEnt);
|
|
if (p3)
|
|
{
|
|
pLoc = new AcDbArc;
|
|
pLoc->copyFrom(pEnt);
|
|
}
|
|
AcDbRegion* pReg = AcDbRegion::cast(pEnt);
|
|
if (pReg)
|
|
{
|
|
pLoc = new AcDbRegion;
|
|
pLoc->copyFrom(pEnt);
|
|
}
|
|
}
|
|
return pLoc;
|
|
}
|
|
|
|
void TGDrawThunder::EreaseObj(const AcDbObjectId& id)
|
|
{
|
|
if (id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id,AcDb::kForWrite,AcDbEntity,pEnt);
|
|
if (pEnt != NULL)
|
|
{
|
|
pEnt->erase();
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
|
|
BOOL TGDrawThunder::IntersectWith2Circle(AcDbCircle* pCir1, AcDbCircle* pCir2, AcGePoint3dArray& arPt)
|
|
{
|
|
if (pCir1 != NULL && pCir2 != NULL)
|
|
{
|
|
pCir1->intersectWith(pCir2, AcDb::kOnBothOperands, arPt);
|
|
if (arPt.length() < 1)
|
|
{
|
|
double dRadius1 = pCir1->radius();
|
|
double dRadius2 = pCir2->radius();
|
|
double dDist = pCir1->center().distanceTo(pCir2->center());
|
|
|
|
if (fabs(dDist - (dRadius1+dRadius2)) < 1e-3) // 相切
|
|
{
|
|
AcDbLine ln(pCir1->center(), pCir2->center());
|
|
ln.intersectWith(pCir1, AcDb::kOnBothOperands, arPt);
|
|
}
|
|
else if (dDist < (dRadius1+dRadius2)) // 相交
|
|
{
|
|
AcDbVoidPtrArray arPtr,arReg1,arReg2;
|
|
AcDbCircle* pC1 = new AcDbCircle(pCir1->center(), pCir1->normal(), pCir1->radius());
|
|
arPtr.append(pC1);
|
|
AcDbRegion::createFromCurves(arPtr, arReg1);
|
|
ReleasePtrArray(arPtr);
|
|
|
|
AcDbCircle* pC2 = new AcDbCircle(pCir2->center(), pCir2->normal(), pCir2->radius());
|
|
arPtr.append(pC2);
|
|
AcDbRegion::createFromCurves(arPtr, arReg2);
|
|
ReleasePtrArray(arPtr);
|
|
|
|
if (arReg1.length() > 0 && arReg2.length() > 0)
|
|
{
|
|
AcDbRegion* pReg1 = (AcDbRegion*)arReg1.first();
|
|
AcDbRegion* pReg2 = (AcDbRegion*)arReg2.first();
|
|
if (pReg1 != NULL && pReg2 != NULL)
|
|
{
|
|
pReg1->booleanOper(AcDb::kBoolIntersect, pReg2);
|
|
|
|
AcGePoint3d ptT;
|
|
AcDbVoidPtrArray arExplode;
|
|
pReg1->explode(arExplode);
|
|
AcDbArc* pArc = NULL;
|
|
for (int i = 0;i < arExplode.length();++i)
|
|
{
|
|
pArc = (AcDbArc*)arExplode[i];
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->getStartPoint(ptT);
|
|
arPt.append(ptT);
|
|
pArc->getEndPoint(ptT);
|
|
arPt.append(ptT);
|
|
break;
|
|
}
|
|
}
|
|
ReleasePtrArray(arExplode);
|
|
}
|
|
}
|
|
|
|
ReleasePtrArray(arReg1);
|
|
ReleasePtrArray(arReg2);
|
|
}
|
|
}
|
|
}
|
|
|
|
return arPt.length() > 0;
|
|
}
|
|
|
|
AcDb3dSolid* TGDrawThunder::CreateRepair3DSolid(AcDb3dSolid* pInt1,const CCaculateResult& pInt1Data1,const CCaculateResult& pInt1Data2,
|
|
AcDb3dSolid* pInt2,const CCaculateResult& pInt2Data1,const CCaculateResult& pInt2Data2)
|
|
{
|
|
AcDb3dSolid* pRetSolid = NULL;
|
|
if (pInt1 == NULL || pInt2 == NULL)
|
|
{
|
|
return pRetSolid;
|
|
}
|
|
|
|
// 截取面reg
|
|
AcGeVector3d vt = pInt1Data1.m_ptInsert - pInt1Data2.m_ptInsert;
|
|
AcGePlane plan;
|
|
plan.set(pInt1Data1.m_ptInsert,vt,AcGeVector3d::kZAxis);
|
|
AcDbRegion* pReg = NULL;
|
|
pInt1->getSection(plan, pReg);
|
|
if (pReg == NULL) return pRetSolid;
|
|
|
|
vt = pInt2Data1.m_ptInsert - pInt2Data2.m_ptInsert;
|
|
plan.set(pInt2Data1.m_ptInsert,vt,AcGeVector3d::kZAxis);
|
|
AcDbRegion* pReg2 = NULL;
|
|
pInt2->getSection(plan, pReg2);
|
|
if (pReg2 == NULL)
|
|
{
|
|
delete pReg;
|
|
return pRetSolid;
|
|
}
|
|
|
|
// 计算延伸路径
|
|
AcDbLine path;
|
|
CalcStretchPaht(pReg,pInt1Data1,pInt1Data2,pReg2,pInt2Data1,pInt2Data2,&path);
|
|
|
|
// 取需要延伸实体的reg
|
|
double dDist1 = pInt1Data1.m_ptInsert.distanceTo(pInt1Data2.m_ptInsert);
|
|
double dDist2 = pInt2Data1.m_ptInsert.distanceTo(pInt2Data2.m_ptInsert);
|
|
|
|
if (dDist1 > dDist2)
|
|
{
|
|
pRetSolid = ExtrudeSolidAlongPath(pReg2, &path);
|
|
}
|
|
else
|
|
{
|
|
pRetSolid = ExtrudeSolidAlongPath(pReg, &path);
|
|
}
|
|
|
|
delete pReg;
|
|
delete pReg2;
|
|
|
|
return pRetSolid;
|
|
}
|
|
|
|
BOOL TGDrawThunder::CalcStretchPaht(AcDbEntity* pEnt1,const CCaculateResult& pInt1Data1,const CCaculateResult& pInt1Data2,
|
|
AcDbEntity* pEnt2,const CCaculateResult& pInt2Data1,const CCaculateResult& pInt2Data2,
|
|
AcDbLine* pPath)
|
|
{
|
|
if (pEnt1 != NULL &&
|
|
pEnt2 != NULL &&
|
|
pPath != NULL )
|
|
{
|
|
std::list<LINEPTPAIR> lstPtPair;
|
|
LINEPTPAIR ptPair;
|
|
AcGePoint3d ptS,ptE;
|
|
|
|
int nScale = 1;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
nScale *= 1000;
|
|
}
|
|
|
|
ptPair.pt1 = pInt1Data1.m_ptInsert;
|
|
ptPair.pt1.z += pInt1Data1.m_dHeight * nScale;
|
|
ptPair.pt2 = pInt1Data2.m_ptInsert;
|
|
ptPair.pt2.z += pInt1Data2.m_dHeight * nScale;
|
|
lstPtPair.push_back(ptPair);
|
|
|
|
ptPair.pt1 = pInt2Data1.m_ptInsert;
|
|
ptPair.pt1.z += pInt2Data1.m_dHeight * nScale;
|
|
ptPair.pt2 = pInt2Data2.m_ptInsert;
|
|
ptPair.pt2.z += pInt2Data2.m_dHeight * nScale;
|
|
lstPtPair.push_back(ptPair);
|
|
|
|
if (GetSolidCopingLowPoint(pEnt1, lstPtPair, ptS) &&
|
|
GetSolidCopingLowPoint(pEnt2, lstPtPair, ptE) )
|
|
{
|
|
pPath->setStartPoint(ptS);
|
|
pPath->setEndPoint(ptE);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|