1234 lines
34 KiB
C++
1234 lines
34 KiB
C++
#include "stdafx.h"
|
|
#include "AcDbObjectPtr.h"
|
|
#include "globalFunc.h"
|
|
#include "globalDefine.h"
|
|
#include "DbEquipment.h"
|
|
#include "DbPipe.h"
|
|
#include "PipePrototype.h"
|
|
#include <sstream>
|
|
|
|
static double g_dPointToOriginLimitDist = 1e+6;
|
|
void Matrix3D2String(const AcGeMatrix3d &mat, CString &str)
|
|
{
|
|
#if ADS <= 15
|
|
std::ostringstream stream;
|
|
#else
|
|
std::wostringstream stream;
|
|
#endif
|
|
for (int ln = 0; ln < 4; ++ln)
|
|
{
|
|
for (int col = 0; col < 4; ++col)
|
|
{
|
|
stream << mat.entry[ln][col];
|
|
#if ADS <= 15
|
|
stream << " ";
|
|
#else
|
|
stream << L" ";
|
|
#endif
|
|
}
|
|
}
|
|
str = stream.str().c_str();
|
|
}
|
|
|
|
// cet2017.3.2 add 设备类型名
|
|
CString GetEquipmentName(const CDbEquipment *pEquip)
|
|
{
|
|
CString sName = _T("普通设备");
|
|
if (pEquip == NULL)
|
|
{
|
|
return sName;
|
|
}
|
|
if (pEquip->IsSprinkler())
|
|
{
|
|
sName = _T("喷头");
|
|
}
|
|
else if (pEquip->IsHydrant())
|
|
{
|
|
sName = _T("消火栓");
|
|
}
|
|
int nEquipType = pEquip->GetEquipmentType();
|
|
switch (nEquipType)
|
|
{
|
|
case 0:
|
|
{
|
|
sName = _T("消火栓");
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
sName = _T("喷头");
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
sName = _T("井");
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
sName = _T("水泵");
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
sName = _T("雨水口");
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
sName = _T("大小接头");
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return sName;
|
|
}
|
|
|
|
extern CString ReadXdata(Entity ent, const TCHAR*szName);
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(CDbEquipment, CDbPipeNode, AcDb::kDHL_CURRENT,
|
|
AcDb::kMReleaseCurrent, 1, AEC_ZT_EQUIPMENT,
|
|
"AEC_ZT_EQUIPMENT图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
const Adesk::UInt8 CDbEquipment::g_nVersion = 3;
|
|
|
|
CDbEquipment::CDbEquipment() :
|
|
m_vtDirection(1, 0, 0), m_dScale(1.0), m_dDang(0.5),
|
|
m_bHidePipe(TRUE), m_nMirror(0), m_dPipeLength(0)
|
|
{
|
|
m_visibility = TPipeSys::kVisible;
|
|
m_dYScale = 0;
|
|
m_dZScale = 0;
|
|
m_bAutoScale = TRUE;
|
|
}
|
|
|
|
void CDbEquipment::CopyPropertiesFrom(AcDbEntity *pSrc, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
CDbPipeNode::CopyPropertiesFrom(pSrc, gMatchFlag);
|
|
CDbEquipment *pEqu = CDbEquipment::cast(pSrc);
|
|
if (pEqu) {
|
|
//m_idBlock2d = pEqu->m_idBlock2d;
|
|
//m_idBlock3d = pEqu->m_idBlock3d;
|
|
//m_sSysBlock = pEqu->m_sSysBlock;
|
|
//m_dScale = pEqu->m_dScale;
|
|
m_bHidePipe = pEqu->m_bHidePipe;
|
|
//m_nMirror = pEqu->m_nMirror;
|
|
//m_dPipeLength = pEqu->m_dPipeLength;
|
|
//m_dDang = pEqu->m_dDang;
|
|
}
|
|
}
|
|
|
|
//Acad::ErrorStatus CDbEquipment::subGetClassID(CLSID* pClsid) const
|
|
//{
|
|
// return Acad::eOk;
|
|
//}
|
|
|
|
Acad::ErrorStatus
|
|
CDbEquipment::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& ptPick,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
|
|
if (osnapMode == AcDb::kOsModeIns ||
|
|
osnapMode == AcDb::kOsModeCen ||
|
|
osnapMode == AcDb::kOsModeNode) {
|
|
snapPoints.append(m_ptInsert);
|
|
snapPoints.append(m_ptLocation);
|
|
}
|
|
es = CDbPipeNode::subGetOsnapPoints(osnapMode, gsSelectionMark,
|
|
ptPick, lastPoint, viewXform, snapPoints, geomIds);
|
|
|
|
return es;
|
|
}
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus CDbEquipment::dwgInFields(AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = CDbPipeNode::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_idBlock2d);
|
|
pFiler->readItem(&m_idBlock3d);
|
|
GlobalFunc::ReadString(pFiler, m_sSysBlock);
|
|
pFiler->readItem((AcGePoint3d *)&m_ptLocation);
|
|
pFiler->readItem((AcGePoint3d *)&m_ptInsert);
|
|
pFiler->readItem((AcGeVector3d *)&m_vtDirection);
|
|
pFiler->readItem(&m_dScale);
|
|
//pFiler->readItem(&m_bHidePipe);
|
|
GlobalFunc::FilerRead(pFiler, m_bHidePipe);
|
|
pFiler->readItem(&m_nMirror);
|
|
pFiler->readItem(&m_dPipeLength);
|
|
pFiler->readItem(&m_dDang);
|
|
if (nVer > 1) {
|
|
pFiler->readItem(&m_dCircleRadius);
|
|
pFiler->readItem(&m_dYScale);
|
|
pFiler->readItem(&m_dZScale);
|
|
pFiler->readItem(&m_dSpare);
|
|
if (nVer > 2) {
|
|
//pFiler->readItem(&m_bAutoScale);
|
|
GlobalFunc::FilerRead(pFiler, m_bAutoScale);
|
|
}
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus CDbEquipment::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = CDbPipeNode::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk) return es;
|
|
|
|
pFiler->writeItem(g_nVersion);
|
|
pFiler->writeItem(m_idBlock2d);
|
|
pFiler->writeItem(m_idBlock3d);
|
|
pFiler->writeItem((const TCHAR *)m_sSysBlock);
|
|
pFiler->writeItem((const AcGePoint3d &)m_ptLocation);
|
|
pFiler->writeItem((const AcGePoint3d &)m_ptInsert);
|
|
pFiler->writeItem((const AcGeVector3d &)m_vtDirection);
|
|
pFiler->writeItem(m_dScale);
|
|
//pFiler->writeItem(m_bHidePipe);
|
|
GlobalFunc::FilerWrite(pFiler, m_bHidePipe);
|
|
pFiler->writeItem(m_nMirror);
|
|
pFiler->writeItem(m_dPipeLength);
|
|
pFiler->writeItem(m_dDang);
|
|
pFiler->writeItem(m_dCircleRadius);
|
|
pFiler->writeItem(m_dYScale);
|
|
pFiler->writeItem(m_dZScale);
|
|
pFiler->writeItem(m_dSpare);
|
|
GlobalFunc::FilerWrite(pFiler, m_bAutoScale);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus CDbEquipment::dxfInFields(AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = CDbPipeNode::dxfInFields(pFiler);
|
|
if (es != Acad::eOk) return es;
|
|
|
|
if (!pFiler->atSubclassData(_T("CDbEquipment"))) {
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
|
|
resbuf rb;
|
|
while ((es == Acad::eOk) && ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
|
switch (rb.restype) {
|
|
case AcDb::kDxfXCoord:
|
|
m_ptLocation = rb.resval.rpoint;
|
|
break;
|
|
case AcDb::kDxfXReal:
|
|
m_dScale = rb.resval.rreal;
|
|
break;
|
|
case AcDb::kDxfBlockName:
|
|
break;
|
|
default:
|
|
pFiler->pushBackItem();
|
|
es = Acad::eEndOfFile;
|
|
break;
|
|
}
|
|
}
|
|
if (es != Acad::eEndOfFile)
|
|
return Acad::eInvalidResBuf;
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus CDbEquipment::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = CDbPipeNode::dxfOutFields(pFiler);
|
|
assert(es == Acad::eOk);
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass, _T("CDbEquipment"));
|
|
assert(es == Acad::eOk);
|
|
|
|
pFiler->writePoint3d(AcDb::kDxfXCoord, m_ptLocation);
|
|
pFiler->writeDouble(AcDb::kDxfXReal, m_dScale);
|
|
CString sBlkName, sDesName;
|
|
GlobalFunc::GetBlkNameById(m_idBlock2d, sBlkName, sDesName);
|
|
pFiler->writeString(AcDb::kDxfBlockName, (const TCHAR*)sBlkName);
|
|
// cet 2017.3.2 add 添加设备类型名,用于识别设备
|
|
CString sName = GetEquipmentName(this);
|
|
pFiler->writeString(AcDb::kDxfXTextString, (const TCHAR*)sName);
|
|
return es;
|
|
}
|
|
|
|
// 图块插入比例
|
|
AcGeScale3d CDbEquipment::GetInsertScale() const
|
|
{
|
|
assertReadEnabled();
|
|
double dScale(1), dScaleY(1), dScaleZ(1);
|
|
if (m_bAutoScale)
|
|
{
|
|
dScale = m_dScale * GetPScale() / 100;
|
|
dScaleY = m_dYScale * GetPScale() / 100;
|
|
dScaleZ = m_dZScale * GetPScale() / 100;
|
|
}
|
|
else
|
|
{
|
|
dScale = m_dScale;
|
|
dScaleY = m_dYScale;
|
|
dScaleZ = m_dZScale;
|
|
}
|
|
|
|
if (fabs(dScaleY) < 0.001)
|
|
dScaleY = dScale;
|
|
if (fabs(dScaleZ) < 0.001)
|
|
dScaleZ = dScale;
|
|
AcGeScale3d scale(dScale, dScaleY, fabs(dScaleZ));
|
|
if (IsMirrorByY())
|
|
scale.sx *= -1;
|
|
if (IsMirrorByX())
|
|
scale.sy *= -1;
|
|
return scale;
|
|
}
|
|
|
|
Acad::ErrorStatus CDbEquipment::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
if (Has2DBuffer())
|
|
{
|
|
Draw2DBuffers(dc);
|
|
return Acad::eOk;
|
|
}
|
|
// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
|
|
//AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
|
|
//if (player.openStatus() == Acad::eOk && player->isOff())
|
|
//{
|
|
// return Acad::eOk;
|
|
//}
|
|
return _ExplodeOrDraw2d(dc);
|
|
}
|
|
|
|
Acad::ErrorStatus CDbEquipment::_ExplodeOrDraw2d(AcGiDraw &dc, BOOL bZEqual0) const
|
|
{
|
|
if (!m_idBlock2d.isValid())
|
|
return Acad::eInvalidInput;
|
|
|
|
if (fabs(m_vtDirection.x) < 1.0E-6 && fabs(m_vtDirection.y) < 1.0E-6)
|
|
return Acad::eOk; //垂直设备
|
|
|
|
XPoint ptInsert = m_ptInsert;
|
|
if (bZEqual0) ptInsert.z = 0;
|
|
double dAngle = ads_angle(XPoint(), m_vtDirection);
|
|
DrawBlock(dc, m_idBlock2d, m_ptInsert, GetInsertScale(), dAngle);
|
|
|
|
OPENOBJ_BEGIN(m_idBlock2d, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
|
|
if (pBlock) {
|
|
|
|
// BOOL bNewMethod=(g_nAcadVer>15.0001 && g_bMakeBlock);
|
|
// sg add 091105，强制打印时，不使用新方法
|
|
// if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0 && dc.IsPlotGeneration())
|
|
// bNewMethod = FALSE;
|
|
|
|
//2011-9-30 SBdc.DrawBlock(*pBlock,ptInsert,GetInsertScale(),dAngle,TRUE); 采用旧方法，从8.0版本开始，TRUE参数对于打印不起作用。关闭图层，仍然打印
|
|
//dc.DrawBlock(*pBlock,ptInsert,GetInsertScale(),dAngle,bNewMethod);
|
|
|
|
|
|
//dc.DrawBlock(*pBlock, ptInsert, GetInsertScale(), dAngle, TRUE);
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus CDbEquipment::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
if (!m_idBlock3d.isValid())
|
|
return _ExplodeOrDraw2d(dc, FALSE);
|
|
|
|
OPENOBJ_BEGIN(m_idBlock3d, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
|
|
if (pBlock) {
|
|
XVector3D vtNormal(0, 0, 1);
|
|
if (fabs(m_vtDirection.z) > 1.0E-6)
|
|
{ //非水平面，计算法向
|
|
vtNormal = GlobalFunc::operator*(XVector3D(1, 0, 0) ,m_vtDirection);
|
|
//vtNormal = XVector3D(1, 0, 0) * m_vtDirection;
|
|
vtNormal.Normalize();
|
|
}
|
|
//XPoint ptLoc=GlobalFunc::Wcs2Ecs(m_ptLocation, vtNormal); cet 2011.12.29 modify
|
|
XPoint ptInsert = m_ptInsert;
|
|
ptInsert.z = m_ptLocation.z;
|
|
XPoint ptLoc = GlobalFunc::Wcs2Ecs(ptInsert, vtNormal);
|
|
if (IsUpLinkHydrant()) // 上接消火栓补充一段管线
|
|
{
|
|
ExplodeOrDrawPipe3d(dc);
|
|
}
|
|
|
|
double nRotEcs = ads_angle(XPoint(), m_vtDirection); //计算ECS下的转角
|
|
|
|
|
|
AcDbBlockReference insert(ptLoc, m_idBlock3d);
|
|
insert.setRotation(nRotEcs);
|
|
insert.setScaleFactors(GetInsertScale());
|
|
//if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor()) == 0) {
|
|
AcGeMatrix3d mat = insert.blockTransform();
|
|
AcGiGeometry *geom = ((AcGiViewDraw &)dc).GetCommonDraw()->rawGeometry();
|
|
geom->pushModelTransform(mat);
|
|
geom->draw(pBlock);
|
|
geom->popModelTransform();
|
|
//}
|
|
//else if (_tcscmp(dc.Desc(), XExplodeStream::Descriptor()) == 0) {
|
|
// ((XExplodeStream &)dc).Append((AcDbEntity *)insert.clone());
|
|
//}
|
|
}
|
|
else {
|
|
return Acad::eInvalidInput;
|
|
}
|
|
OPENOBJ_END();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus CDbEquipment::ExplodeOrDrawPipe3d(AcGiDraw &dc) const
|
|
{
|
|
// 获得连接管的id
|
|
int nNum = GetInterfaceNum();
|
|
CPipeInterface face;
|
|
AcDbObjectId idPipe;
|
|
for (int i = 0; i < nNum; i++)
|
|
{
|
|
GetInterface(i, face);
|
|
idPipe = face.m_idPipe;
|
|
break;
|
|
}
|
|
|
|
OPENOBJ_BEGIN(idPipe, AcDb::kForRead, CDbPipe, pPipe);
|
|
if (pPipe != NULL)
|
|
{
|
|
// 获得管道起点终点
|
|
XVector3D vtNormal(0, 0, 1);
|
|
if (fabs(m_vtDirection.z) > 1.0E-6) //非水平面，计算法向
|
|
{
|
|
vtNormal = GlobalFunc::operator*(XVector3D(1, 0, 0) ,m_vtDirection);
|
|
//vtNormal = XVector3D(1, 0, 0) * m_vtDirection;
|
|
vtNormal.Normalize();
|
|
}
|
|
XPoint ptInsert = m_ptInsert;
|
|
ptInsert.z = m_ptLocation.z;
|
|
XPoint pt1 = GlobalFunc::Wcs2Ecs(ptInsert, vtNormal);
|
|
XLine line(pPipe->StartPoint(), pPipe->EndPoint());
|
|
XPoint pt2 = GlobalFunc::Wcs2Ecs(m_ptLocation, vtNormal);
|
|
m_ptLocation.Project(&line, pt2);
|
|
|
|
CDbPipe *pNewPipe = (CDbPipe *)pPipe->clone();
|
|
pNewPipe->SetStartPoint(pt1);
|
|
pNewPipe->SetEndPoint(pt2);
|
|
pNewPipe->SetNode(0, AcDbObjectId::kNull);
|
|
pNewPipe->SetNode(1, AcDbObjectId::kNull);
|
|
Adesk::UInt16 color = dc.GetColor();
|
|
dc.SetColor(1);
|
|
DrawBaseEx(dc, *pNewPipe);
|
|
//pNewPipe->Draw3d(dc);
|
|
dc.SetColor(color);
|
|
}
|
|
OPENOBJ_END();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void CDbEquipment::GetTips(DList<ObjInfoUnit> &info) const
|
|
{
|
|
info.Append(new ObjInfoUnit(_T("对象类型"), _T("设备")));
|
|
CString sBlkName, sDesName;
|
|
if (GlobalFunc::GetBlkNameById(m_idBlock2d, sBlkName, sDesName) && !sDesName.IsEmpty()) {
|
|
info.Append(new ObjInfoUnit(_T("对象名称"), (const TCHAR*)sDesName));
|
|
}
|
|
// if(sDesName.Find(_T("井")) > -1){ //检查井
|
|
// info.Append(new ObjInfoUnit(_T("井编号"), m_sSysBlock));
|
|
// info.Append(new ObjInfoUnit(_T("地面标高"), XString(_T("%.3f"), m_dDang)));
|
|
// info.Append(new ObjInfoUnit(_T("井底标高"), XString("%.3f", m_dPipeLength)));
|
|
// int num = GetInterfaceNum();
|
|
// for(int i=0;i<num;i++){
|
|
// CPipeInterface iFace;
|
|
// GetInterface(i, iFace);
|
|
// CString csPipeName, csLabel;
|
|
// csLabel = GetISysLabel(i);
|
|
// if(csLabel == "")
|
|
// continue;
|
|
// OPENOBJ_BEGIN(iFace.m_idPipe,AcDb::kForRead,CDbPipePrototype,pPipe);
|
|
// if(pPipe) {
|
|
// csPipeName = pPipe->GetSysLabel();
|
|
// }
|
|
// OPENOBJ_END();
|
|
// csPipeName.Format("%s底标高", csPipeName);
|
|
// info.Append(new ObjInfoUnit((const char*)csPipeName, csLabel));
|
|
// }
|
|
// }
|
|
// else
|
|
info.Append(new ObjInfoUnit(_T("当量值"), GlobalFunc::Dist2Str(m_dDang)));
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
CDbEquipment::GetGripText(int idx, CString &cs) const
|
|
{
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
switch (idx) {
|
|
case 0: cs = _T("移动设备"); break;
|
|
case 1: cs = _T("移动基点"); break;
|
|
case 2: cs = _T("改变消火栓开启方向"); break; // cet 2016.8.3 add
|
|
default: es = Acad::eInvalidInput;
|
|
}
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
CDbEquipment::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
gripPoints.append((AcGePoint3d)m_ptInsert);
|
|
gripPoints.append((AcGePoint3d)m_ptLocation);
|
|
// cet 2016.8.3 add 增加消火栓右侧夹点，用于实现调整消火栓开启方向
|
|
if (m_idBlock2d.isValid() && IsHydrant())
|
|
{
|
|
double dWidth = GetInsertScale().sx;
|
|
double dHeight = GetInsertScale().sy;
|
|
double dAngle = ads_angle(XPoint(), m_vtDirection);
|
|
AcGeVector3d vtX = AcGeVector3d::kXAxis * dWidth * 0.5 + AcGeVector3d::kYAxis * dHeight * 0.55;
|
|
AcGePoint3d pt = m_ptLocation + vtX.rotateBy(dAngle, AcGeVector3d::kZAxis);
|
|
gripPoints.append(pt);
|
|
}
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
CDbEquipment::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
stretchPoints.append((AcGePoint3d)m_ptInsert);
|
|
stretchPoints.append((AcGePoint3d)m_ptLocation);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
CDbEquipment::subMoveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
// cet 2016.8.3 add 消火栓夹点，实现调整方向
|
|
if (indices.length() == 1 && indices[0] == 2)
|
|
{
|
|
// 移动前所在象限
|
|
double dWidth = GetInsertScale().sx;
|
|
double dHeight = GetInsertScale().sy;
|
|
double dAngleBeforeMove = AcGeVector3d::kXAxis.angleTo(AcGeVector3d::kXAxis * dWidth * 0.5 + AcGeVector3d::kYAxis * dHeight * 0.55, AcGeVector3d::kZAxis);
|
|
int nDirBeforMove = -1;
|
|
if (fabs(dAngleBeforeMove - PI * 2) < 0.001)
|
|
{
|
|
dAngleBeforeMove = 0.0;
|
|
}
|
|
if (dAngleBeforeMove > 0.0 + 0.001 && dAngleBeforeMove + 0.001 < PI * 0.5) // (0, 90)
|
|
{
|
|
nDirBeforMove = 0;
|
|
}
|
|
else if (dAngleBeforeMove > PI * 0.5 + 0.001 && dAngleBeforeMove + 0.001 < PI) // (90, 180)
|
|
{
|
|
nDirBeforMove = 1;
|
|
}
|
|
else if (dAngleBeforeMove > PI + 0.001 && dAngleBeforeMove + 0.001 < PI * 1.5) // (180, 270)
|
|
{
|
|
nDirBeforMove = 2;
|
|
}
|
|
else if (dAngleBeforeMove > PI * 1.5 + 0.001 && dAngleBeforeMove + 0.001 < PI * 2) // (270, 360)
|
|
{
|
|
nDirBeforMove = 3;
|
|
}
|
|
// 移动后点所在象限
|
|
AcGeVector3d vtX = AcGeVector3d::kXAxis * dWidth * 0.5 + AcGeVector3d::kYAxis * dHeight * 0.55;
|
|
double dAngle = ads_angle(XPoint(), m_vtDirection);
|
|
vtX.rotateBy(dAngle, AcGeVector3d::kZAxis);
|
|
AcGeVector3d ptMove = m_ptLocation + vtX + offset;
|
|
AcGeVector3d vtTemp = ptMove - m_ptLocation.AsAcGePoint3d();
|
|
vtTemp.z = 0.0;
|
|
vtX = AcGeVector3d::kXAxis;
|
|
vtX.rotateBy(dAngle, AcGeVector3d::kZAxis);
|
|
double dAngleAfterMove = vtX.angleTo(vtTemp, AcGeVector3d::kZAxis);
|
|
if (fabs(dAngleAfterMove - PI * 2) < 0.001)
|
|
{
|
|
dAngleAfterMove = 0.0;
|
|
}
|
|
int nDirAfterMove = -1;
|
|
if (dAngleAfterMove > 0.0 + 0.001 && dAngleAfterMove + 0.001 < PI * 0.5) // (0, 90)
|
|
{
|
|
nDirAfterMove = 0;
|
|
}
|
|
else if (dAngleAfterMove > PI * 0.5 + 0.001 && dAngleAfterMove + 0.001 < PI) // (90, 180)
|
|
{
|
|
nDirAfterMove = 1;
|
|
}
|
|
else if (dAngleAfterMove > PI + 0.001 && dAngleAfterMove + 0.001 < PI * 1.5) // (180, 270)
|
|
{
|
|
nDirAfterMove = 2;
|
|
}
|
|
else if (dAngleAfterMove > PI * 1.5 + 0.001 && dAngleAfterMove + 0.001 < PI * 2) // (270, 360)
|
|
{
|
|
nDirAfterMove = 3;
|
|
}
|
|
// 根据象限变化调整方向
|
|
if (nDirAfterMove == nDirBeforMove || nDirBeforMove == -1 || nDirAfterMove == -1)
|
|
{
|
|
return es;
|
|
}
|
|
if (nDirBeforMove == 0 && nDirAfterMove == 3 ||
|
|
nDirBeforMove == 1 && nDirAfterMove == 2 ||
|
|
nDirBeforMove == 2 && nDirAfterMove == 1 ||
|
|
nDirBeforMove == 3 && nDirAfterMove == 0) // x轴镜像
|
|
{
|
|
MirrorByX(IsMirrorByX() ? FALSE : TRUE);
|
|
}
|
|
else if (nDirBeforMove == 0 && nDirAfterMove == 1 ||
|
|
nDirBeforMove == 1 && nDirAfterMove == 0 ||
|
|
nDirBeforMove == 2 && nDirAfterMove == 3 ||
|
|
nDirBeforMove == 3 && nDirAfterMove == 2) // y轴镜像
|
|
{
|
|
MirrorByY(IsMirrorByY() ? FALSE : TRUE);
|
|
}
|
|
else
|
|
{
|
|
MirrorByY(IsMirrorByY() ? FALSE : TRUE);
|
|
MirrorByX(IsMirrorByX() ? FALSE : TRUE);
|
|
}
|
|
return es;
|
|
}
|
|
es = MoveGSPointsAt(indices, offset);
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
CDbEquipment::subMoveStretchPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = MoveGSPointsAt(indices, offset);
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
CDbEquipment::MoveGSPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
XPoint vtOffset;
|
|
(AcGeVector3d &)vtOffset = offset;
|
|
vtOffset.z = 0;
|
|
m_ptInsert += vtOffset;
|
|
m_ptLocation += vtOffset;
|
|
|
|
return es;
|
|
|
|
// SR 2010-6-17 修改 拉伸不考虑z坐标
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Acad::ErrorStatus es=Acad::eOk;
|
|
// AcGeMatrix3d mat;
|
|
// mat.setToTranslation(offset);
|
|
//
|
|
// if(m_ptLocation==m_ptInsert) {
|
|
// m_ptInsert.TransformBy(mat);
|
|
// m_ptLocation.TransformBy(mat);
|
|
// }
|
|
// else {
|
|
// for (int i=0; i<indices.length();i++) {
|
|
// int idx = indices[i];
|
|
// switch(idx) {
|
|
// case 0:
|
|
// m_ptInsert.TransformBy(mat);
|
|
// m_ptLocation.TransformBy(mat);//sr add 2004/7/27
|
|
// break;
|
|
// case 1:
|
|
// m_ptInsert.TransformBy(mat);
|
|
// m_ptLocation.TransformBy(mat);
|
|
// break;
|
|
// default:
|
|
// es=Acad::eInvalidInput;
|
|
// }
|
|
// }
|
|
// }
|
|
// return es;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus
|
|
CDbEquipment::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
CDbPipeNode::subTransformBy(xform);
|
|
m_ptInsert.TransformBy(xform);
|
|
m_ptLocation.TransformBy(xform);
|
|
|
|
/* cet 2012.7.5 modify 原方法镜像错误
|
|
if(IsMirrorMatrix(xform))
|
|
{//设备镜像 sr modify 2007/3/9
|
|
// TCHAR *layer;
|
|
// layer = this->layer();
|
|
// if(_tcsicmp(layer, LAY_EQUIP_HYDRANT) == 0) // 2009-7-30 SR 取消消火栓限制，其他附件也可以左右翻转了（忘记当初为什么要做这样的限制了）
|
|
MirrorByY(!IsMirrorByY()); //消火栓镜像稍微麻烦点
|
|
// delete []layer;
|
|
((AcGeVector3d &)m_vtDirection).transformBy(xform);
|
|
double dAng = ads_angle(XPoint(),m_vtDirection);
|
|
dAng = dAng - PI;
|
|
SetAngle(fabs(dAng));
|
|
return Acad::eOk;
|
|
}
|
|
|
|
((AcGeVector3d &)m_vtDirection).transformBy(xform);
|
|
*/
|
|
|
|
((AcGeVector3d &)m_vtDirection).transformBy(xform);
|
|
if (GlobalFunc::IsMirrorMatrix(xform))
|
|
{
|
|
MirrorByX(!IsMirrorByX());
|
|
}
|
|
|
|
double dScale = xform.scale();
|
|
if (fabs(dScale - 1) > 1.0E-5 && fabs(dScale) > 1.0E-5) { // cet 2010.8.27 modify 将1.0E-3 改为 1.0E-5
|
|
m_dScale *= dScale;
|
|
m_dYScale *= dScale; // 2009-8-3 增加Y,Z 不然用SC变比例，没有变Y,Z方向的比例
|
|
m_dZScale *= dScale;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void CDbEquipment::MirrorByX(BOOL bFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
if (bFlag)
|
|
m_nMirror |= MIRROR_XAXIS;
|
|
else
|
|
m_nMirror &= ~MIRROR_XAXIS;
|
|
}
|
|
|
|
void CDbEquipment::MirrorByY(BOOL bFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
if (bFlag)
|
|
m_nMirror |= MIRROR_YAXIS;
|
|
else
|
|
m_nMirror &= ~MIRROR_YAXIS;
|
|
}
|
|
|
|
Acad::ErrorStatus CDbEquipment::GetExtents(XPoint &ptLow, XPoint &ptUp) const
|
|
{
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = CDbPipeNode::GetExtents(ptLow, ptUp);
|
|
if (es == Acad::eOk) {
|
|
if (ptLow == XPoint() && ptUp == XPoint()) {
|
|
ptLow = m_ptLocation;
|
|
ptUp = m_ptLocation;
|
|
}
|
|
else {
|
|
ptLow = Min(ptLow, m_ptLocation);
|
|
ptUp = Max(ptUp, m_ptLocation);
|
|
}
|
|
}
|
|
return es;
|
|
}
|
|
|
|
// 判断节点是否可以连接管段. nPos: 0--start; 1--end
|
|
BOOL CDbEquipment::CanLinkSide(const AcDbObjectId &idPipe, int nPos) const
|
|
{
|
|
BOOL bRet = FALSE;
|
|
// cet 2016.6.7 modify 自定义实体中不再直接使用图层宏
|
|
// // zxl 2014.01.09 add 雨水口特殊处理
|
|
// CString sLayer = layer();
|
|
// if (sLayer.Compare(LAY_TWT_GULLY) == 0)
|
|
if (GetEquipmentType() == 4)
|
|
{
|
|
double dMeter = 1.0;
|
|
if (GlobalFunc::DocGetMeterUnitDraw())
|
|
dMeter = 1000.0;
|
|
double nRadius = GetScale() * GetPScale();
|
|
OPENOBJ_BEGIN(idPipe, AcDb::kForRead, CDbPipePrototype, pPipe);
|
|
if (pPipe) {
|
|
XPoint ptRef = nPos ? pPipe->EndPoint() : pPipe->StartPoint();
|
|
XPoint ptLoc = GetLocation();
|
|
ptLoc.z = 0;//
|
|
ptRef.z = 0;//
|
|
if (ptRef.Distance(ptLoc) < PS_SNAP / dMeter)
|
|
bRet = TRUE;
|
|
double nDist = ptRef.Distance(ptLoc);
|
|
if (fabs(nDist - nRadius / 2) < PS_SNAP / dMeter)
|
|
bRet = TRUE;
|
|
}
|
|
OPENOBJ_END();
|
|
return bRet;
|
|
}
|
|
|
|
OPENOBJ_BEGIN(idPipe, AcDb::kForRead, CDbPipePrototype, pPipe);
|
|
if (pPipe) {
|
|
const XPoint &ptRef = nPos ? pPipe->EndPoint() : pPipe->StartPoint();
|
|
XPoint ptLoc = GetLocation();
|
|
if (ptRef.Distance(ptLoc) < PS_SNAP)
|
|
bRet = TRUE;
|
|
}
|
|
OPENOBJ_END();
|
|
return bRet;
|
|
}
|
|
|
|
//XRectAngle.Intersection 函数有缺陷，无法求交坐标过大的情况
|
|
int IntersectionRect2Line(XRectAngle &rect, XLine &line, XPoint &ptInter)
|
|
{
|
|
AcGeLineSeg2d ln1(line.StartPoint().AsAcGePoint2d(), line.EndPoint().AsAcGePoint2d());
|
|
XPoint lowRight(rect.upRight.x, rect.lowLeft.y, rect.upRight.z),
|
|
upLeft(rect.lowLeft.x, rect.upRight.y, rect.upRight.z);
|
|
XLine line1(rect.lowLeft, lowRight, LS_FINITE),
|
|
line2(lowRight, rect.upRight, LS_FINITE),
|
|
line3(rect.upRight, upLeft, LS_FINITE),
|
|
line4(upLeft, rect.lowLeft, LS_FINITE);
|
|
int intersNum = 0;
|
|
XPoint intPt;
|
|
XLine *ptr[4] = { &line1, &line2, &line3, &line4 };
|
|
for (int i = 0; i < 4; i++) {
|
|
XPoint p1 = ptr[i]->StartPoint();
|
|
XPoint p2 = ptr[i]->EndPoint();
|
|
AcGeLineSeg2d ln2(p1.AsAcGePoint2d(), p2.AsAcGePoint2d());
|
|
if (ln1.intersectWith(ln2, ptInter))
|
|
return 1;
|
|
}
|
|
return intersNum;
|
|
}
|
|
|
|
double CDbEquipment::GetWidth(const CDbPipePrototype* pPipe) const
|
|
{
|
|
//待考虑三维图块...
|
|
double dWidth = 0;
|
|
// cet 2014.5.6 del 管线被设备遮挡的长度，通过炸开二维图块与管线求交获得
|
|
// CString csNumber = GetNumber();
|
|
//
|
|
// if(csNumber.Find(_T("CIRCLE")) >= 0 && IsHidePipe()){//如果是圆设备，返回圆半径×比例
|
|
// csNumber = csNumber.Right(csNumber.GetLength() - 7);
|
|
// dWidth = _tstof(csNumber)*GetScale();
|
|
// return dWidth*GetPScale()/100;
|
|
// }
|
|
if (m_idBlock2d.isValid()) {// 二维图块
|
|
AcDbExtents extents;
|
|
AcDbBlockReference insert(AcGePoint3d(0, 0, 0), m_idBlock2d);
|
|
double dScaleX(0), dScaleY(0);
|
|
|
|
if (m_bAutoScale)
|
|
{
|
|
dScaleX = m_dScale * GetPScale() / 100;
|
|
dScaleY = m_dYScale * GetPScale() / 100;
|
|
}
|
|
else
|
|
{
|
|
dScaleX = m_dScale;
|
|
dScaleY = m_dYScale;
|
|
}
|
|
|
|
|
|
if (fabs(dScaleY) < 0.001)
|
|
dScaleY = dScaleX;
|
|
|
|
if (IsMirrorByY())
|
|
dScaleX = -dScaleX;
|
|
if (IsMirrorByX())
|
|
dScaleY = -dScaleY;
|
|
insert.setScaleFactors(AcGeScale3d(dScaleX, dScaleY, fabs(dScaleX)));
|
|
// cet 2014.5.6 modify 使用外包框算法，结果有时不准备, 改为炸开实体求交 （未考虑图块嵌套情况）
|
|
// if(insert.geomExtentsBestFit(extents)==Acad::eOk) {
|
|
// XPoint ptMax = extents.maxPoint();
|
|
// XPoint ptMin = extents.minPoint();
|
|
//
|
|
// dWidth = (ptMax.x-ptMin.x)/2;// 第一次求得的宽度值
|
|
//
|
|
// if(pPipe!=NULL && pPipe->Is(CURVE_LINE)) { // 仅考虑直线管段
|
|
// XPoint ptPosition = insert.position();
|
|
// XPoint ptPlus = m_ptInsert-ptPosition;
|
|
//
|
|
// XPoint ptLocation=m_ptLocation;
|
|
// XRectAngle rect(ptMin+ptPlus,ptMax+ptPlus);
|
|
// XLine line=(XLine)*pPipe;
|
|
//
|
|
// double dAngle=CT_std_angle(ads_angle(XPoint(),m_vtDirection));
|
|
// if(fabs(dAngle)>1.0E-6) {
|
|
// ads_matrix mat;
|
|
// m_ptInsert.GetRotationMatrix(-dAngle,mat);
|
|
// line.TransformBy(mat);
|
|
// ptLocation.TransformBy(mat);
|
|
// }
|
|
// rect.SetElevation(0);
|
|
// line.SetElevation(0);
|
|
// ptLocation.z=0;
|
|
//
|
|
// int nFlag = ptLocation▭
|
|
// if(nFlag != PR_INSIDE) {
|
|
// dWidth = 0;
|
|
// } else {
|
|
// XPoint ptIntersect;
|
|
// if(IntersectionRect2Line(rect,line,ptIntersect)){
|
|
// dWidth=ptLocation.Distance(ptIntersect);
|
|
// }
|
|
// // if(rect.Intersection(line,ptIntersect)){//sr remove it 2007-5-9 XRectAngle.Intersection 函数有缺陷，无法求交坐标过大的情况
|
|
// // dWidth=ptLocation.Distance(ptIntersect);
|
|
// // }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
insert.setPosition(m_ptInsert);
|
|
double dAngle = ads_angle(XPoint(), m_vtDirection);
|
|
insert.setRotation(dAngle);
|
|
GeCurveSegment curve = pPipe->GetCurve();
|
|
curve.SetElevation(0.0);
|
|
AcDbCurve *pPipeCurve = curve.AsAcDbCurve();
|
|
// cet 2017.3.8 add 距离原点过远时，移动到原点附近计算，防止计算出错
|
|
AcGeMatrix3d mat = AcGeMatrix3d::kIdentity;
|
|
if (m_ptInsert.Distance(XPoint()) > g_dPointToOriginLimitDist)
|
|
{
|
|
XPoint ptTemp = m_ptInsert;
|
|
ptTemp.z = 0.0;
|
|
mat.setToTranslation(-ptTemp.AsAcGeVector3d());
|
|
insert.transformBy(mat);
|
|
pPipeCurve->transformBy(mat);
|
|
}
|
|
AcDbVoidPtrArray arrEnt;
|
|
AcGePoint3dArray arrIntPt, arrPoint;
|
|
AcGePoint3d pt1, pt2;
|
|
if (insert.explode(arrEnt) == Acad::eOk)
|
|
{
|
|
for (int j = 0; j < arrEnt.length(); ++j)
|
|
{
|
|
AcDbEntity *pEnt = (AcDbEntity*)(arrEnt[j]);
|
|
if (pEnt == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
AcDbCurve *pCurve = AcDbCurve::cast(pEnt);
|
|
if (pCurve == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
Acad::ErrorStatus st = pPipeCurve->intersectWith(pCurve, AcDb::kOnBothOperands, AcGePlane::kXYPlane, arrIntPt);
|
|
for (int i = 0; i < arrIntPt.length(); ++i)
|
|
{
|
|
arrPoint.append(arrIntPt[i]);
|
|
}
|
|
arrIntPt.setLogicalLength(0);
|
|
}
|
|
GlobalFunc::ReleaseEntSet(arrEnt);
|
|
}
|
|
delete pPipeCurve;
|
|
pPipeCurve = NULL;
|
|
|
|
// 设备插入点在管线一端，找到与设备重合的管线端点，求出距该点最用的交点距离
|
|
XPoint ptS = pPipe->GetStartPoint();
|
|
XPoint ptE = pPipe->GetEndPoint();
|
|
AcGePoint3d pt = ptS;
|
|
if (ptS.Distance2d(m_ptInsert) > ptE.Distance2d(m_ptInsert))
|
|
{
|
|
pt = ptE;
|
|
}
|
|
pt.transformBy(mat); // cet 2017.3.8 add 考虑距离原点过远情况，移动到原点附近计算
|
|
pt.z = 0.0;
|
|
for (int k = 0; k < arrPoint.length(); ++k)
|
|
{
|
|
double dDist = pt.distanceTo(arrPoint[k]);
|
|
if (k == 0 || dWidth < dDist)
|
|
{
|
|
dWidth = dDist;
|
|
}
|
|
}
|
|
}
|
|
return dWidth;
|
|
}
|
|
|
|
// 对st类型的接口进行重新连接
|
|
void CDbEquipment::UpdateLinkage(const XPoint &ptAt,
|
|
TPipeSys::SysType st,
|
|
const DList<AcDbObjectId> &idPipes)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptLocation = ptAt;
|
|
// cet 2016.6.7 modify 自定义实体中不再直接使用图层宏
|
|
// // zxl 2014.01.09 add 雨水口特殊处理
|
|
// CString sLayer = layer();
|
|
// if (sLayer.Compare(LAY_TWT_GULLY) == 0)
|
|
if (GetEquipmentType() == 4)
|
|
{
|
|
DList<CPipeInterface> lstInterface;//先保留一份出来，目的是得到各管底标高
|
|
for (int j = 0; j < m_lstInterface.Length(); j++) {
|
|
CPipeInterface& iFace = *m_lstInterface[j];
|
|
lstInterface.Append(new CPipeInterface(iFace));
|
|
}
|
|
|
|
double dMeter = 1.0;
|
|
if (GlobalFunc::DocGetMeterUnitDraw())
|
|
dMeter = 1000.0;
|
|
|
|
RemoveInterface(st);
|
|
double nRadius = GetScale() * GetPScale();
|
|
for (int i = 0; i < idPipes.Length(); i++) {
|
|
const AcDbObjectId &id = idPipes[i];
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, CDbPipe, pPipe);
|
|
if (pPipe) {
|
|
CPipeInterface iFace;
|
|
iFace.m_sysType = st;
|
|
iFace.m_faceType = CPipeInterface::kNodeLocation;
|
|
for (j = 0; j < lstInterface.Length(); j++) {
|
|
CPipeInterface& iFace2 = *lstInterface[j];
|
|
if (iFace2.m_idPipe == id) {
|
|
iFace.m_sSysLabel = iFace2.m_sSysLabel;
|
|
break;
|
|
}
|
|
}
|
|
iFace.m_idPipe = id;
|
|
XPoint ptS, ptE;
|
|
ptS = pPipe->StartPoint();
|
|
ptE = pPipe->EndPoint();
|
|
ptS.z = 0;
|
|
ptE.z = 0;
|
|
XPoint ptLoc = m_ptLocation;
|
|
ptLoc.z = 0;
|
|
double nDist1 = ptLoc.Distance(ptS);
|
|
double nDist2 = ptLoc.Distance(ptE);
|
|
if (nDist1 < PS_SNAP / dMeter || fabs(nDist1 - nRadius / 2) < PS_SNAP / dMeter) {
|
|
if (fabs(nDist1 - nRadius / 2) < PS_SNAP / dMeter) {
|
|
if (pPipe->upgradeOpen() == Acad::eOk) {
|
|
pPipe->SetStartPoint(m_ptLocation);
|
|
pPipe->downgradeOpen();
|
|
}
|
|
}
|
|
iFace.m_ptLocation = pPipe->StartPoint();
|
|
AcGeVector3d vt;
|
|
pPipe->getFirstDeriv(pPipe->StartPoint(), vt);
|
|
iFace.m_vtLocation = vt;
|
|
AddInterface(iFace);
|
|
}
|
|
else if (nDist2 < PS_SNAP / dMeter || fabs(nDist2 - nRadius / 2) < PS_SNAP / dMeter) {
|
|
if (fabs(nDist2 - nRadius / 2) < PS_SNAP / dMeter) {
|
|
if (pPipe->upgradeOpen() == Acad::eOk) {
|
|
pPipe->SetEndPoint(m_ptLocation);
|
|
pPipe->downgradeOpen();
|
|
}
|
|
}
|
|
iFace.m_ptLocation = pPipe->EndPoint();
|
|
AcGeVector3d vt;
|
|
pPipe->getFirstDeriv(pPipe->EndPoint(), vt);
|
|
iFace.m_vtLocation = XVector3D(-vt[0], -vt[1], -vt[2]);
|
|
AddInterface(iFace);
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
return;
|
|
}
|
|
CDbPipeNode::UpdateLinkage(ptAt, st, idPipes);
|
|
|
|
/*RemoveInterface(st);
|
|
for(int i=0; i<idPipes.Length(); i++) {
|
|
const AcDbObjectId &id=idPipes[i];
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, CDbPipe, pPipe);
|
|
if(pPipe) {
|
|
CPipeInterface iFace;
|
|
iFace.m_sysType = st;
|
|
iFace.m_faceType = CPipeInterface::kNodeLocation;
|
|
iFace.m_sSysLabel = pPipe->GetSysLabel();
|
|
iFace.m_idPipe = id;
|
|
if(m_ptLocation.Distance(pPipe->StartPoint())<PS_SNAP) {
|
|
iFace.m_ptLocation = pPipe->StartPoint();
|
|
AcGeVector3d vt;
|
|
pPipe->getFirstDeriv(pPipe->StartPoint(), vt);
|
|
iFace.m_vtLocation = vt;
|
|
AddInterface(iFace);
|
|
} else if(m_ptLocation.Distance(pPipe->EndPoint())<PS_SNAP) {
|
|
iFace.m_ptLocation = pPipe->EndPoint();
|
|
AcGeVector3d vt;
|
|
pPipe->getFirstDeriv(pPipe->EndPoint(), vt);
|
|
iFace.m_vtLocation = XVector3D(-vt[0], -vt[1], -vt[2]);
|
|
AddInterface(iFace);
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}*/
|
|
}
|
|
|
|
// 2008-2-27 SB add 支持系统图块与不相关但位置贴近的管线，进行裁剪
|
|
Acad::ErrorStatus CDbEquipment::GetClipBoundary(XPoly2D& poly)const
|
|
{
|
|
if (m_idBlock2d.isValid() && IsHidePipe()) {// 二维图块
|
|
AcDbExtents extents;
|
|
// AcDbBlockReference insert(m_ptLocation, m_idBlock2d);
|
|
// double dScaleX(0), dScaleY(0);
|
|
// dScaleX = m_dScale*GetPScale()/100;
|
|
// dScaleY = m_dYScale*GetPScale()/100;
|
|
// if(fabs(dScaleY) < 0.001)
|
|
// dScaleY = dScaleX;
|
|
//
|
|
// if(IsMirrorByY())
|
|
// dScaleX = -dScaleX;
|
|
// if(IsMirrorByX())
|
|
// dScaleY = -dScaleY;
|
|
// insert.setScaleFactors(AcGeScale3d(dScaleX, dScaleY, fabs(dScaleX)));
|
|
|
|
// if(insert.geomExtentsBestFit(extents)==Acad::eOk) {
|
|
if (getGeomExtents(extents) == Acad::eOk) {
|
|
XPoint ptMax = extents.maxPoint();
|
|
XPoint ptMin = extents.minPoint();
|
|
ptMax.z = 0;
|
|
ptMin.z = 0;
|
|
XRectAngle rect(ptMin, ptMax);
|
|
rect.AsPoly2D(poly);
|
|
poly.SetFlag(1);
|
|
//poly.Make();
|
|
return Acad::eOk;
|
|
}
|
|
}
|
|
|
|
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
BOOL CDbEquipment::IsSprinkler() const
|
|
{
|
|
// cet 2014.12.2 add 根据设备类型判断是否为喷头
|
|
if (GetEquipmentType() == 1)
|
|
{
|
|
return TRUE;
|
|
}
|
|
XString xsTmp1 = _T("$twtsys$00000125");
|
|
XString xsTmp2 = _T("$twtsys$00000128");
|
|
XString xsTmp3 = _T("$twtsys$00000129");
|
|
XString xsTmp4 = _T("$twtsys$00000131");
|
|
// XString xsTmp5 = _T("$twtsys$00000283"); //系统喷头
|
|
// XString xsTmp6 = _T("$twtsys$00000126"); //系统喷头
|
|
// XString xsTmp7 = _T("$twtsys$00000130"); //系统喷头
|
|
AcDbObjectId idBlk = GetBlock2d();
|
|
const TCHAR *szBlkName = NULL;
|
|
OPENOBJ_BEGIN(idBlk, AcDb::kForRead, AcDbBlockTableRecord, pRecord);
|
|
if (pRecord) {
|
|
pRecord->getName(szBlkName);
|
|
}
|
|
OPENOBJ_END();
|
|
// cet 2012.6.26 modify 将块名改为小写
|
|
CString sBlkName = szBlkName;
|
|
sBlkName.MakeLower();
|
|
if (_tcsicmp(sBlkName, xsTmp2) == 0 || _tcsicmp(sBlkName, xsTmp1) == 0 ||
|
|
_tcsicmp(sBlkName, xsTmp4) == 0 || _tcsicmp(sBlkName, xsTmp3) == 0) //是喷头
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CDbEquipment::IsHydrant() const
|
|
{
|
|
// cet 2014.12.2 add 根据设备类型判断是否为消火栓
|
|
if (GetEquipmentType() == 0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
XString xsTmp1 = _T("$twtsys$00000434");
|
|
XString xsTmp2 = _T("$twtsys$00000435");
|
|
XString xsTmp3 = _T("$twtsys$00000485");
|
|
XString xsTmp4 = _T("$twtsys$00000487");
|
|
XString xsTmp5 = _T("$twtsys$00000508");
|
|
XString xsTmp6 = _T("$twtsys$00000509");
|
|
const TCHAR *szBlkName = NULL;
|
|
AcDbObjectId idBlk = GetBlock2d();
|
|
OPENOBJ_BEGIN(idBlk, AcDb::kForRead, AcDbBlockTableRecord, pRecord);
|
|
if (pRecord) {
|
|
pRecord->getName(szBlkName);
|
|
}
|
|
OPENOBJ_END();
|
|
// cet 2012.6.26 modify 将块名改为小写
|
|
CString sBlkName = szBlkName;
|
|
sBlkName.MakeLower();
|
|
if (_tcsicmp(sBlkName, xsTmp2) == 0 || _tcsicmp(sBlkName, xsTmp1) == 0 ||
|
|
_tcsicmp(sBlkName, xsTmp3) == 0 || _tcsicmp(sBlkName, xsTmp4) == 0 ||
|
|
_tcsicmp(sBlkName, xsTmp5) == 0 || _tcsicmp(sBlkName, xsTmp6) == 0)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CDbEquipment::IsUpLinkHydrant() const
|
|
{
|
|
XString xsTmp1 = _T("$twtsys$00000441");
|
|
const TCHAR *szBlkName = NULL;
|
|
AcDbObjectId idBlk = GetBlock3d();
|
|
OPENOBJ_BEGIN(idBlk, AcDb::kForRead, AcDbBlockTableRecord, pRecord);
|
|
if (pRecord) {
|
|
pRecord->getName(szBlkName);
|
|
}
|
|
OPENOBJ_END();
|
|
// cet 2012.6.26 modify 将块名改为小写
|
|
CString sBlkName = szBlkName;
|
|
sBlkName.MakeLower();
|
|
if (_tcsicmp(sBlkName, xsTmp1) == 0)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
void InitDbEquipment(BOOL bTrue)
|
|
{
|
|
if (bTrue) {
|
|
CDbEquipment::rxInit();
|
|
//CDbEquipment::InitMatchProtocol(TRUE);
|
|
}
|
|
else {
|
|
//CDbEquipment::InitMatchProtocol(FALSE);
|
|
deleteAcRxClass(CDbEquipment::desc());
|
|
}
|
|
}
|
|
|
|
void CDbEquipment::SetEquipmentType(int nType)
|
|
{
|
|
assertWriteEnabled();
|
|
EntityFields &fd = Fields();
|
|
fd.SFD(_T("EquipmentType"), static_cast<Adesk::Int8>(nType));
|
|
}
|
|
|
|
void CDbEquipment::SetEquipmentType(EquipType nType)
|
|
{
|
|
SetEquipmentType(static_cast<int>(nType));
|
|
}
|
|
|
|
int CDbEquipment::GetEquipmentType() const
|
|
{
|
|
const EntityFields &fd = GetFields();
|
|
Adesk::Int8 nType = -1;
|
|
fd.GFD(_T("EquipmentType"), nType);
|
|
return static_cast<int>(nType);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|