1066 lines
23 KiB
C++
1066 lines
23 KiB
C++
#include "stdafx.h"
|
|
|
|
|
|
const Adesk::UInt8 TDbNetshelf::g_nVersion = 1;
|
|
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSNetshelf, ATSEntity, AcDb::kDHL_CURRENT,
|
|
AcDb::kMReleaseCurrent, 1, ATS_NETSHELF, "ATS_NETSHELF图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
IMPLEMENT_TENTBASE(TDbNetshelf);
|
|
|
|
static void RemoveAll(DList<XPoint>& lstPoint,const XPoint& ptDest)
|
|
{
|
|
for (int i=0; i<lstPoint.Length(); i++) {
|
|
if (ptDest == *lstPoint[i]) {
|
|
lstPoint.Remove();
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TDbNetshelf::TDbNetshelf():
|
|
m_dRadiusSphere(_AS_SYS_UNIT(50)),
|
|
m_dRadiusPole(_AS_SYS_UNIT(25)),
|
|
m_bMonoAdded(TRUE)
|
|
{
|
|
//默认图层：当前层
|
|
XString sCurLayer;
|
|
xg_getvar(_T("CLAYER"), (TCHAR*)sCurLayer);
|
|
m_idLayerSphere=
|
|
GetLayerIdFromString((const TCHAR*)sCurLayer);
|
|
}
|
|
|
|
TDbNetshelf::~TDbNetshelf()
|
|
{
|
|
}
|
|
|
|
BOOL TDbNetshelf::IsValid() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if(!TDbEntity::IsValid())
|
|
return FALSE;
|
|
|
|
BOOL bRet=m_dRadiusSphere>1.0E-3 &&
|
|
m_dRadiusPole>1.0E-3 &&
|
|
m_lstPole.Length()>0;
|
|
return bRet;
|
|
}
|
|
|
|
void TDbNetshelf::SetLayerSphere(AcDbObjectId idLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idLayerSphere = idLayer;
|
|
}
|
|
|
|
|
|
void TDbNetshelf::SetLayerSphere(CString sLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
if (sLayer.IsEmpty()) {
|
|
XString sCurLayer;
|
|
xg_getvar(_T("CLAYER"), (TCHAR*)sCurLayer);
|
|
m_idLayerSphere=GetLayerIdFromString((const TCHAR*)sCurLayer);
|
|
}
|
|
else {
|
|
m_idLayerSphere=InitLayer(sLayer,FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
void TDbNetshelf::SetRadiusSphere(double dRadius)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dRadiusSphere = dRadius;
|
|
}
|
|
|
|
void TDbNetshelf::SetRadiusPole(double dRadius)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dRadiusPole = dRadius;
|
|
}
|
|
|
|
|
|
void TDbNetshelf::SetMonoAdded(BOOL bFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
m_bMonoAdded = bFlag;
|
|
}
|
|
|
|
|
|
BOOL TDbNetshelf::IsMonoAdded() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_bMonoAdded;
|
|
}
|
|
|
|
double TDbNetshelf::GetRadiusSphere() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_dRadiusSphere;
|
|
}
|
|
|
|
double TDbNetshelf::GetRadiusPole() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_dRadiusPole;
|
|
}
|
|
|
|
AcDbObjectId TDbNetshelf::GetLayerSphere() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_idLayerSphere;
|
|
}
|
|
|
|
|
|
CString TDbNetshelf::GetSphereLayer() const
|
|
{
|
|
assertReadEnabled();
|
|
CString sLayer=GetSymbolName(m_idLayerSphere).cs();
|
|
return sLayer;
|
|
}
|
|
|
|
void TDbNetshelf::SetLayer(CString sLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
if (sLayer.IsEmpty()) {
|
|
XString sCurLayer;
|
|
xg_getvar(_T("CLAYER"), (TCHAR*)sCurLayer);
|
|
AcDbObjectId idLayer=
|
|
GetLayerIdFromString((const TCHAR*)sCurLayer);
|
|
setLayer(idLayer);
|
|
}
|
|
else {
|
|
AcDbObjectId idLayer=InitLayer(sLayer,FALSE);
|
|
setLayer(idLayer);
|
|
}
|
|
}
|
|
|
|
CString TDbNetshelf::GetLayer() const
|
|
{
|
|
assertReadEnabled();
|
|
CString sLayer=GetSymbolName(layerId()).cs();
|
|
return sLayer;
|
|
}
|
|
|
|
|
|
BOOL TDbNetshelf::IsExit(const XLine& line) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int nCount = m_lstPole.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
if (/*line.flag==m_lstPole[i].flag &&*/
|
|
((line.StartPoint()==m_lstPole[i].StartPoint() &&
|
|
line.EndPoint()==m_lstPole[i].EndPoint()) ||
|
|
(line.StartPoint()==m_lstPole[i].EndPoint() &&
|
|
line.EndPoint()==m_lstPole[i].StartPoint())))
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TDbNetshelf::IsMonoNode(const XPoint& ptVertex) const
|
|
{
|
|
assertReadEnabled();
|
|
int nCount = m_lstMono.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
if (ptVertex == m_lstMono[i])
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TDbNetshelf::IsMultiNode(const XPoint& ptVertex) const
|
|
{
|
|
assertReadEnabled();
|
|
int nCount = m_lstMulti.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
if (ptVertex == m_lstMulti[i])
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TDbNetshelf::AddPole(const XLine& line)
|
|
{
|
|
assertWriteEnabled();
|
|
if (line.GetLength()<1.0E-3)
|
|
return FALSE;
|
|
if (IsExit(line))
|
|
return FALSE;
|
|
|
|
m_lstPole.Append(new XLine(line));
|
|
AddNode(line.StartPoint());
|
|
AddNode(line.EndPoint());
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void TDbNetshelf::AddNode(const XPoint& ptNode)
|
|
{
|
|
BOOL bMulti = IsMultiNode(ptNode);
|
|
BOOL bMono = IsMonoNode(ptNode);
|
|
if (!bMono && !bMulti) {
|
|
m_lstMono.NewAppend(ptNode);
|
|
}
|
|
else if (bMono && !bMulti) {
|
|
m_lstMono.Remove();
|
|
m_lstMulti.NewAppend(ptNode);
|
|
}
|
|
else if (bMono && bMulti) {
|
|
m_lstMono.Remove();
|
|
}
|
|
}
|
|
|
|
void TDbNetshelf::DelNode(const XPoint& ptNode)
|
|
{
|
|
//处理单甩节点
|
|
int nCount = m_lstMono.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
XPoint& ptTemp=*m_lstMono[i];
|
|
if (ptTemp == ptNode) {
|
|
m_lstMono.Remove();
|
|
return;
|
|
}
|
|
}
|
|
|
|
//处理公共节点
|
|
int nNum=0;
|
|
nCount = m_lstPole.Length();
|
|
for (i=0; i<nCount; i++) {
|
|
XLine& lineTemp=*m_lstPole[i];
|
|
XPoint& ptTemp1=lineTemp.StartPoint();
|
|
if (ptTemp1 == ptNode) {
|
|
nNum++;
|
|
if (nNum>=2) break;
|
|
}
|
|
else {
|
|
XPoint& ptTemp2=lineTemp.EndPoint();
|
|
if (ptTemp2 == ptNode) {
|
|
nNum++;
|
|
if (nNum>=2) break;
|
|
}
|
|
}
|
|
}
|
|
if (nNum == 1) {
|
|
m_lstMono.NewAppend(ptNode);
|
|
int nCount = m_lstMulti.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
if (*m_lstMulti[i] == ptNode) {
|
|
m_lstMulti.Remove();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL TDbNetshelf::DelPole(const XLine& line)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
BOOL bRet = FALSE;
|
|
int nCount = m_lstPole.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
XLine& lineTemp=*m_lstPole[i];
|
|
if (/*line.flag==m_lstPole[i].flag &&*/
|
|
((line.StartPoint()==lineTemp.StartPoint() &&
|
|
line.EndPoint()==lineTemp.EndPoint()) ||
|
|
(line.StartPoint()==lineTemp.EndPoint() &&
|
|
line.EndPoint()==lineTemp.StartPoint()))) {
|
|
m_lstPole.Remove();
|
|
bRet = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (!bRet) {
|
|
return bRet;
|
|
}
|
|
|
|
//删除节点
|
|
DelNode(line.StartPoint());
|
|
DelNode(line.EndPoint());
|
|
|
|
return bRet;
|
|
}
|
|
|
|
void TDbNetshelf::ProcessNetshelf(const DList<XLine>& lstLine,
|
|
const BOOL bRemoveSame)
|
|
{
|
|
assertWriteEnabled();
|
|
m_lstPole.Reset();
|
|
m_lstMono.Reset();
|
|
m_lstMulti.Reset();
|
|
|
|
//杆
|
|
int nCount = lstLine.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
m_lstPole.Append(new XLine(lstLine[i]));
|
|
}
|
|
|
|
//去出相同的line
|
|
if (bRemoveSame) {
|
|
for (int i=0; i<m_lstPole.Length()-1; i++) {
|
|
XLine& line = *m_lstPole[i];
|
|
for (int j=i+1; j<m_lstPole.Length(); j++) {
|
|
if (/*line.flag==m_lstPole[i]->flag &&*/
|
|
((line.StartPoint()==m_lstPole[j]->StartPoint() &&
|
|
line.EndPoint()==m_lstPole[j]->EndPoint()) ||
|
|
(line.StartPoint()==m_lstPole[j]->EndPoint() &&
|
|
line.EndPoint()==m_lstPole[j]->StartPoint()))) {
|
|
m_lstPole.Remove();
|
|
j--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//节点
|
|
nCount = m_lstPole.Length();
|
|
for (i=0; i<nCount; i++) {
|
|
AddNode(m_lstPole[i]->StartPoint());
|
|
AddNode(m_lstPole[i]->EndPoint());
|
|
}
|
|
}
|
|
|
|
const XPointList& TDbNetshelf::GetMonoNode() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_lstMono;
|
|
}
|
|
|
|
const XPointList& TDbNetshelf::GetMultiNode() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_lstMulti;
|
|
}
|
|
|
|
const DList<XLine>& TDbNetshelf::GetPole() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_lstPole;
|
|
}
|
|
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbNetshelf::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbNetshelf *pSrc=TDbNetshelf::cast(pSrcEntity);
|
|
if(pSrc) {
|
|
if(database()==NULL||
|
|
pSrcEntity->database()==NULL||
|
|
database()==pSrcEntity->database())//add by whl on 060317
|
|
{
|
|
m_idLayerSphere=pSrc->m_idLayerSphere;
|
|
}
|
|
|
|
m_bMonoAdded=pSrc->m_bMonoAdded;
|
|
m_dRadiusSphere=pSrc->m_dRadiusSphere;
|
|
m_dRadiusPole=pSrc->m_dRadiusPole;
|
|
}
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbNetshelf::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus TDbNetshelf::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
|
|
es = TDbEntity::dwgInFields(pFiler);
|
|
if(es != Acad::eOk)
|
|
return es;
|
|
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
if(nVer>g_nVersion) {// Version is too new
|
|
return Acad::eMakeMeProxy;
|
|
}
|
|
|
|
//图层
|
|
pFiler->readItem(&m_idLayerSphere);
|
|
|
|
//网架参数
|
|
pFiler->readItem(&m_dRadiusSphere);
|
|
pFiler->readItem(&m_dRadiusPole);
|
|
pFiler->readItem(&m_bMonoAdded);
|
|
|
|
Adesk::UInt16 nCount=0;
|
|
//杆
|
|
m_lstPole.Reset();
|
|
pFiler->readItem(&nCount);
|
|
for(Adesk::UInt16 i=0; i<nCount; i++) {
|
|
XPoint ptStart;
|
|
pFiler->readItem(&(AcGePoint3d &)ptStart);
|
|
m_lstPole.Append(new XLine(ptStart,XPoint(0,0,0)));
|
|
}
|
|
assert(m_lstPole.Length()==nCount);
|
|
for(i=0; i<nCount; i++) {
|
|
XLine& line=*m_lstPole[i];
|
|
XPoint& ptEnd=line.EndPoint();
|
|
pFiler->readItem(&(AcGePoint3d &)ptEnd);
|
|
}
|
|
|
|
//单甩节点
|
|
m_lstMono.Reset();
|
|
pFiler->readItem(&nCount);
|
|
for(i=0; i<nCount; i++) {
|
|
XPoint* pPtTemp = new XPoint;
|
|
pFiler->readItem((AcGePoint3d *)pPtTemp);
|
|
m_lstMono.Append(pPtTemp);
|
|
}
|
|
|
|
//公用节点
|
|
m_lstMulti.Reset();
|
|
pFiler->readItem(&nCount);
|
|
for(i=0; i<nCount; i++) {
|
|
XPoint* pPtTemp = new XPoint;
|
|
pFiler->readItem((AcGePoint3d *)pPtTemp);
|
|
m_lstMulti.Append(pPtTemp);
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbNetshelf::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
|
|
//del by xlc on 100416
|
|
//R18平台在进行编辑时删除最后一根杆件后返回Acad::eInvalidInput时程序崩溃退出
|
|
//低平台在图形导出时崩溃
|
|
// if (!IsValid())
|
|
// {
|
|
// return Acad::eInvalidInput;
|
|
// }
|
|
|
|
|
|
es = TDbEntity::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
|
|
pFiler->writeItem(g_nVersion);
|
|
|
|
//图层
|
|
pFiler->writeItem(m_idLayerSphere);
|
|
|
|
//网架参数
|
|
pFiler->writeItem(m_dRadiusSphere);
|
|
pFiler->writeItem(m_dRadiusPole);
|
|
pFiler->writeItem(m_bMonoAdded);
|
|
|
|
Adesk::UInt16 nCount=0;
|
|
//杆
|
|
nCount = m_lstPole.Length();
|
|
pFiler->writeItem(nCount);
|
|
for(Adesk::UInt16 i=0; i<nCount; i++) {
|
|
pFiler->writeItem((AcGePoint3d &)m_lstPole[i].StartPoint());
|
|
}
|
|
for(i=0; i<nCount; i++) {
|
|
pFiler->writeItem((AcGePoint3d &)m_lstPole[i].EndPoint());
|
|
}
|
|
|
|
//单甩节点
|
|
nCount = m_lstMono.Length();
|
|
pFiler->writeItem(nCount);
|
|
for(i=0; i<nCount; i++) {
|
|
pFiler->writeItem((AcGePoint3d &)m_lstMono[i]);
|
|
}
|
|
|
|
//公用节点
|
|
nCount = m_lstMulti.Length();
|
|
pFiler->writeItem(nCount);
|
|
for(i=0; i<nCount; i++) {
|
|
pFiler->writeItem((AcGePoint3d &)m_lstMulti[i]);
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbNetshelf::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
|
|
es = TDbEntity::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
|
|
if (!pFiler->atSubclassData(_T("TDbNetshelf"))) {
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
|
|
m_lstPole.Reset();
|
|
m_lstMono.Reset();
|
|
m_lstMulti.Reset();
|
|
|
|
resbuf rb;
|
|
DList<XPoint> lstStart;
|
|
DList<XPoint> lstEnd;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
|
switch (rb.restype) {
|
|
case AcDb::kDxfHardPointerId+0:
|
|
acdbGetObjectId(m_idLayerSphere,rb.resval.rlname);
|
|
break;
|
|
case AcDb::kDxfXReal+0:
|
|
m_dRadiusSphere=rb.resval.rreal;
|
|
break;
|
|
case AcDb::kDxfXReal+1:
|
|
m_dRadiusPole=rb.resval.rreal;
|
|
break;
|
|
case AcDb::kDxfBool+0:
|
|
m_bMonoAdded=rb.resval.rint;
|
|
break;
|
|
case AcDb::kDxfXCoord+0:
|
|
lstStart.Append(new XPoint(rb.resval.rpoint));
|
|
break;
|
|
case AcDb::kDxfXCoord+1:
|
|
lstEnd.Append(new XPoint(rb.resval.rpoint));
|
|
break;
|
|
case AcDb::kDxfXCoord+2:
|
|
m_lstMono.Append(new XPoint(rb.resval.rpoint));
|
|
break;
|
|
case AcDb::kDxfXCoord+3:
|
|
m_lstMulti.Append(new XPoint(rb.resval.rpoint));
|
|
break;
|
|
default:
|
|
pFiler->pushBackItem();
|
|
es = Acad::eEndOfFile;
|
|
break;
|
|
}
|
|
}
|
|
if (es != Acad::eEndOfFile)
|
|
return Acad::eInvalidResBuf;
|
|
|
|
int nCount = lstStart.Length();
|
|
if(nCount<=0 || nCount!=lstEnd.Length()) {
|
|
pFiler->setError(_T("\nError DXF group code: 10, 11"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
for (int i=0; i<nCount; i++) {
|
|
m_lstPole.Append(new XLine(*lstStart[i],*lstEnd[i]));
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbNetshelf::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if (!IsValid())
|
|
return Acad::eInvalidInput;
|
|
|
|
es = TDbEntity::dxfOutFields(pFiler);
|
|
assert(es == Acad::eOk);
|
|
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbNetshelf"));
|
|
assert(es == Acad::eOk);
|
|
|
|
//图层
|
|
pFiler->writeObjectId(AcDb::kDxfHardPointerId+0,m_idLayerSphere);
|
|
|
|
//网架参数
|
|
pFiler->writeDouble(AcDb::kDxfXReal+0,m_dRadiusSphere);
|
|
pFiler->writeDouble(AcDb::kDxfXReal+1,m_dRadiusPole);
|
|
pFiler->writeBoolean(AcDb::kDxfBool+0,m_bMonoAdded);
|
|
|
|
//杆
|
|
int nCount = m_lstPole.Length();
|
|
for(int i=0; i<nCount; i++) {
|
|
pFiler->writePoint3d(AcDb::kDxfXCoord+0,m_lstPole[i].StartPoint());
|
|
}
|
|
for(i=0; i<nCount; i++) {
|
|
pFiler->writePoint3d(AcDb::kDxfXCoord+1,m_lstPole[i].EndPoint());
|
|
}
|
|
|
|
//单甩节点
|
|
nCount = m_lstMono.Length();
|
|
for(i=0; i<nCount; i++) {
|
|
pFiler->writePoint3d(AcDb::kDxfXCoord+2,m_lstMono[i]);
|
|
}
|
|
|
|
//公用节点
|
|
nCount = m_lstMulti.Length();
|
|
for(i=0; i<nCount; i++) {
|
|
pFiler->writePoint3d(AcDb::kDxfXCoord+3,m_lstMulti[i]);
|
|
}
|
|
|
|
assert(es == Acad::eOk);
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbNetshelf::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& ptPick,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if( osnapMode==AcDb::kOsModeCen ||
|
|
osnapMode==AcDb::kOsModeNode
|
|
) {
|
|
int nCount = m_lstMulti.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
snapPoints.append(m_lstMulti[i].AsAcGePoint3d());
|
|
}
|
|
nCount = m_lstMono.Length();
|
|
for (i=0; i<nCount; i++) {
|
|
snapPoints.append(m_lstMono[i].AsAcGePoint3d());
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus es =
|
|
TDbEntity::subGetOsnapPoints(osnapMode, gsSelectionMark,
|
|
ptPick, lastPoint, viewXform, snapPoints, geomIds);
|
|
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbNetshelf::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//单甩节点
|
|
for(int i=0; i<m_lstMono.Length(); i++){
|
|
gripPoints.append(m_lstMono[i]);
|
|
}
|
|
//公用节点
|
|
for(i=0; i<m_lstMulti.Length(); i++){
|
|
gripPoints.append(m_lstMulti[i]);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbNetshelf::GetGripText(int idx, CString &cs) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int nMono = m_lstMono.Length();
|
|
int nMulti = m_lstMulti.Length() + nMono;
|
|
if (idx>=0 && idx<nMono) {
|
|
cs = _T("移动单甩节点");
|
|
}
|
|
else if (idx>=nMono && idx<nMulti) {
|
|
cs = _T("移动公用节点");
|
|
}
|
|
else {
|
|
return Acad::eInvalidIndex;
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbNetshelf::subMoveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
int nMono = m_lstMono.Length();
|
|
int nMulti = m_lstMulti.Length()+nMono;
|
|
|
|
for (int i=0; i<indices.length();i++) {
|
|
int idx = indices[i];
|
|
if(idx>=0 && idx<nMono) {//单甩节点
|
|
XPoint& ptOffset = *m_lstMono[idx];
|
|
MovePoleGripPoints(ptOffset,offset);
|
|
ptOffset += offset;
|
|
RegulateNode(ptOffset);
|
|
}
|
|
else if (idx>=nMono && idx<nMulti) {//公用节点
|
|
XPoint& ptOffset = *m_lstMulti[idx-nMono];
|
|
MovePoleGripPoints(ptOffset,offset);
|
|
ptOffset += offset;
|
|
RegulateNode(ptOffset);
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void TDbNetshelf::RegulateNode(const XPoint& ptDest)
|
|
{
|
|
if (IsMonoNode(ptDest)) {//单甩节点
|
|
if (IsMultiNode(ptDest)) {
|
|
m_lstMono.Remove();
|
|
}
|
|
else {
|
|
int nCount = m_lstMono.Length();
|
|
for (int nPrevious=0,nNum=0,i=0; i<nCount; i++) {
|
|
if (ptDest == *m_lstMono[i]) {
|
|
nNum++;
|
|
if(nNum>1) {
|
|
m_lstMono.Remove();
|
|
|
|
//此处不真正删除点，只是将单节点给双节点链表
|
|
int nOldDelFlag = m_lstMono.GetDelFlag();
|
|
XPoint& ptMove = *m_lstMono[nPrevious];
|
|
m_lstMono.SetDelFlag(0);
|
|
m_lstMono.Remove(nPrevious);
|
|
m_lstMulti.Append(&ptMove);
|
|
m_lstMono.SetDelFlag(nOldDelFlag);
|
|
break;
|
|
}
|
|
nPrevious=i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (IsMultiNode(ptDest)) {//公用节点
|
|
int nCount = m_lstMulti.Length();
|
|
for (int nNum=0,i=0; i<nCount; i++) {
|
|
if (ptDest == *m_lstMulti[i]) {
|
|
nNum++;
|
|
if(nNum>1) {
|
|
m_lstMulti.Remove();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbNetshelf::MovePoleGripPoints(const XPoint& ptDest,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
int nCount = m_lstPole.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
XLine& line = *m_lstPole[i];
|
|
XPoint& ptStart = line.StartPoint();
|
|
if (ptStart == ptDest) {
|
|
ptStart += offset;
|
|
}
|
|
XPoint& ptEnd = line.EndPoint();
|
|
if (ptEnd == ptDest) {
|
|
ptEnd += offset;
|
|
}
|
|
if (line.GetLength()<_DIST_SNAP) {
|
|
m_lstPole.Remove();
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbNetshelf::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = TDbEntity::subTransformBy(xform);
|
|
if (es != Acad::eOk) return es;
|
|
|
|
ads_matrix mat;
|
|
AsAdsMatrix(xform,mat);
|
|
|
|
m_lstMono.TransUCS(mat);
|
|
m_lstMulti.TransUCS(mat);
|
|
int nCount = m_lstPole.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
XLine& line = *m_lstPole[i];
|
|
line.TransformBy(mat);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus TDbNetshelf::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
if (!IsValid())
|
|
return Acad::eNotApplicable;
|
|
|
|
int nCount = m_lstPole.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
XLine ln=m_lstPole[i];
|
|
ln.SetElevation(0.0);
|
|
dc << ln;
|
|
}
|
|
|
|
return es;
|
|
}
|
|
|
|
|
|
// 绘制3d的显示
|
|
Acad::ErrorStatus
|
|
TDbNetshelf::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
if (!IsValid())
|
|
return Acad::eNotApplicable;
|
|
|
|
if(g_bOsnapExpl) {
|
|
int nCount = m_lstPole.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
dc << m_lstPole[i];
|
|
}
|
|
} else {
|
|
DrawPole3D(dc);//杆
|
|
dc.SetColorLayer(colorIndex(), m_idLayerSphere);
|
|
DrawSphere3D(dc);//球
|
|
//dc.RestoreProperties(vProp.m_prop);
|
|
|
|
|
|
}
|
|
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbNetshelf::DrawSphere3D(XExplodeDraw &dc) const
|
|
{
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
|
|
int nDiv = GetSphereDivNum();
|
|
|
|
int nLat = nDiv/2;
|
|
int nLong= nDiv;
|
|
|
|
nLat = int(nLat/2)*2+1;//确保奇数
|
|
nLong = int(nLong/2)*2+2;//确保偶数
|
|
|
|
XPoint *pPtArray=NULL;
|
|
pPtArray = new XPoint[nLat*nLong];
|
|
if (pPtArray == NULL) {
|
|
return Acad::eOutOfMemory;
|
|
}
|
|
|
|
//单甩节点
|
|
if (m_bMonoAdded) {
|
|
int nCount = m_lstMono.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
if (GetSphereMesh(pPtArray,m_lstMono[i],nLat,nLong)) {
|
|
dc.DrawMesh(nLat,nLong,(AcGePoint3d *)pPtArray);
|
|
|
|
XPoly2D polyTemp1(1);
|
|
XPoly2D polyTemp2(1);
|
|
for(int j=0; j<nLong-1; j++) {
|
|
polyTemp1.AppendNode(pPtArray[j]);
|
|
}
|
|
dc.DrawShell(polyTemp1);
|
|
for(j=0; j<nLong-1; j++) {
|
|
int nIndex = (nLat-1)*nLong+j;
|
|
polyTemp2.AppendNode(pPtArray[nIndex]);
|
|
}
|
|
dc.DrawShell(polyTemp2);
|
|
}
|
|
}
|
|
}
|
|
|
|
//公共节点
|
|
int nCount = m_lstMulti.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
if (GetSphereMesh(pPtArray,m_lstMulti[i],nLat,nLong)) {
|
|
dc.DrawMesh(nLat,nLong,(AcGePoint3d *)pPtArray);
|
|
|
|
XPoly2D polyTemp1(1);
|
|
XPoly2D polyTemp2(1);
|
|
for(int j=0; j<nLong-1; j++) {
|
|
polyTemp1.AppendNode(pPtArray[j]);
|
|
}
|
|
dc.DrawShell(polyTemp1);
|
|
for(j=0; j<nLong-1; j++) {
|
|
int nIndex = (nLat-1)*nLong+j;
|
|
polyTemp2.AppendNode(pPtArray[nIndex]);
|
|
}
|
|
dc.DrawShell(polyTemp2);
|
|
}
|
|
}
|
|
|
|
delete []pPtArray;
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbNetshelf::DrawPole3D(XExplodeDraw &dc) const
|
|
{
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
int nDiv = GetPoleDivNum();
|
|
nDiv++;
|
|
|
|
XPoint *pPtArray=NULL;
|
|
pPtArray = new XPoint[2*nDiv];
|
|
if (pPtArray == NULL) {
|
|
return Acad::eOutOfMemory;
|
|
}
|
|
|
|
int nCount = m_lstPole.Length();
|
|
for (int i=0; i<nCount; i++) {
|
|
if (GetPoleMesh(pPtArray,m_lstPole[i],nDiv)) {
|
|
dc.DrawMesh(2,nDiv,(AcGePoint3d *)pPtArray);
|
|
|
|
XPoly2D polyTemp1(1);
|
|
XPoly2D polyTemp2(1);
|
|
for(int j=0; j<nDiv-1; j++) {
|
|
polyTemp1.AppendNode(pPtArray[j]);
|
|
}
|
|
dc.DrawShell(polyTemp1);
|
|
int nUp = nDiv*2-1;
|
|
for(j=nDiv; j<nUp; j++) {
|
|
polyTemp2.AppendNode(pPtArray[j]);
|
|
}
|
|
dc.DrawShell(polyTemp2);
|
|
}
|
|
}
|
|
|
|
delete []pPtArray;
|
|
return es;
|
|
}
|
|
|
|
BOOL TDbNetshelf::GetPoleMesh(XPoint*& pPtArray,
|
|
const XLine& line,const int nCol) const
|
|
{
|
|
if (nCol<4 || m_dRadiusSphere<m_dRadiusPole) {
|
|
return FALSE;
|
|
}
|
|
|
|
double dSub = sqrt(m_dRadiusSphere*m_dRadiusSphere-
|
|
m_dRadiusPole*m_dRadiusPole);
|
|
double dDistance = ads_distance(line.StartPoint(),line.EndPoint());
|
|
if (dDistance<=0 && dDistance<dSub*2) {
|
|
return FALSE;
|
|
}
|
|
|
|
//起点和终点和方向
|
|
XPoint ptStart(line.StartPoint());
|
|
XPoint ptEnd(line.EndPoint());
|
|
AcGeVector3d vtDirection(line.EndPoint().x-line.StartPoint().x,
|
|
line.EndPoint().y-line.StartPoint().y,
|
|
line.EndPoint().z-line.StartPoint().z);
|
|
XVector3D vtSub(vtDirection);
|
|
double dScale=dSub/dDistance;
|
|
vtSub *= dScale;
|
|
if (!(!m_bMonoAdded && IsMonoNode(ptStart))) {
|
|
ptStart += vtSub;
|
|
}
|
|
if (!(!m_bMonoAdded && IsMonoNode(ptEnd))) {
|
|
ptEnd -= vtSub;
|
|
}
|
|
|
|
//旋转参数
|
|
AcGeVector3d vtNormal(0,0,1);
|
|
AcGeVector3d vtRotateAxis = vtNormal.crossProduct(vtDirection);
|
|
double dRotateAngle = vtNormal.angleTo(vtDirection, vtRotateAxis);
|
|
|
|
for (int i=0; i<nCol-1; i++) {
|
|
double dAngle = PI*2*i/(nCol-1);
|
|
AcGePoint3d ptStartTemp(m_dRadiusPole*sin(dAngle),
|
|
m_dRadiusPole*cos(dAngle),0);
|
|
AcGePoint3d ptEndTemp=ptStartTemp;
|
|
ptStartTemp += ptStart;
|
|
ptEndTemp += ptEnd;
|
|
ptStartTemp.rotateBy(dRotateAngle, vtRotateAxis, ptStart);
|
|
ptEndTemp.rotateBy(dRotateAngle, vtRotateAxis, ptEnd);
|
|
|
|
pPtArray[i]=ptStartTemp;
|
|
pPtArray[nCol+i]=ptEndTemp;
|
|
}
|
|
pPtArray[nCol-1] = pPtArray[0];
|
|
pPtArray[2*nCol-1] = pPtArray[nCol];
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TDbNetshelf::GetSphereMesh(XPoint*& pPtArray,
|
|
const XPoint& ptCenter,
|
|
const int nLat,
|
|
const int nLong) const
|
|
{
|
|
if (m_dRadiusSphere<1.0E-3 ||
|
|
nLat<3 || nLong<4)
|
|
return FALSE;
|
|
|
|
for(int i=0,n=-nLat/2; n<=nLat/2; n++, i++) {
|
|
double nLatAng=(double)(PI/nLat*n);
|
|
double z = (double)(m_dRadiusSphere*sin(nLatAng));
|
|
double xy= (double)(m_dRadiusSphere*cos(nLatAng));
|
|
|
|
int nLatNum = i*nLong;
|
|
for(int j=0,m=-(nLong-1)/2; m<=(nLong-1)/2; m++, j++) {
|
|
double nLongAng=(double)(2.0*PI/(nLong-1)*m-PI);
|
|
double x=(double)(xy*cos(nLongAng));
|
|
double y=(double)(xy*sin(nLongAng));
|
|
|
|
int nIndex = nLatNum+j;
|
|
pPtArray[nIndex].x = x+ptCenter.x;
|
|
pPtArray[nIndex].y = y+ptCenter.y;
|
|
pPtArray[nIndex].z = z+ptCenter.z;
|
|
}
|
|
|
|
pPtArray[nLatNum+nLong-1] = pPtArray[nLatNum];
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int TDbNetshelf::GetSphereDivNum() const
|
|
{
|
|
extern double g_nCirDeviation;
|
|
extern int GetCirDivNum(double r, double h);
|
|
|
|
int nDiv = TchExport::GetCirDivNum(m_dRadiusSphere,_AS_SYS_UNIT(TchGeLib::g_nCirDeviation));
|
|
if (nDiv < 3) {
|
|
nDiv = 3;
|
|
}
|
|
return nDiv;
|
|
}
|
|
|
|
int TDbNetshelf::GetPoleDivNum() const
|
|
{
|
|
extern double g_nCirDeviation;
|
|
extern int GetCirDivNum(double r, double h);
|
|
|
|
int nDiv = TchExport::GetCirDivNum(m_dRadiusPole,_AS_SYS_UNIT(TchGeLib::g_nCirDeviation));
|
|
if (nDiv < 3) {
|
|
nDiv = 3;
|
|
}
|
|
return nDiv;
|
|
}
|
|
|
|
void TDbNetshelf::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
assertReadEnabled();
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("网架")));
|
|
}
|
|
|
|
|
|
|
|
void InitDbNetshelf(BOOL bTrue)
|
|
{
|
|
if(bTrue) {
|
|
TDbNetshelf::rxInit();
|
|
acrxBuildClassHierarchy();
|
|
TDbNetshelf::InitMatchProtocol(TRUE);
|
|
} else {
|
|
TDbNetshelf::InitMatchProtocol(FALSE);
|
|
deleteAcRxClass(TDbNetshelf::desc());
|
|
}
|
|
}
|
|
|
|
|
|
|