3729 lines
106 KiB
C++
3729 lines
106 KiB
C++
#include "stdafx.h"
|
||
|
||
#include <DbCurveMesh2.h>
|
||
#include <DbPolyMesh.h>
|
||
|
||
|
||
#include "DbPipe.h"
|
||
#include "DbPipeFitting.h"
|
||
#include "DbPipeLabel.h"
|
||
#include "DbPipeValve.h"
|
||
#include "DbPsConfig.h"
|
||
#include "PipeTools.h"
|
||
#include "DbWell.h"
|
||
#include "DbDoubleLinePipe.h"
|
||
#include "DbVPipeDim.h"
|
||
#include "SectionUtility.h"
|
||
#include "SectionStructDef.h"
|
||
#include "TXmlTree.h"
|
||
//#include "TwtDef.h"
|
||
|
||
|
||
// 旋转向量
|
||
XVector3D RotateBy(const XVector3D& vt,const XVector3D& vtAxis,double dAngle/*弧度值*/)
|
||
{
|
||
AcGeVector3d vtTemp(vt);
|
||
AcGeVector3d vtResult=vtTemp.rotateBy(dAngle,vtAxis);
|
||
return XVector3D(vtResult);
|
||
}
|
||
|
||
// 绘制加粗的线（convert to pline）
|
||
void DrawWeight(XExplodeDraw &dc,double dWeight,AcDbPolyline& pline)
|
||
{
|
||
XAcGiViewDraw &viewDraw = (XAcGiViewDraw &)dc;
|
||
int nNum = pline.numVerts();
|
||
if (nNum > 0) {
|
||
// for (int k=0;k<nNum; k++) {
|
||
// pline.setWidthsAt(k,dWeight,dWeight);
|
||
// }
|
||
pline.setConstantWidth(dWeight);
|
||
viewDraw.Polyline(pline);
|
||
// dc << pline;
|
||
|
||
//dc.DrawEntity(pline);
|
||
// if(viewDraw.m_pWd)
|
||
// pline.worldDraw(viewDraw.m_pWd);
|
||
// else
|
||
// pline.viewportDraw(viewDraw.m_pVd);
|
||
}
|
||
}
|
||
|
||
//沈睿2004、6、9修改，增加颜色参数
|
||
void DrawWeight(XExplodeDraw &dc,double dWeight,XPoly2D &poly,int nColorIndex, double nScale)
|
||
{
|
||
//cet 2013.7.18 add 18、19平台粗显时，线型比例设置不正确
|
||
//2005/2/25 modify sr 管线支持比例因子，由于DC不直接支持，所以通过修改dc内部参数实现
|
||
//其中，绘制是修改DC环境参数，必须先执行，炸开是直接修改新生成的实体，所以后执行
|
||
if(_tcsicmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) {
|
||
XAcGiViewDraw &dcDraw = (XAcGiViewDraw&)dc;
|
||
// cet 2012.12.18 del 用户选择是否随管线比例变化
|
||
// dcDraw.GetCommonDraw()->subEntityTraits().setLineTypeScale(GetPScale()/100*linetypeScale());// SR 2012-6-19 支持线型比例随对象比例发生变化
|
||
dcDraw.GetCommonDraw()->subEntityTraits().setLineTypeScale(nScale);
|
||
}
|
||
|
||
AcDbPolyline pline;
|
||
pline.setLinetypeScale(nScale);
|
||
PolyConvert(poly, pline);
|
||
|
||
if(nColorIndex>0)
|
||
pline.setColorIndex(nColorIndex);
|
||
|
||
DrawWeight(dc,dWeight,pline);
|
||
}
|
||
void DrawWeight(XExplodeDraw &dc,double dWeight,XCurveSegment &seg,int nColorIndex, double nScale)
|
||
{
|
||
XPoly2D poly;
|
||
seg.AsPoly2D(poly);
|
||
DrawWeight(dc,dWeight,poly, nColorIndex,nScale);
|
||
}
|
||
void DrawWeight(XExplodeDraw &dc,double dWeight,XCircle &cir,int nColorIndex, double nScale)
|
||
{
|
||
XCurveSegment seg;
|
||
seg = cir;
|
||
DrawWeight(dc,dWeight,seg, nColorIndex, nScale);
|
||
}
|
||
|
||
|
||
ACRX_DXF_DEFINE_MEMBERS(ATSPipe, ATSPipePrototype, AcDb::kDHL_CURRENT,
|
||
AcDb::kMReleaseCurrent, 1, ATS_PIPE,
|
||
"ATS_PIPE图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
||
IMPLEMENT_TENTBASE(TDbPipe);
|
||
|
||
const Adesk::UInt8 TDbPipe::g_nVersion = 2;
|
||
|
||
TDbPipe::TDbPipe():
|
||
m_dRadius(30),m_dRadiusIn(0),m_dOldRadius(0),m_dDnDiameter(0),
|
||
m_dPipeWeight(0.35),m_nMaterial(0),m_dSpeedSubMid(0),m_dSpeedLength(0),m_dSpare(0)
|
||
{
|
||
m_sysType=TPipeSys::kUnknownSys/*kHeatPipe*/;
|
||
m_bUpdateLinkedDim = false; // cet 2015.3.11 add 默认不更新关联标注
|
||
}
|
||
|
||
void TDbPipe::CopyPropertiesFrom(AcDbEntity *pSrc,unsigned gMatchFlag)
|
||
{
|
||
assertWriteEnabled();
|
||
TDbPipePrototype::CopyPropertiesFrom(pSrc, gMatchFlag);
|
||
TDbPipe *pPipe = TDbPipe::cast(pSrc);
|
||
if(pPipe) {
|
||
m_dRadius = pPipe->m_dRadius;
|
||
m_dRadiusIn = pPipe->m_dRadiusIn;
|
||
m_dDnDiameter = pPipe->m_dDnDiameter;
|
||
m_dPipeWeight = pPipe->m_dPipeWeight;
|
||
m_nMaterial = pPipe->m_nMaterial;
|
||
m_sLabel = pPipe->m_sLabel;
|
||
SetPipeSystemName(pPipe->GetPipeSystemName()); // cet 2016.8.22 add
|
||
UpdateLinkedPipeDnDimText(); // cet 2017.9.19 add 更新相关标注
|
||
}
|
||
}
|
||
|
||
Acad::ErrorStatus TDbPipe::subGetClassID(CLSID* pClsid) const
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbPipe::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
|
||
INT_PTR gsSelectionMark,
|
||
const AcGePoint3d& ptPick,
|
||
const AcGePoint3d& lastPoint,
|
||
const AcGeMatrix3d& viewXform,
|
||
AcGePoint3dArray& snapPoints,
|
||
AcDbIntArray& geomIds) const
|
||
{
|
||
extern BOOL GetPSEntFormBlock(DList<AcDbObjectId> &lstPSEnt,
|
||
const XRectAngle& rectBound,const AcRxClass *pClass);
|
||
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
es=TDbPipePrototype::subGetOsnapPoints(osnapMode, gsSelectionMark,
|
||
ptPick, lastPoint, viewXform, snapPoints, geomIds);
|
||
if(es!=Acad::eOk) return es;
|
||
|
||
if(osnapMode==AcDb::kOsModeIns && !IsVertical()) { // 增加插入点
|
||
XPoint ptMin,ptMax;
|
||
DList<AcDbObjectId> lstPipe;
|
||
if(XCurveSegment::GetExtend(ptMin,ptMax)
|
||
&& GetPSEntFormBlock(lstPipe,XRectAngle(ptMin,ptMax),TDbPipe::desc())) {
|
||
AcDbObjectId idThis=objectId();
|
||
int nCount = lstPipe.Length();
|
||
for(long i=0;i<nCount;i++) {
|
||
AcDbObjectId &idPipe=*lstPipe[i];
|
||
if(idPipe==idThis)
|
||
continue;
|
||
OPENOBJ_BEGIN(idPipe,AcDb::kForRead,TDbPipe,pPipe);
|
||
if(pPipe!=NULL && !pPipe->IsVertical()) {
|
||
XPoint ptOnThis;
|
||
if(::Intersection(this,pPipe,ptOnThis)) {
|
||
snapPoints.append((AcGePoint3d)ptOnThis);
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
}
|
||
if(osnapMode==AcDb::kOsModeQuad && IsVertical()) { //立管 2007-11-23 武汉市院
|
||
double dRadius = m_dRadius*GetPScale();
|
||
XPoint ptCen = GetVerUpCenter();
|
||
XPoint pt1, pt2, pt3, pt4;
|
||
ads_polar(ptCen, 0, dRadius, pt1);
|
||
ads_polar(ptCen, PI/2.0, dRadius, pt2);
|
||
ads_polar(ptCen, PI, dRadius, pt3);
|
||
ads_polar(ptCen, PI/2.0*3.0, dRadius, pt4);
|
||
snapPoints.append(pt1);
|
||
snapPoints.append(pt2);
|
||
snapPoints.append(pt3);
|
||
snapPoints.append(pt4);
|
||
}
|
||
|
||
return es;
|
||
}
|
||
|
||
// 从DWG读入数据:
|
||
Acad::ErrorStatus
|
||
TDbPipe::dwgInFields(AcDbDwgFiler* pFiler)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
Acad::ErrorStatus es = TDbPipePrototype::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_dRadius);
|
||
pFiler->readItem(&m_dRadiusIn);
|
||
pFiler->readItem(&m_dDnDiameter);
|
||
pFiler->readItem(&m_dPipeWeight);
|
||
pFiler->readItem(&m_nMaterial);
|
||
ReadString(pFiler,m_sLabel);
|
||
|
||
pFiler->readItem(&m_dSpeedSubMid);
|
||
pFiler->readItem(&m_dSpeedLength);
|
||
|
||
if(nVer > 1){
|
||
pFiler->readItem(&m_dSpare);
|
||
// if (!IsNewDimType())
|
||
// {
|
||
// GetNewDimType();
|
||
// }
|
||
ReadString(pFiler,m_sSpare);
|
||
}
|
||
|
||
if(nVer == 1){
|
||
if(m_dRadius > 20)
|
||
m_dRadius = m_dRadius / 100;
|
||
if(m_dRadiusIn > 10)
|
||
m_dRadiusIn = m_dRadiusIn / 100;
|
||
}
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbPipe::dwgOutFields(AcDbDwgFiler* pFiler) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es = TDbPipePrototype::dwgOutFields(pFiler);
|
||
if(es != Acad::eOk) return es;
|
||
if(g_nSaveTArchVer==6)
|
||
pFiler->writeItem((Adesk::UInt8)1);
|
||
else
|
||
pFiler->writeItem(g_nVersion);
|
||
if(g_nSaveTArchVer==6){
|
||
pFiler->writeItem(m_dRadius*100);
|
||
pFiler->writeItem(m_dRadiusIn*100);
|
||
}
|
||
else{
|
||
pFiler->writeItem(m_dRadius);
|
||
pFiler->writeItem(m_dRadiusIn);
|
||
}
|
||
pFiler->writeItem(m_dDnDiameter);
|
||
pFiler->writeItem(m_dPipeWeight);
|
||
pFiler->writeItem(m_nMaterial);
|
||
pFiler->writeItem((const TCHAR *)m_sLabel);
|
||
pFiler->writeItem(m_dSpeedSubMid);
|
||
pFiler->writeItem(m_dSpeedLength);
|
||
|
||
if(g_nSaveTArchVer>6){
|
||
// zxl 2012.12.25 modify 新标注兼容老标注类型
|
||
// pFiler->writeItem(m_dSpare);
|
||
double dSpare = GetOldDimType();
|
||
pFiler->writeItem(dSpare);
|
||
pFiler->writeItem((const TCHAR *)m_sSpare);
|
||
}
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
double TDbPipe::GetOldDimType() const
|
||
{
|
||
if (!IsNewDimType())
|
||
{
|
||
return m_dSpare;
|
||
}
|
||
double dRet = -1;
|
||
int nDnType = GetPipeDnDimType();
|
||
int nGradientType = GetPipeGradientDimType();
|
||
int nLenType = GetPipeLenDimType();
|
||
int nLabelType = GetPipeDimLableType();
|
||
if (nDnType > 0)
|
||
{
|
||
if (nGradientType == 1 || nGradientType == 2)
|
||
{
|
||
if (nLenType > 0)
|
||
{
|
||
dRet = 1;
|
||
}
|
||
else
|
||
{
|
||
dRet = 4;
|
||
}
|
||
}
|
||
else if (nGradientType == 3 || nGradientType == 4)
|
||
{
|
||
if (nLenType > 0)
|
||
{
|
||
if (nLabelType == 0)
|
||
{
|
||
dRet = 3;
|
||
}
|
||
else
|
||
{
|
||
dRet = 2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (nLabelType == 0)
|
||
{
|
||
dRet = 6;
|
||
}
|
||
else
|
||
{
|
||
dRet = 5;
|
||
}
|
||
}
|
||
}
|
||
else if (nGradientType == 5 || nGradientType == 6)
|
||
{
|
||
dRet = 10;
|
||
}
|
||
else
|
||
{
|
||
if (nLenType > 0)
|
||
{
|
||
if (nLabelType == 0)
|
||
{
|
||
dRet = 7;
|
||
}
|
||
else if (nLabelType == 1)
|
||
{
|
||
dRet = 8;
|
||
}
|
||
else
|
||
{
|
||
dRet = 9;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
dRet = 0;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
dRet = 0;
|
||
}
|
||
|
||
return dRet;
|
||
}
|
||
|
||
|
||
Acad::ErrorStatus
|
||
TDbPipe::dxfInFields(AcDbDxfFiler* pFiler)
|
||
{
|
||
assertWriteEnabled();
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
es=TDbPipePrototype::dxfInFields(pFiler);
|
||
if(es!=Acad::eOk) return es;
|
||
|
||
if (!pFiler->atSubclassData(_T("TDbPipe"))) {
|
||
return Acad::eBadDxfSequence;
|
||
}
|
||
|
||
resbuf rb;
|
||
while((es==Acad::eOk) && ((es=pFiler->readResBuf(&rb))==Acad::eOk)) {
|
||
switch (rb.restype) {
|
||
case AcDb::kDxfXTextString+1:
|
||
m_sLabel=rb.resval.rstring;
|
||
break;
|
||
case AcDb::kDxfXReal:
|
||
m_dDnDiameter=rb.resval.rreal;
|
||
break;
|
||
case AcDb::kDxfXReal+1:
|
||
m_dTextHeight=rb.resval.rreal;
|
||
break;
|
||
case AcDb::kDxfXCoord:
|
||
m_ptLabel=rb.resval.rpoint;
|
||
break;
|
||
default:
|
||
pFiler->pushBackItem();
|
||
es = Acad::eEndOfFile;
|
||
break;
|
||
}
|
||
}
|
||
if(es!=Acad::eEndOfFile)
|
||
return Acad::eInvalidResBuf;
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbPipe::dxfOutFields(AcDbDxfFiler* pFiler) const
|
||
{
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
es=TDbPipePrototype::dxfOutFields(pFiler);
|
||
assert(es==Acad::eOk);
|
||
es=pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbPipe"));
|
||
assert(es==Acad::eOk);
|
||
|
||
pFiler->writeString(AcDb::kDxfXTextString+1,(const TCHAR*)m_sLabel);
|
||
pFiler->writeDouble(AcDb::kDxfXReal,m_dDnDiameter);
|
||
pFiler->writeDouble(AcDb::kDxfXReal+1,m_dTextHeight);
|
||
pFiler->writePoint3d(AcDb::kDxfXCoord,m_ptLabel);
|
||
pFiler->writeUInt8(AcDb::kDxfInt8, IsVertical());
|
||
|
||
return es;
|
||
}
|
||
|
||
//extern BOOL StringAnalysis(const TCHAR *src, XString &sPrefix, int *num, int *numWidth);
|
||
//void TDbPipe::SetSubText(long i,CString sText)
|
||
//{
|
||
// assertWriteEnabled();
|
||
// XString xsText;
|
||
// int num, numWith;
|
||
// StringAnalysis((const TCHAR*)sText, xsText, &num, &numWith);
|
||
// SetLabel((const TCHAR*)xsText);
|
||
// SetDnDiameter(num);
|
||
//}
|
||
|
||
|
||
|
||
// 增加流向夹点
|
||
Acad::ErrorStatus TDbPipe::subGetGripPoints(AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
es=TDbPipePrototype::subGetGripPoints(gripPoints, osnapModes, geomIds);
|
||
if(es!=Acad::eOk)
|
||
return es;
|
||
if(!IsVertical() && g_bSPipeFDir){
|
||
XPoint ptMid = MidPoint();
|
||
double dDir(0);
|
||
if(m_flowDir==TPipeSys::kFromEnd)
|
||
dDir = ads_angle(GetEndPoint(), GetStartPoint());
|
||
else
|
||
dDir = ads_angle(GetStartPoint(), GetEndPoint());
|
||
XPoint p1;
|
||
ads_polar(ptMid, dDir, GetPScale()*2, p1);
|
||
gripPoints.append(p1);
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
// 取得夹点说明
|
||
Acad::ErrorStatus TDbPipe::GetGripText(int idx, CString &cs) const
|
||
{
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
es = TDbPipePrototype::GetGripText(idx,cs);
|
||
if(es!=Acad::eOk && !IsVertical()) {
|
||
if(idx == 4 && g_bSPipeFDir)
|
||
cs=_T("改变流向");
|
||
es=Acad::eOk;
|
||
}
|
||
return es;
|
||
}
|
||
|
||
|
||
// 功能: 夹点操作
|
||
Acad::ErrorStatus TDbPipe::subMoveGripPointsAt(
|
||
const AcDbIntArray& indices,
|
||
const AcGeVector3d& offset)
|
||
{
|
||
assertWriteEnabled();
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
|
||
es=TDbPipePrototype::subMoveGripPointsAt(indices, offset);
|
||
|
||
if(es!=Acad::eOk) return es;
|
||
if(!IsVertical()){
|
||
int idx = indices[0];
|
||
if(idx == 4 && g_bSPipeFDir){
|
||
XPoint ptMid = MidPoint();
|
||
double dDir(0);
|
||
if(m_flowDir==TPipeSys::kFromEnd)
|
||
dDir = ads_angle(GetEndPoint(), GetStartPoint());
|
||
else
|
||
dDir = ads_angle(GetStartPoint(), GetEndPoint());
|
||
XPoint p1;
|
||
ads_polar(ptMid, dDir, GetPScale()*2, p1);
|
||
XPoint ptOffset=p1+offset;
|
||
double dDist1 = ads_distance(ptOffset, GetStartPoint());
|
||
double dDist2 = ads_distance(ptOffset, GetEndPoint());
|
||
if(dDist1 < dDist2)
|
||
SetFlowDir(TPipeSys::kFromEnd);
|
||
else
|
||
SetFlowDir(TPipeSys::kFromStart);
|
||
}
|
||
}
|
||
return es;
|
||
}
|
||
|
||
BOOL TDbPipe::CanMergeWith(const TDbPipePrototype &other, int *iPosThis, int *iPosOther) const
|
||
{
|
||
if(other.isKindOf(TDbPipe::desc())) {
|
||
TDbPipe *pOther=TDbPipe::cast(&other);
|
||
if(fabs(m_dRadius-pOther->m_dRadius)>_distSnap ||
|
||
fabs(m_dDnDiameter-pOther->m_dDnDiameter)>_distSnap)
|
||
return FALSE;
|
||
}
|
||
return TDbPipePrototype::CanMergeWith(other,iPosThis,iPosOther);
|
||
}
|
||
|
||
// 自动增加节点到当前数据库，ids－该节点自动连接的管线，派生类应当重载
|
||
AcDbObjectId TDbPipe::AddAutoNodeToDb(const XPoint &ptAt, const DList<AcDbObjectId> &ids) const
|
||
{
|
||
AcDbObjectId id;
|
||
if(ids.Length()) {
|
||
TDbPipeFitting *pFitting=new TDbPipeFitting;
|
||
pFitting->UpdateLinkage(ptAt, GetSysType(), ids);
|
||
pFitting->setLayer(this->layerId());
|
||
id=AddToCurrentSpace(pFitting, Adesk::kTrue);
|
||
}
|
||
return id;
|
||
}
|
||
|
||
void TDbPipe::DisposeBreak(const XCurveSegment &cv,
|
||
AcGePoint3dArray &arPoint,const XPoint &ptLoc,double dWidth,
|
||
double dDistance,const AcGeVector3d &vtDir, DList<XCurveSegment> &lstBreakCurve) const
|
||
{
|
||
if(Is(CURVE_ARC)){//sr add
|
||
XArc arc2 = GetArc();
|
||
|
||
XPoint pt3, pt4, ptMid;
|
||
arc2.GetStartPoint(pt3);
|
||
arc2.GetEndPoint(pt4);
|
||
|
||
// arc2.GetPoints(pt3, pt4);
|
||
arc2.MidPoint(ptMid);
|
||
pt3.z = 0;
|
||
pt4.z = 0;
|
||
ptMid.z = 0;
|
||
XArc arc(pt3, ptMid, pt4);//先把arc标高设为0
|
||
|
||
double nParam(0);
|
||
XPoint pt1, pt2;
|
||
|
||
|
||
AcDbArc *pArc=new AcDbArc;
|
||
pArc->setCenter(arc.GetCenterPt());
|
||
pArc->setRadius(arc.GetRadius());
|
||
pArc->setStartAngle(arc.GetStarAngle());
|
||
pArc->setEndAngle(arc.GetEndAngle());
|
||
|
||
// cet 2013.1.22 modify 所求点可能不在弧线上
|
||
// pArc->getParamAtPoint(ptLoc, nParam);
|
||
// pArc->getPointAtParam(nParam+dWidth/arc.GetRadius(), pt1);
|
||
// pArc->getPointAtParam(nParam-dWidth/arc.GetRadius(), pt2);
|
||
double dDist = 0.0, dTotalDist = 0.0;
|
||
pArc->getDistAtPoint(ptLoc, dDist);
|
||
AcGePoint3d ptE;
|
||
pArc->getEndPoint(ptE);
|
||
pArc->getDistAtPoint(ptE, dTotalDist);
|
||
if (dDist + dWidth < dTotalDist) // 所求点在弧线上
|
||
{
|
||
pArc->getPointAtDist(dDist + dWidth, pt1);
|
||
}
|
||
else // 所求点不在弧线上
|
||
{
|
||
pt1 = ptE;
|
||
}
|
||
|
||
if (dDist - dWidth > 0.0) // 所求点在弧线上
|
||
{
|
||
pArc->getPointAtDist(dDist - dWidth, pt2);
|
||
}
|
||
else // 所求点不在弧线上
|
||
{
|
||
pArc->getStartPoint(pt2);
|
||
}
|
||
|
||
|
||
delete pArc;
|
||
|
||
// getPointAtParam(nParam+dWidth/arc.radius, pt1);
|
||
// getPointAtParam(nParam-dWidth/arc.radius, pt2);
|
||
// cet 2017.11.13 del 二维显示不需要考虑z值;
|
||
// 其次求最近点也有问题，应该为z轴方向最近点，不然坡度管交点位置可能改变.
|
||
// getClosestPointTo(pt1,pt1);
|
||
// getClosestPointTo(pt2,pt2);
|
||
pt1.z = 0;
|
||
pt2.z = 0;
|
||
arPoint.append((AcGePoint3d)pt1);
|
||
arPoint.append((AcGePoint3d)pt2);
|
||
}
|
||
else{
|
||
XVector3D vtAdd = vtDir * dWidth;
|
||
XPoint ptStart = ptLoc-vtAdd;
|
||
XPoint ptEnd = ptLoc+vtAdd;
|
||
double dStart = cv.PathDistance(ptStart);
|
||
double dEnd = cv.PathDistance(ptEnd);
|
||
// cet 2017.11.13 del 二维显示不需要考虑z值;
|
||
// 其次求最近点也有问题，应该为z轴方向最近点，不然坡度管交点位置可能改变.
|
||
// if(fabs(StartPoint().z - EndPoint().z) < 0.01){
|
||
// getClosestPointTo(ptStart,ptStart);
|
||
// getClosestPointTo(ptEnd,ptEnd);
|
||
// }
|
||
ptStart.z = 0;
|
||
ptEnd.z = 0;
|
||
|
||
if (dStart>0 && dStart<dDistance)
|
||
arPoint.append((AcGePoint3d)ptStart);
|
||
if (dEnd>0 && dEnd<dDistance)
|
||
arPoint.append((AcGePoint3d)ptEnd);
|
||
|
||
XLine line(ptStart, ptEnd, 1);
|
||
XCurveSegment seg;
|
||
seg = line;
|
||
lstBreakCurve.Append(new XCurveSegment(seg));
|
||
}
|
||
}
|
||
|
||
//之前采用AOL求交，在坐标太大的情况下，计算失误。 sr 2007-5-9
|
||
BOOL Intersection2Curve(XCurveSegment &cvPipe1, XCurveSegment &cvPipe2, XPoint &ptIntersect)
|
||
{
|
||
cvPipe1.SetElevation(0);
|
||
cvPipe2.SetElevation(0);
|
||
AcDbCurve *pCurve1 = cvPipe1.AsAcDbCurve();
|
||
AcDbCurve *pCurve2 = cvPipe2.AsAcDbCurve();
|
||
AcGePoint3dArray points;
|
||
Acad::ErrorStatus es = pCurve1->intersectWith(pCurve2, AcDb::kOnBothOperands, points);
|
||
delete pCurve1;
|
||
delete pCurve2;
|
||
int numPoints=points.length();
|
||
if(numPoints == 1){ //有1个交点
|
||
ptIntersect = points[0];
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
/*
|
||
// 通过管件附件打断的曲线，二维，z＝0
|
||
void TDbPipe::GetBrokenCurves(const XCurveSegment &cv,
|
||
DList<XCurveSegment> &lstCurve) const
|
||
{
|
||
int nAttach = m_lstAttachment.Length();
|
||
int nHide = m_lstHidePipe.Length();
|
||
|
||
if (nAttach<=0 && nHide<=0){ //没有管件附件
|
||
lstCurve.Append(new XCurveSegment(cv));
|
||
return;
|
||
}
|
||
|
||
//AcGePoint3dArray arPoint;//裁剪的点
|
||
AcGePoint3dArray arPoint(20);//裁剪的点
|
||
|
||
DList<XPoint> lstLocation;
|
||
DList<XCurveSegment> lstBreakCurve;
|
||
|
||
//double dDisThis = PathDistance(EndPoint());
|
||
double dDisThis = cv.Length();
|
||
|
||
// 直线段时
|
||
//XVector3D vtDir(EndPoint()-StartPoint());//以直线段初始化方向
|
||
XVector3D vtDir(cv.EndPoint()-cv.StartPoint());//以直线段初始化方向
|
||
AcGeVector3d vtAttachment(vtDir);//管线附件在基线上的方向
|
||
vtAttachment.z = 0;
|
||
vtAttachment.normalize();
|
||
|
||
//取得临时管线附件和管件附件的在管线上的端点
|
||
for(int i=0; i<nAttach; i++) {
|
||
const AcDbObjectId &id = m_lstAttachment[i];
|
||
OPENOBJ_BEGIN(id,AcDb::kForRead,TDbPipeAttachment,pAttachment);
|
||
if(pAttachment!=NULL) {
|
||
if(pAttachment->IsCheckSysType() && pAttachment->GetSysType()!=GetSysType())
|
||
continue;
|
||
double dWidth = pAttachment->GetWidth()/2;
|
||
double dScale = pAttachment->GetScale();
|
||
dWidth *= dScale;
|
||
TDbPipeValve *pValve = NULL;
|
||
if(pValve = TDbPipeValve::cast(pAttachment)){
|
||
if(pValve->HasFlange())//如果是带法兰的阀门，宽度要增加法兰厚度
|
||
dWidth += pValve->GetFlangeWidth()*pValve->GetScale()*GetPScale()/100/2;
|
||
}
|
||
if (dWidth>1.0E-3) {
|
||
XPoint ptLocation(pAttachment->GetLocation());
|
||
ptLocation.z=0;
|
||
lstLocation.Append(new XPoint(ptLocation));
|
||
DisposeBreak(cv,arPoint,ptLocation,dWidth,dDisThis,vtAttachment, lstBreakCurve);
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
// 管线的遮挡关系
|
||
for(int k=0; k<nHide; k++) {
|
||
OPENOBJ_BEGIN(m_lstHidePipe[k],AcDb::kForRead,TDbPipePrototype,pPipe);
|
||
if(pPipe!=NULL && IsPsSystemShow(pPipe->GetSysType())) {
|
||
double dWidth=pPipe->GetBreakWidth()/2; //打断间距，如果是单线管，读取系统变量
|
||
if(pPipe->isKindOf(TDbDoubleLinePipe::desc())){//如果是双线管，按管径和相交角度计算。2007 1 15
|
||
TDbDoubleLinePipe *pDPipe=(TDbDoubleLinePipe *)pPipe;
|
||
AcGeVector3d vt1 = pDPipe->Direction3d().AsAcGeVector3d();
|
||
AcGeVector3d vt2 = this->Direction3d().AsAcGeVector3d();
|
||
double dAng = vt1.angleTo(vt2);
|
||
double dDn = pDPipe->GetDnDiameter();
|
||
dWidth = dDn / sin(dAng) / 2;
|
||
}
|
||
|
||
if(dWidth>1.0E-3) {
|
||
XPoint ptIntersect,ptTemp;
|
||
XCurveSegment cvPipe=*pPipe;
|
||
XCurveSegment cvPipe2 = cv;
|
||
cvPipe.SetElevation(0);//设置标高为0
|
||
// if(cv.Intersection(cvPipe,ptIntersect,ptTemp)) {//AOL 计算不精确
|
||
if(Intersection2Curve(cvPipe2, cvPipe, ptIntersect)) {
|
||
if(fabs(StartPoint().z - EndPoint().z) < 0.01)
|
||
getClosestPointTo(ptIntersect,ptIntersect);
|
||
ptIntersect.z = 0;
|
||
lstLocation.Append(new XPoint(ptIntersect));
|
||
DisposeBreak(cv,arPoint,ptIntersect,dWidth,dDisThis,vtAttachment, lstBreakCurve);
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
|
||
|
||
//按定位点到起点的距离快速排序（由小到大）
|
||
int nCount = arPoint.length();
|
||
if(nCount>1) {
|
||
DList<double> lstDist;// 打断点在曲线段上的距离
|
||
for(int i=0; i<nCount; i++) { // 为提高效率先计算出距离
|
||
XPoint ptTmp = arPoint[i];
|
||
double dDist=cv.PathDistance(arPoint[i]);
|
||
lstDist.Append(new double(dDist));
|
||
}
|
||
for(i=0; i<nCount-1; i++) {
|
||
for(int j=0; j<nCount-1-i; j++) {
|
||
if (*lstDist[j]>*lstDist[j+1]) { //Swap
|
||
lstDist.Swap(j,j+1);
|
||
arPoint.swap(j,j+1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
nCount = arPoint.length();
|
||
|
||
|
||
//得到管线基线，并用管线附件打断管线成AcDbCurve
|
||
AcDbVoidPtrArray arSeg;//裁剪后的曲线段
|
||
TDbPipePrototype pipeCv;
|
||
(XCurveSegment &)pipeCv = cv;
|
||
AcDbCurve *pCurve=pipeCv.GetBaseCurve();
|
||
Acad::ErrorStatus es2 = pCurve->getSplitCurves(arPoint, arSeg);
|
||
if(pCurve && es2 == Acad::eInvalidInput){
|
||
double dTmp = 100000.0 / StartPoint().x;
|
||
AcGeMatrix3d mat;
|
||
mat.setToScaling(dTmp); //之前是固定0.1
|
||
pCurve->transformBy(mat);
|
||
//在某些特殊情况下(坐标太大）， getSplitCurves返回eInvalidInput， 导致管线无法打断， 沈睿2004－5－31
|
||
AcGePoint3dArray arPoint2(20);
|
||
for(int k=0; k<nCount; k++) {
|
||
AcGePoint3d ptCur=arPoint[k];
|
||
ptCur.transformBy(mat);
|
||
pCurve->getClosestPointTo(ptCur, ptCur);
|
||
arPoint2.append(ptCur);
|
||
}
|
||
es2 = pCurve->getSplitCurves(arPoint2, arSeg);
|
||
if(es2 != Acad::eOk) {
|
||
lstCurve.Append(new XCurveSegment(cv));
|
||
if(pCurve)
|
||
delete pCurve;
|
||
return;
|
||
}
|
||
mat.invert();
|
||
nCount = arSeg.length();
|
||
for(k=0; k<nCount; k++) {
|
||
AcDbCurve *pCurve0=(AcDbCurve *)arSeg[k];
|
||
pCurve0->transformBy(mat);
|
||
}
|
||
|
||
|
||
}
|
||
else if(pCurve==NULL || es2!=Acad::eOk) {
|
||
lstCurve.Append(new XCurveSegment(cv));
|
||
if(pCurve)
|
||
delete pCurve;
|
||
return;
|
||
}
|
||
delete pCurve;
|
||
|
||
nCount = arSeg.length();
|
||
int nLocation = lstLocation.Length();
|
||
if(nCount == nLocation*2 + 1) { // 正常情况，奇偶性
|
||
for(int k=0; k<nCount; k=k+2) {
|
||
AcDbCurve *pCurve0=(AcDbCurve *)arSeg[k];
|
||
TDbPipePrototype pipe;
|
||
pipe.SetBaseCurve(pCurve0);
|
||
delete pCurve0;
|
||
|
||
//判断有没有反方向绘制的线段 sr add 2006-1-10
|
||
XCurveSegment *pSeg=new XCurveSegment(pipe.GetCurve());
|
||
XPoint ptCurveS = pSeg->StartPoint();
|
||
XPoint ptCurveE = pSeg->EndPoint();
|
||
BOOL bStartInside = FALSE;
|
||
BOOL bEndInside = FALSE;
|
||
for(int m=0;m<lstBreakCurve.Length();m++){
|
||
XCurveSegment segTmp = *lstBreakCurve[m];
|
||
if(segTmp.Is(CURVE_LINE)){
|
||
XLine lineTmp = segTmp;
|
||
int ret1 = ptCurveS&lineTmp;
|
||
int ret2 = ptCurveE&lineTmp;
|
||
if(ret1 == PR_INSIDE)
|
||
bStartInside = TRUE;
|
||
if(ret2 == PR_INSIDE)
|
||
bEndInside = TRUE;
|
||
}
|
||
}
|
||
if(!bStartInside || !bEndInside)
|
||
lstCurve.Append(pSeg);
|
||
}
|
||
}
|
||
else { // 非正常情况，比如附件的遮挡范围超出基线
|
||
for(int k=0; k<nCount; k++) {
|
||
//转换成AcDbCurve
|
||
AcDbCurve *pCurve0=(AcDbCurve *)arSeg[k];
|
||
TDbPipePrototype pipe;
|
||
pipe.SetBaseCurve(pCurve0);
|
||
delete pCurve0;
|
||
|
||
//转换成XCurveSegment，并判断是否是附件的基线
|
||
XCurveSegment *pSeg=new XCurveSegment(pipe.GetCurve());
|
||
XPoint ptS = pSeg->StartPoint();
|
||
XPoint ptE = pSeg->EndPoint();
|
||
BOOL bAppend=TRUE;
|
||
for (int j=0;j<nLocation; j++) {
|
||
XPoint &pt = *lstLocation[j];
|
||
pt.z = 0;
|
||
int nResult = pt&(*pSeg);
|
||
if (nResult==PR_EDGE || nResult==PR_INSIDE) {
|
||
bAppend = FALSE;
|
||
delete pSeg;
|
||
break;
|
||
}
|
||
}
|
||
if (bAppend) { //添加用来显示的曲线段
|
||
lstCurve.Append(pSeg);
|
||
}
|
||
}
|
||
}
|
||
|
||
if(lstCurve.Length()<=0)
|
||
lstCurve.Append(new XCurveSegment(cv));
|
||
}
|
||
*/
|
||
|
||
// 通过管件附件打断的曲线，二维，z＝0
|
||
// 2010-3-18 SR 增加视口显示的判断
|
||
void TDbPipe::GetBrokenCurves(XExplodeDraw &dc, const XCurveSegment &cv,
|
||
DList<XCurveSegment> &lstCurve) const
|
||
{
|
||
int nAttach = m_lstAttachment.Length();
|
||
int nHide = m_lstHidePipe.Length();
|
||
|
||
if (nAttach<=0 && nHide<=0){ //没有管件附件
|
||
lstCurve.Append(new XCurveSegment(cv));
|
||
return;
|
||
}
|
||
|
||
//AcGePoint3dArray arPoint;//裁剪的点
|
||
AcGePoint3dArray arPoint(20);//裁剪的点
|
||
|
||
DList<XPoint> lstLocation;
|
||
DList<XCurveSegment> lstBreakCurve;
|
||
|
||
//double dDisThis = PathDistance(EndPoint());
|
||
double dDisThis = cv.GetLength();
|
||
|
||
// 直线段时
|
||
//XVector3D vtDir(EndPoint()-StartPoint());//以直线段初始化方向
|
||
XVector3D vtDir(cv.EndPoint()-cv.StartPoint());//以直线段初始化方向
|
||
AcGeVector3d vtAttachment(vtDir);//管线附件在基线上的方向
|
||
vtAttachment.z = 0;
|
||
vtAttachment.normalize();
|
||
|
||
//取得临时管线附件和管件附件的在管线上的端点
|
||
for(int i=0; i<nAttach; i++) {
|
||
const AcDbObjectId &id = m_lstAttachment[i];
|
||
OPENOBJ_BEGIN(id,AcDb::kForRead,TDbPipeAttachment,pAttachment);
|
||
if(pAttachment!=NULL) {
|
||
if(pAttachment->IsCheckSysType() && pAttachment->GetSysType()!=GetSysType())
|
||
continue;
|
||
double dWidth = pAttachment->GetWidth()/2;
|
||
double dScale = pAttachment->GetScale();
|
||
dWidth *= dScale;
|
||
TDbPipeValve *pValve = NULL;
|
||
if(pValve = TDbPipeValve::cast(pAttachment)){
|
||
if(pValve->HasFlange())//如果是带法兰的阀门，宽度要增加法兰厚度
|
||
dWidth += pValve->GetFlangeWidth()*pValve->GetScale()*GetPScale()/100/2;
|
||
}
|
||
if (dWidth>1.0E-3) {
|
||
XPoint ptLocation(pAttachment->GetLocation());
|
||
ptLocation.z=0;
|
||
lstLocation.Append(new XPoint(ptLocation));
|
||
DisposeBreak(cv,arPoint,ptLocation,dWidth,dDisThis,vtAttachment, lstBreakCurve);
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
XAcGiViewDraw &viewDraw = (XAcGiViewDraw &)dc;
|
||
// 管线的遮挡关系
|
||
for(int k=0; k<nHide; k++) {
|
||
OPENOBJ_BEGIN(m_lstHidePipe[k],AcDb::kForRead,TDbPipePrototype,pPipe);
|
||
if(pPipe!=NULL && IsVisibleEntity(pPipe))
|
||
{
|
||
AcDbObjectId idLay = pPipe->layerId();
|
||
if(viewDraw.m_pVd != NULL && _tcsicmp(dc.Desc(), XExplodeStream::Descriptor())!=0)
|
||
{
|
||
BOOL bFlag = viewDraw.m_pVd->viewport().layerVisible(idLay);// 2010-3-18 sr 增加考虑遮挡管线所在的图层是否被冻结
|
||
if(!bFlag)
|
||
continue;
|
||
}
|
||
|
||
|
||
double dWidth=pPipe->GetBreakWidth()/2; //打断间距，如果是单线管，读取系统变量
|
||
if(pPipe->isKindOf(TDbDoubleLinePipe::desc())){//如果是双线管，按管径和相交角度计算。2007 1 15
|
||
TDbDoubleLinePipe *pDPipe=(TDbDoubleLinePipe *)pPipe;
|
||
AcGeVector3d vt1 = pDPipe->Direction3d().AsAcGeVector3d();
|
||
AcGeVector3d vt2 = this->Direction3d().AsAcGeVector3d();
|
||
double dAng = vt1.angleTo(vt2);
|
||
double dDn = pDPipe->GetDnDiameter();
|
||
dWidth = dDn / sin(dAng) / 2;
|
||
}
|
||
|
||
if(dWidth>1.0E-3) {
|
||
XPoint ptIntersect,ptTemp;
|
||
XCurveSegment cvPipe=*pPipe;
|
||
XCurveSegment cvPipe2 = cv;
|
||
cvPipe.SetElevation(0);//设置标高为0
|
||
// if(cv.Intersection(cvPipe,ptIntersect,ptTemp)) {//AOL 计算不精确
|
||
if(Intersection2Curve(cvPipe2, cvPipe, ptIntersect)) {
|
||
// cet 2017.11.13 del 二维显示不需要考虑z值;
|
||
// 其次求最近点也有问题，应该为z轴方向最近点，不然坡度管交点位置可能改变.
|
||
// if(fabs(StartPoint().z - EndPoint().z) < 0.01)
|
||
// getClosestPointTo(ptIntersect,ptIntersect);
|
||
ptIntersect.z = 0;
|
||
lstLocation.Append(new XPoint(ptIntersect));
|
||
DisposeBreak(cv,arPoint,ptIntersect,dWidth,dDisThis,vtAttachment, lstBreakCurve);
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
// cet 2013.1.22 add 剔除不在cv上的点, 避免打断时出错 正常情况没有问题，在暖通“弧线管连设备”的时候会造成这样的问题。
|
||
BOOL bArc = cv.Is(CURVE_ARC);
|
||
while(bArc)
|
||
{
|
||
int nLen = arPoint.length();
|
||
XPoint pt;
|
||
int i = 0;
|
||
for (; i < nLen; ++i)
|
||
{
|
||
pt = arPoint[i];
|
||
if ((pt & cv) != PR_INSIDE)
|
||
{
|
||
arPoint.removeAt(i);
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (i >= nLen)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
//按定位点到起点的距离快速排序（由小到大）
|
||
|
||
int nCount = arPoint.length();
|
||
if(nCount>1) {
|
||
DList<double> lstDist;// 打断点在曲线段上的距离
|
||
for(int i=0; i<nCount; i++) { // 为提高效率先计算出距离
|
||
XPoint ptTmp = arPoint[i];
|
||
double dDist=cv.PathDistance(arPoint[i]);
|
||
lstDist.Append(new double(dDist));
|
||
}
|
||
for(i=0; i<nCount-1; i++) {
|
||
for(int j=0; j<nCount-1-i; j++) {
|
||
if (*lstDist[j]>*lstDist[j+1]) { //Swap
|
||
lstDist.Swap(j,j+1);
|
||
arPoint.swap(j,j+1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
nCount = arPoint.length();
|
||
|
||
|
||
//得到管线基线，并用管线附件打断管线成AcDbCurve
|
||
AcDbVoidPtrArray arSeg;//裁剪后的曲线段
|
||
TDbPipePrototype pipeCv;
|
||
(XCurveSegment &)pipeCv = cv;
|
||
AcDbCurve *pCurve=pipeCv.GetBaseCurve();
|
||
Acad::ErrorStatus es2 = pCurve->getSplitCurves(arPoint, arSeg);
|
||
if(pCurve && es2 == Acad::eInvalidInput){
|
||
double dTmp = 100000.0 / StartPoint().x;
|
||
AcGeMatrix3d mat;
|
||
mat.setToScaling(dTmp); //之前是固定0.1
|
||
pCurve->transformBy(mat);
|
||
//在某些特殊情况下(坐标太大）， getSplitCurves返回eInvalidInput， 导致管线无法打断， 沈睿2004－5－31
|
||
AcGePoint3dArray arPoint2(20);
|
||
for(int k=0; k<nCount; k++) {
|
||
AcGePoint3d ptCur=arPoint[k];
|
||
ptCur.transformBy(mat);
|
||
pCurve->getClosestPointTo(ptCur, ptCur);
|
||
arPoint2.append(ptCur);
|
||
}
|
||
es2 = pCurve->getSplitCurves(arPoint2, arSeg);
|
||
if(es2 != Acad::eOk) {
|
||
lstCurve.Append(new XCurveSegment(cv));
|
||
if(pCurve)
|
||
delete pCurve;
|
||
return;
|
||
}
|
||
mat.invert();
|
||
nCount = arSeg.length();
|
||
for(k=0; k<nCount; k++) {
|
||
AcDbCurve *pCurve0=(AcDbCurve *)arSeg[k];
|
||
pCurve0->transformBy(mat);
|
||
}
|
||
|
||
|
||
}
|
||
else if(pCurve==NULL || es2!=Acad::eOk) {
|
||
lstCurve.Append(new XCurveSegment(cv));
|
||
if(pCurve)
|
||
delete pCurve;
|
||
return;
|
||
}
|
||
delete pCurve;
|
||
|
||
nCount = arSeg.length();
|
||
int nLocation = lstLocation.Length();
|
||
if(nCount == nLocation*2 + 1) { // 正常情况，奇偶性
|
||
for(int k=0; k<nCount; k=k+2) {
|
||
AcDbCurve *pCurve0=(AcDbCurve *)arSeg[k];
|
||
TDbPipePrototype pipe;
|
||
pipe.SetBaseCurve(pCurve0);
|
||
delete pCurve0;
|
||
|
||
//判断有没有反方向绘制的线段 sr add 2006-1-10
|
||
XCurveSegment *pSeg=new XCurveSegment(pipe.GetCurve());
|
||
XPoint ptCurveS = pSeg->StartPoint();
|
||
XPoint ptCurveE = pSeg->EndPoint();
|
||
BOOL bStartInside = FALSE;
|
||
BOOL bEndInside = FALSE;
|
||
for(int m=0;m<lstBreakCurve.Length();m++){
|
||
XCurveSegment segTmp = *lstBreakCurve[m];
|
||
if(segTmp.Is(CURVE_LINE)){
|
||
XLine lineTmp = segTmp;
|
||
int ret1 = ptCurveS&lineTmp;
|
||
int ret2 = ptCurveE&lineTmp;
|
||
if(ret1 == PR_INSIDE)
|
||
bStartInside = TRUE;
|
||
if(ret2 == PR_INSIDE)
|
||
bEndInside = TRUE;
|
||
}
|
||
}
|
||
if(!bStartInside || !bEndInside)
|
||
lstCurve.Append(pSeg);
|
||
}
|
||
}
|
||
else { // 非正常情况，比如附件的遮挡范围超出基线
|
||
for(int k=0; k<nCount; k++) {
|
||
//转换成AcDbCurve
|
||
AcDbCurve *pCurve0=(AcDbCurve *)arSeg[k];
|
||
TDbPipePrototype pipe;
|
||
pipe.SetBaseCurve(pCurve0);
|
||
delete pCurve0;
|
||
|
||
//转换成XCurveSegment，并判断是否是附件的基线
|
||
XCurveSegment *pSeg=new XCurveSegment(pipe.GetCurve());
|
||
XPoint ptS = pSeg->StartPoint();
|
||
XPoint ptE = pSeg->EndPoint();
|
||
BOOL bAppend=TRUE;
|
||
for (int j=0;j<nLocation; j++) {
|
||
XPoint &pt = *lstLocation[j];
|
||
pt.z = 0;
|
||
int nResult = pt&(*pSeg);
|
||
if (nResult==PR_EDGE || nResult==PR_INSIDE) {
|
||
bAppend = FALSE;
|
||
delete pSeg;
|
||
break;
|
||
}
|
||
}
|
||
if (bAppend) { //添加用来显示的曲线段
|
||
lstCurve.Append(pSeg);
|
||
}
|
||
}
|
||
}
|
||
|
||
if(lstCurve.Length()<=0)
|
||
lstCurve.Append(new XCurveSegment(cv));
|
||
}
|
||
|
||
// 立管遮挡管线的长度
|
||
double TDbPipe::GetVerPipeHideLength(const TDbPipeNode* pNode) const
|
||
{
|
||
double dLength=0;
|
||
int nCount=pNode->GetInterfaceNum();
|
||
for(int i=0; i<nCount; i++){
|
||
const AcDbObjectId &id=pNode->GetIPipe(i);
|
||
if(id != objectId()) {
|
||
OPENOBJ_BEGIN(id,AcDb::kForRead,TDbPipe,pPipe);
|
||
if(pPipe != NULL) {
|
||
if(pPipe->IsVerLowNode(pNode->objectId())) {
|
||
// if(GetPScale() < 60)//大样立管按管径 2007－1－31 取消
|
||
// dLength = pPipe->GetDnDiameter()/2;
|
||
// else
|
||
dLength = pPipe->GetRadius()*GetPScale();
|
||
break;
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
return dLength;
|
||
}
|
||
|
||
void TDbPipe::ResetDrawSpeed()
|
||
{
|
||
assertWriteEnabled();
|
||
double dSpeedLength=0, dSpeedSubMid=0;//初始化
|
||
|
||
OPENOBJ_BEGIN(m_nodeEnd.m_idNode,AcDb::kForRead,TDbPipeNode,pNode);
|
||
if(pNode!=NULL) {
|
||
if (pNode->IsHidePipe()) { //是否节点遮挡管线
|
||
double dWidth = pNode->GetWidth(this);
|
||
if (dWidth>1.0E-3) {
|
||
dSpeedLength -= dWidth;
|
||
dSpeedSubMid -= dWidth/2;
|
||
}
|
||
} else { //是否立管遮挡管线
|
||
double dVerLen=GetVerPipeHideLength(pNode);
|
||
if(dVerLen>1.0E-3) {
|
||
dSpeedLength -= dVerLen;
|
||
dSpeedSubMid -= dVerLen/2;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
OPENOBJ_BEGIN(m_nodeStart.m_idNode,AcDb::kForRead,TDbPipeNode,pNode);
|
||
if (pNode!=NULL) {
|
||
if (pNode->IsHidePipe()) {
|
||
double dWidth = pNode->GetWidth(this);
|
||
if (dWidth>1.0E-3) {
|
||
dSpeedLength -= dWidth;
|
||
dSpeedSubMid += dWidth/2;
|
||
}
|
||
} else { //是否立管遮挡管线
|
||
double dVerLen=GetVerPipeHideLength(pNode);
|
||
if(dVerLen>1.0E-3) {
|
||
dSpeedLength -= dVerLen;
|
||
dSpeedSubMid += dVerLen/2;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
if(fabs(dSpeedLength)>1.0E-3 || fabs(dSpeedSubMid)>1.0E-3) {
|
||
XCurveSegment cv=GetCurve();
|
||
cv.SetElevation(0);//设置为二维，z＝0
|
||
double dLength = cv.GetLength();
|
||
m_dSpeedLength = dLength + dSpeedLength; //最终曲线的长度(如果是弧，就是弧长）
|
||
m_dSpeedSubMid = dLength/2 + dSpeedSubMid; //起点偏移到最终曲线中点的距离
|
||
if(cv.Is(CURVE_ARC)) // 2008-10-10 sr加入以下5行，弧管连接立管，遮挡错误。并补充GetHideCurve注释
|
||
{
|
||
if(cv.StartPoint() != StartPoint()) //如果弧反了，起点终点互换
|
||
m_dSpeedSubMid = dLength/2 - dSpeedSubMid;
|
||
}
|
||
} else {
|
||
m_dSpeedLength = 0;
|
||
m_dSpeedSubMid = 0;
|
||
}
|
||
}
|
||
|
||
void TDbPipe::ResetDrawSpeed(TDbPipeNode *pModifyNode)
|
||
{
|
||
if (pModifyNode == NULL)
|
||
{
|
||
return ResetDrawSpeed();
|
||
}
|
||
// 端点遮挡长度
|
||
assertWriteEnabled();
|
||
double dSpeedLength=0, dSpeedSubMid=0;//初始化
|
||
// 终点遮挡长度
|
||
bool bFlag = false;
|
||
OPENOBJ_BEGIN(m_nodeEnd.m_idNode,AcDb::kForRead,TDbPipeNode,pNode);
|
||
if(pNode!=NULL) {
|
||
bFlag = true;
|
||
if (pNode->IsHidePipe()) { //是否节点遮挡管线
|
||
double dWidth = pNode->GetWidth(this);
|
||
if (dWidth>1.0E-3) {
|
||
dSpeedLength -= dWidth;
|
||
dSpeedSubMid -= dWidth/2;
|
||
}
|
||
} else { //是否立管遮挡管线
|
||
double dVerLen=GetVerPipeHideLength(pNode);
|
||
if(dVerLen>1.0E-3) {
|
||
dSpeedLength -= dVerLen;
|
||
dSpeedSubMid -= dVerLen/2;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
if (!bFlag && pModifyNode->objectId() == m_nodeEnd.m_idNode)
|
||
{
|
||
TDbPipeNode *pNode = pModifyNode;
|
||
if (pNode->IsHidePipe()) { //是否节点遮挡管线
|
||
double dWidth = pNode->GetWidth(this);
|
||
if (dWidth>1.0E-3) {
|
||
dSpeedLength -= dWidth;
|
||
dSpeedSubMid -= dWidth/2;
|
||
}
|
||
} else { //是否立管遮挡管线
|
||
double dVerLen=GetVerPipeHideLength(pNode);
|
||
if(dVerLen>1.0E-3) {
|
||
dSpeedLength -= dVerLen;
|
||
dSpeedSubMid -= dVerLen/2;
|
||
}
|
||
}
|
||
}
|
||
// 起点遮挡长度
|
||
bFlag = false;
|
||
OPENOBJ_BEGIN(m_nodeStart.m_idNode,AcDb::kForRead,TDbPipeNode,pNode);
|
||
if (pNode!=NULL) {
|
||
bFlag = true;
|
||
if (pNode->IsHidePipe()) {
|
||
double dWidth = pNode->GetWidth(this);
|
||
if (dWidth>1.0E-3) {
|
||
dSpeedLength -= dWidth;
|
||
dSpeedSubMid += dWidth/2;
|
||
}
|
||
} else { //是否立管遮挡管线
|
||
double dVerLen=GetVerPipeHideLength(pNode);
|
||
if(dVerLen>1.0E-3) {
|
||
dSpeedLength -= dVerLen;
|
||
dSpeedSubMid += dVerLen/2;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
if (!bFlag && pModifyNode->objectId() == m_nodeStart.m_idNode)
|
||
{
|
||
TDbPipeNode *pNode = pModifyNode;
|
||
if (pNode->IsHidePipe()) {
|
||
double dWidth = pNode->GetWidth(this);
|
||
if (dWidth>1.0E-3) {
|
||
dSpeedLength -= dWidth;
|
||
dSpeedSubMid += dWidth/2;
|
||
}
|
||
} else { //是否立管遮挡管线
|
||
double dVerLen=GetVerPipeHideLength(pNode);
|
||
if(dVerLen>1.0E-3) {
|
||
dSpeedLength -= dVerLen;
|
||
dSpeedSubMid += dVerLen/2;
|
||
}
|
||
}
|
||
}
|
||
// 更新管道长度数据
|
||
if(fabs(dSpeedLength)>1.0E-3 || fabs(dSpeedSubMid)>1.0E-3)
|
||
{
|
||
XCurveSegment cv=GetCurve();
|
||
cv.SetElevation(0);//设置为二维，z＝0
|
||
double dLength = cv.GetLength();
|
||
m_dSpeedLength = dLength + dSpeedLength; //最终曲线的长度(如果是弧，就是弧长）
|
||
m_dSpeedSubMid = dLength/2 + dSpeedSubMid; //起点偏移到最终曲线中点的距离
|
||
if(cv.Is(CURVE_ARC)) // 2008-10-10 sr加入以下5行，弧管连接立管，遮挡错误。并补充GetHideCurve注释
|
||
{
|
||
if(cv.StartPoint() != StartPoint()) //如果弧反了，起点终点互换
|
||
m_dSpeedSubMid = dLength/2 - dSpeedSubMid;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
m_dSpeedLength = 0;
|
||
m_dSpeedSubMid = 0;
|
||
}
|
||
}
|
||
|
||
// 考虑遮挡的当前曲线，二维，z＝0
|
||
void TDbPipe::GetHideCurve(XCurveSegment& cvHide) const
|
||
{
|
||
XCurveSegment cvHideTemp=GetCurve();
|
||
cvHideTemp.SetElevation(0);//设置为二维，z＝0
|
||
|
||
//该为将数据写入数据库加速二维显示速度
|
||
if (fabs(m_dSpeedLength)>1.0E-3 && fabs(m_dSpeedSubMid)>1.0E-3) {
|
||
//1. 如果是弧管，由弧长（最后实际画的长度m_dSpeedLength）得到眩长
|
||
double dChordLength = cvHideTemp.GetChordLength(m_dSpeedLength);
|
||
XPointDir2d ptSubMid;
|
||
//2. 已知起点偏移到最终曲线中点的距离，得到中点
|
||
cvHideTemp.Polar(m_dSpeedSubMid,ptSubMid);
|
||
//3. 根据中点，和最终曲线的长度（玄长），得到最终曲线
|
||
cvHideTemp.GetSubSegment(ptSubMid,dChordLength,cvHide);
|
||
return;
|
||
}
|
||
|
||
cvHide = cvHideTemp;
|
||
}
|
||
|
||
BOOL TDbPipe::GetVerOpenedType(XVector3D &vtDir, int &nOpenType) const
|
||
{
|
||
BOOL bRet=FALSE;
|
||
const AcDbObjectId& idNode=GetVerUpNode();
|
||
OPENOBJ_BEGIN(idNode,AcDb::kForRead,TDbPipeNode,pNode);
|
||
if(pNode!=NULL)
|
||
{
|
||
int nPipeNum=pNode->GetInterfaceNum();
|
||
if(nPipeNum == 2)
|
||
{
|
||
for(int i=0; i<nPipeNum; i++)
|
||
{
|
||
const AcDbObjectId &id=pNode->GetIPipe(i);
|
||
if(id != objectId())
|
||
{
|
||
OPENOBJ_BEGIN(id,AcDb::kForRead,TDbPipePrototype,pPipe);
|
||
if(pPipe != NULL)
|
||
{
|
||
if(!pPipe->IsVertical())
|
||
{
|
||
AcDbObjectId idStart=pPipe->GetNode(0);
|
||
if(idStart==idNode)
|
||
vtDir=pPipe->GetDirection();
|
||
else
|
||
vtDir=pPipe->StartPoint()-pPipe->EndPoint();
|
||
bRet = TRUE;
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
}
|
||
else if (nPipeNum == 3)
|
||
{
|
||
nOpenType = 1;
|
||
std::vector<AcGeVector3d> vecDir;
|
||
for(int i=0; i<nPipeNum; i++)
|
||
{
|
||
const AcDbObjectId &id=pNode->GetIPipe(i);
|
||
if(id != objectId())
|
||
{
|
||
OPENOBJ_BEGIN(id,AcDb::kForRead,TDbPipePrototype,pPipe);
|
||
if(pPipe != NULL)
|
||
{
|
||
if(!pPipe->IsVertical())
|
||
{
|
||
AcDbObjectId idStart=pPipe->GetNode(0);
|
||
if(idStart==idNode)
|
||
vtDir=pPipe->GetDirection();
|
||
else
|
||
vtDir=pPipe->StartPoint()-pPipe->EndPoint();
|
||
|
||
vecDir.push_back(vtDir);
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
if (vecDir.size() > 1 && vecDir[0].isParallelTo(vecDir[1]))
|
||
{
|
||
bRet = TRUE;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
return bRet;
|
||
}
|
||
|
||
// 绘制平面立管
|
||
Acad::ErrorStatus TDbPipe::DrawVerPipe2d(XExplodeDraw &dc) const
|
||
{
|
||
XVector3D vtDirection(1,0,0);
|
||
|
||
// BOOL bVerOpened=IsVerOpened() && GetVerOpenDir(vtDirection);//扣弯
|
||
int nOpenType = 0;// 立管扣弯开口方式，0:单侧开口 1:两侧开口 zxl 2012.10.24 modify
|
||
BOOL bVerOpened=IsVerOpened() && GetVerOpenedType(vtDirection, nOpenType);//扣弯
|
||
|
||
double nRadius = m_dRadius*GetPScale();
|
||
double nRadiusIn = m_dRadiusIn*GetPScale();
|
||
|
||
//比例小于60的按大样图，立管直径按管径 20061229取消
|
||
// if(GetPScale() < 60){
|
||
// nRadius = m_dDnDiameter/2;
|
||
// if(nRadiusIn > 0.01)
|
||
// nRadiusIn = nRadius/2;
|
||
// }
|
||
|
||
if(bVerOpened) {//绘制扣弯
|
||
XPoint ptCenter(GetStartPoint().x,GetEndPoint().y);
|
||
double dAngle = ads_angle(XPoint(),vtDirection);
|
||
double dStartAngle = CT_std_angle(dAngle+PI/4);
|
||
double dEndAngle = CT_std_angle(dAngle+PI*7/4);
|
||
// zxl 2012.10.24 modify 增加一种扣弯样式
|
||
// XArc arc(ptCenter, nRadius, dStartAngle, dEndAngle);
|
||
// dc << arc;
|
||
if (nOpenType == 0)
|
||
{
|
||
XArc arc(ptCenter, nRadius, dStartAngle, dEndAngle);
|
||
dc << arc;
|
||
}
|
||
else if (nOpenType == 1)
|
||
{
|
||
double dMiddleAngle1 = CT_std_angle(dAngle+PI*3/4);
|
||
double dMiddleAngle2 = CT_std_angle(dAngle+PI*5/4);
|
||
XArc arc1(ptCenter, nRadius, dStartAngle, dMiddleAngle1);
|
||
dc << arc1;
|
||
XArc arc2(ptCenter, nRadius, dMiddleAngle2, dEndAngle);
|
||
dc << arc2;
|
||
}
|
||
}
|
||
else {
|
||
XPoint ptCenter(GetStartPoint().x,GetEndPoint().y);
|
||
XCircle cirOut(ptCenter,nRadius);
|
||
if(nRadiusIn>1.0E-3) { //绘制双圆圈 >0
|
||
XCircle cirIn(ptCenter,nRadiusIn);
|
||
dc << cirOut << cirIn;
|
||
}
|
||
else if(fabs(m_dRadiusIn+1)<=1.0E-3) { //－1时实心
|
||
XCurveSegment seg;
|
||
seg=cirOut;
|
||
XPoly2D poly,polyDisperse;
|
||
seg.AsPoly2D(poly);
|
||
poly.Disperse(polyDisperse); // cet 2017.9.8 modify 半径太小时，原函数出错
|
||
if(dc.IsPlotGeneration()) //02 04 打印预览崩溃，改绘制多个圆
|
||
{
|
||
dc.DrawHatch(polyDisperse, _T("LINE"), 1);
|
||
}
|
||
else
|
||
{
|
||
dc.DrawSolid(polyDisperse);
|
||
}
|
||
}
|
||
else if(fabs(m_dRadiusIn+3)<=1.0E-3) { //－3绘制粗圆圈
|
||
cirOut.SetRadius((m_dRadius - m_dPipeWeight * 0.25)*GetPScale()); // cet 2011.4.20 add 使圆加粗部分都在圆内
|
||
XCurveSegment seg;
|
||
seg=cirOut;
|
||
XPoly2D poly,polyDisperse;
|
||
seg.AsPoly2D(poly);
|
||
AcDbPolyline pline;
|
||
PolyConvert(poly, pline);
|
||
// cet 2011.4.20 modify 使圆加粗部分都在圆内, 粗度值为m_dPipeWeight一半
|
||
//DrawWeight(dc,GetPScale()*m_dPipeWeight,pline);
|
||
DrawWeight(dc,GetPScale()*m_dPipeWeight * 0.5,pline);
|
||
}
|
||
else {
|
||
dc << cirOut;
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
// 绘制平面水平管
|
||
Acad::ErrorStatus TDbPipe::DrawHorPipe2d(XExplodeDraw &dc, BOOL bIsWeight) const
|
||
{
|
||
XCurveSegment cvHide;//二维，z＝0
|
||
GetHideCurve(cvHide);
|
||
DList<XCurveSegment> lstCurve;
|
||
if (IsPsBreakPipe(this->database())) {//打断
|
||
GetBrokenCurves(dc, cvHide,lstCurve);
|
||
} else {
|
||
lstCurve.Append(new XCurveSegment(cvHide));
|
||
}
|
||
int nCount = lstCurve.Length();
|
||
|
||
//动态预览 2009-8-18 sr add (wyg 修改随块颜色打印崩溃) 前1个判断是放在explode调用
|
||
if(_tcsicmp(dc.Desc(), XExplodeStream::Descriptor())!=0 && !objectId().isValid())
|
||
{
|
||
XAcGiViewDraw &dcDraw = (XAcGiViewDraw&)dc;
|
||
dcDraw.GetCommonDraw()->subEntityTraits().setColor(this->colorIndex());
|
||
}
|
||
|
||
// cet 2012.12.18 add 用户选择线性比例大小设置
|
||
double nScale = 0;
|
||
if (IsRelatePipeLineTypeToCurPScale())
|
||
{
|
||
nScale = GetPScale()/100*linetypeScale();
|
||
}
|
||
else
|
||
{
|
||
nScale = linetypeScale();
|
||
}
|
||
|
||
for (int i=0; i<nCount; i++) {
|
||
XCurveSegment &seg = *lstCurve[i];
|
||
if (bIsWeight) {
|
||
double dWeight = GetPScale()*m_dPipeWeight;
|
||
// double nScale = linetypeScale();
|
||
// cet 2012.12.18 del 用户选择是否随管线比例变化
|
||
// double nScale = GetPScale()/100*linetypeScale(); //SR 2012-6-19 支持线型比例随对象比例发生变化
|
||
DrawWeight(dc,dWeight,seg,colorIndex(), nScale);
|
||
} else {
|
||
//2005/2/25 modify sr 管线支持比例因子，由于DC不直接支持，所以通过修改dc内部参数实现
|
||
//其中，绘制是修改DC环境参数，必须先执行，炸开是直接修改新生成的实体，所以后执行
|
||
if(_tcsicmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) {
|
||
XAcGiViewDraw &dcDraw = (XAcGiViewDraw&)dc;
|
||
// cet 2012.12.18 del 用户选择是否随管线比例变化
|
||
// dcDraw.GetCommonDraw()->subEntityTraits().setLineTypeScale(GetPScale()/100*linetypeScale());// SR 2012-6-19 支持线型比例随对象比例发生变化
|
||
dcDraw.GetCommonDraw()->subEntityTraits().setLineTypeScale(nScale);
|
||
}
|
||
|
||
|
||
dc << seg;
|
||
|
||
if(_tcsicmp(dc.Desc(), XAcGiViewDraw::Descriptor())!=0 && dc.IsFullExplode())
|
||
{ //自定义实体炸开
|
||
XExplodeStream &dcDraw = (XExplodeStream&)dc;
|
||
AcDbVoidPtrArray *pEntSet = dcDraw.GetEntitySet();
|
||
if(pEntSet != NULL && 0 != pEntSet->length())
|
||
{
|
||
AcDbEntity *pEnt = (AcDbEntity *)(pEntSet->last());
|
||
if(pEnt != NULL)
|
||
{
|
||
// cet 2012.12.18 del 用户选择是否随管线比例变化
|
||
// double nScale = GetPScale()/100*linetypeScale(); //SR 2012-6-19 支持线型比例随对象比例发生变化
|
||
pEnt->setLinetypeScale(nScale);
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
//得到管子实际长度（单位米）
|
||
ads_real TDbPipe::Length() const
|
||
{
|
||
double len = TDbPipePrototype::GetLength();
|
||
if(DocGetMeterUnitDraw())
|
||
{
|
||
XPoint ptS = StartPoint();
|
||
XPoint ptE = EndPoint();
|
||
ptS.z = 0;
|
||
ptE.z = 0;
|
||
// len = ads_distance(ptS, ptE);//2008-11-24 米单位下显示长度是错的，现改为平面投影长度
|
||
//2009.2.16 删除上面的一句，室外坐标米单位下z就是米
|
||
}
|
||
else
|
||
len = len / 1000.0;
|
||
|
||
return len;
|
||
}
|
||
|
||
//得到管子投影长度（单位米）
|
||
ads_real TDbPipe::GetPlanLength() const
|
||
{
|
||
double len(0);
|
||
XPoint ptS = StartPoint();
|
||
XPoint ptE = EndPoint();
|
||
ptS.z = 0;
|
||
ptE.z = 0;
|
||
len = ads_distance(ptS, ptE);//2008-11-24 米单位下显示长度是错的，现改为平面投影长度
|
||
|
||
if(!DocGetMeterUnitDraw())
|
||
len = len / 1000.0;
|
||
return len;
|
||
}
|
||
|
||
|
||
extern CString I2Str(double i);
|
||
|
||
//读扩展数据
|
||
extern CString ReadXdata(Entity ent, const TCHAR*szName);
|
||
extern CString ReadXdata(const AcDbEntity *pEnt, const TCHAR*szName); // cet 2014.6.4 add
|
||
|
||
//写扩展数据
|
||
BOOL WriteXdata(Entity ent, const TCHAR*szName, const TCHAR*szValue)
|
||
{
|
||
AcDbObjectId eId;
|
||
AcDbEntity *pEnt = NULL;
|
||
acdbGetObjectId(eId, ent);
|
||
if(!XSymbolTable(_T("APPID"), szName))
|
||
ads_regapp(szName);
|
||
acdbOpenObject(pEnt, eId, AcDb::kForWrite);
|
||
if(!pEnt)
|
||
return FALSE;
|
||
resbuf *pXData = ads_buildlist(1001, szName, 1000, szValue, NULL);
|
||
pEnt->setXData(pXData);
|
||
ads_relrb(pXData);
|
||
pEnt->close();
|
||
return TRUE;
|
||
}
|
||
|
||
//写扩展数据 cet 2014.6.20 add
|
||
BOOL WriteXdata(AcDbEntity *pEnt, const TCHAR*szName, const TCHAR*szValue)
|
||
{
|
||
if(!XSymbolTable(_T("APPID"), szName))
|
||
ads_regapp(szName);
|
||
if(!pEnt)
|
||
return FALSE;
|
||
resbuf *pXData = ads_buildlist(1001, szName, 1000, szValue, NULL);
|
||
pEnt->setXData(pXData);
|
||
ads_relrb(pXData);
|
||
return TRUE;
|
||
}
|
||
|
||
// 获取管线管径标注字符 zxl 2012.12.17 add
|
||
CString TDbPipe::GetPipeDnDimStr() const
|
||
{
|
||
// cet 2015.3.6 add 标注中的管径类型(标准管径 外径)
|
||
double dDnDiameter = m_dDnDiameter;
|
||
if (DimDnType() == 1) // 外径
|
||
{
|
||
dDnDiameter = OuterDn();
|
||
}
|
||
CString sText;
|
||
int nPrec = 3;
|
||
bool bTrim = true;
|
||
int nDnDimType = GetPipeDnDimType();
|
||
if (nDnDimType == 0)
|
||
{
|
||
return sText;
|
||
}
|
||
else if (nDnDimType == 1)
|
||
{
|
||
if(dDnDiameter>1.0E-3) {
|
||
CString csLable = m_sLabel.cs();
|
||
// zxl 2014.04.03 modify
|
||
//if(csLable.Find(_T("%%c")) > -1 && GetPipeThick() > 0.01)
|
||
ads_name name;
|
||
acdbGetAdsName(name, this->id());
|
||
Entity ent = name;
|
||
int nShow = _tstof(ReadXdata(ent, _T("TG_PIPELABEL_THICK_SHOW")));
|
||
// cet 2018.2.12 modify 精度有损失,外径可能有小数
|
||
// if(nShow == 1 && GetPipeThick() > 0.01)
|
||
// sText.Format(_T("%s%.0fx%.1f"), csLable,dDnDiameter, GetPipeThick());
|
||
// else
|
||
// sText.Format(_T("%s%.0f"), csLable, dDnDiameter);
|
||
if(nShow == 1 && GetPipeThick() > 0.01)
|
||
sText.Format(_T("%s%sx%s"), csLable, DoubleToString(dDnDiameter, nPrec, bTrim), DoubleToString(GetPipeThick(), nPrec, bTrim));
|
||
else
|
||
sText.Format(_T("%s%s"), csLable, DoubleToString(dDnDiameter, nPrec, bTrim));
|
||
}
|
||
}
|
||
else if (nDnDimType == 2)
|
||
{
|
||
// cet 2018.2.12 modify 精度有损失,外径可能有小数
|
||
// sText.Format(_T("%.0f"), dDnDiameter);
|
||
sText.Format(_T("%s"), DoubleToString(dDnDiameter, nPrec, bTrim));
|
||
}
|
||
return sText;
|
||
}
|
||
|
||
// 获取管线长度标注字符 zxl 2012.12.17 add
|
||
CString TDbPipe::GetPipeLenDimStr() const
|
||
{
|
||
int iDimType = GetPipeLenDimType();
|
||
if (iDimType == 0)
|
||
{
|
||
return _T("");
|
||
}
|
||
|
||
int iPre = GetPipeLenPrecision(this->database());
|
||
CString sHead,sFormat;
|
||
sHead.Format(_T("%d"),iPre);
|
||
sFormat = _T("%.") + sHead + _T("f");
|
||
|
||
double len = Length();
|
||
CString csLen;
|
||
csLen.Format(sFormat, len);
|
||
|
||
CString sPipeLen;
|
||
GetDimPipeLen(sPipeLen, iDimType, csLen);
|
||
|
||
return sPipeLen;
|
||
}
|
||
|
||
CString I2Str2(double i)
|
||
{
|
||
CString csText;
|
||
int nTmp = i * 10;
|
||
if (nTmp % 10 == 0)
|
||
{
|
||
csText.Format(_T("%.0f"), i);
|
||
}
|
||
else// 保留小数点后一位
|
||
{
|
||
csText.Format(_T("%.1f"), i);
|
||
}
|
||
return csText;
|
||
}
|
||
|
||
// 获取管线坡度标注字符 zxl 2012.12.17 add
|
||
CString TDbPipe::GetPipeGradienDimtStr() const
|
||
{
|
||
CString csTmp;
|
||
int nDimType = GetPipeGradientDimType();
|
||
|
||
if (nDimType == 0)
|
||
{
|
||
return csTmp;
|
||
}
|
||
else if(nDimType == 1) //i=0.003
|
||
{
|
||
csTmp.Format(_T("i=%s"), I2Str(m_dRadiusIn*1000));
|
||
}
|
||
else if (nDimType == 2)
|
||
{
|
||
csTmp.Format(_T("i=%s‰"), I2Str2(m_dRadiusIn*1000));
|
||
}
|
||
else if (nDimType == 3)
|
||
{
|
||
csTmp.Format(_T("%s"),I2Str(m_dRadiusIn*1000));
|
||
}
|
||
else if (nDimType == 4)
|
||
{
|
||
csTmp.Format(_T("%s‰"), I2Str2(m_dRadiusIn*1000));
|
||
}
|
||
else if(nDimType == 5) //i0.003
|
||
{
|
||
csTmp.Format(_T("i%s"), I2Str(m_dRadiusIn*1000));
|
||
}
|
||
else if (nDimType == 6)
|
||
{
|
||
csTmp.Format(_T("i%s‰"), I2Str2(m_dRadiusIn*1000));
|
||
}
|
||
return csTmp;
|
||
}
|
||
|
||
// 是否为新标注类型 zxl 2012.12.17 add
|
||
bool TDbPipe::IsNewDimType() const
|
||
{
|
||
Adesk::Int16 nType = GetPipeDnDimType();
|
||
if (nType >= 0)
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
CString TDbPipe::GetNewPipeDimStr() const
|
||
{
|
||
CString sDn, sLen, sGradient, sLabel, sNote;
|
||
sDn = GetPipeDnDimStr();
|
||
// cet 2013.2.5 add 标注标高
|
||
if (!sDn.IsEmpty() && IsDimEle())
|
||
{
|
||
double dEle = StartPoint().z;
|
||
if (!DocGetMeterUnitDraw())
|
||
{
|
||
dEle *= 0.001;
|
||
}
|
||
CString sEle;
|
||
sEle.Format(_T("（%.2f）"), dEle);
|
||
sDn += sEle;
|
||
}
|
||
|
||
sLen = GetPipeLenDimStr();
|
||
sGradient = GetPipeGradienDimtStr();
|
||
int nLabelType = GetPipeDimLableType();
|
||
if (nLabelType == 0)
|
||
{
|
||
sNote = _T(" ");
|
||
}
|
||
else if (nLabelType == 1)
|
||
{
|
||
sNote = _T("-");
|
||
}
|
||
else
|
||
{
|
||
sNote = _T("／");
|
||
}
|
||
|
||
if (GetPipeLableDrawType() != 0)
|
||
{
|
||
sNote = _T("\n");
|
||
}
|
||
sLabel = sDn;
|
||
if (!sDn.IsEmpty() && (!sLen.IsEmpty() || !sGradient.IsEmpty()))
|
||
{
|
||
sLabel += sNote;
|
||
}
|
||
|
||
sLabel += sGradient;
|
||
if (!sLen.IsEmpty() && !sGradient.IsEmpty())
|
||
{
|
||
sLabel += sNote;
|
||
sLabel += sLen;
|
||
}
|
||
else if (sGradient.IsEmpty())
|
||
{
|
||
sLabel += sLen;
|
||
}
|
||
|
||
return sLabel;
|
||
}
|
||
|
||
XString TDbPipe::GetLabelText() const
|
||
{
|
||
//添加多联机标注09.11.19 wlw
|
||
if(m_sysType == TPipeSys::kVRVMedia)
|
||
{
|
||
CString sTmp = _T("%%C");
|
||
CString sLabel = m_sLabel.cs(), sGasDn = _T(""),sLiqDn = _T(""),sDGasDn = _T("");
|
||
// change by hh 2014.6.24 冷媒管增加两种分隔符
|
||
CString sSplit = _T(",");
|
||
// int nStr = sLabel.Find(_T(","));
|
||
int nStr = sLabel.Find(sSplit);
|
||
if(0 > nStr)
|
||
{
|
||
sSplit = _T("/");
|
||
nStr = sLabel.Find(sSplit);
|
||
if(0 > nStr)
|
||
{
|
||
sSplit = _T(" ");
|
||
nStr = sLabel.Find(sSplit);
|
||
}
|
||
}
|
||
int nLength = sLabel.GetLength();
|
||
if (nStr < 0)
|
||
return sLabel;
|
||
//液管
|
||
sLiqDn = sLabel.Left(nStr);
|
||
sGasDn = sLabel.Right(nLength - nStr - 1);
|
||
// nStr = sGasDn.Find(_T(","));
|
||
nStr = sGasDn.Find(sSplit);
|
||
nLength = sGasDn.GetLength();
|
||
//气管
|
||
if (nStr < 0)
|
||
{
|
||
// sLabel.Format(_T("%s%s,%s%s"),sTmp,sLiqDn,sTmp,sGasDn);
|
||
sLabel.Format(_T("%s%s%s%s%s"),sTmp,sLiqDn,sSplit,sTmp,sGasDn);
|
||
}
|
||
//低压气管
|
||
else
|
||
{
|
||
CString sGasTmp = sGasDn;
|
||
sGasDn = sGasTmp.Left(nStr);
|
||
sDGasDn = sGasTmp.Right(nLength - nStr - 1);
|
||
// sLabel.Format(_T("%s%s,%s%s,%s%s"),sTmp,sLiqDn,sTmp,sGasDn,sTmp,sDGasDn);
|
||
sLabel.Format(_T("%s%s%s%s%s%s%s%s"),sTmp,sLiqDn,sSplit, sTmp,sGasDn,sSplit,sTmp,sDGasDn);
|
||
}
|
||
return sLabel;
|
||
}
|
||
|
||
// zxl 2012.12.13 add 新标注样式存在时，获取新标注样式
|
||
if (IsNewDimType())
|
||
{
|
||
CString sLabel = GetNewPipeDimStr();
|
||
return sLabel;
|
||
}
|
||
XString sLabel=m_sLabel;
|
||
//if(m_dDnDiameter>1.0E-3) {
|
||
// sLabel << int(m_dDnDiameter); // sr remove it 20070319 ACAD2008崩溃
|
||
//}
|
||
// cet 2015.3.6 add 标注中的管径类型(标准管径 外径)
|
||
double dDnDiameter = m_dDnDiameter;
|
||
if (DimDnType() == 1) // 外径
|
||
{
|
||
dDnDiameter = OuterDn();
|
||
}
|
||
CString csRet;
|
||
if(dDnDiameter>1.0E-3) {
|
||
CString csLable = sLabel.cs();
|
||
// zxl 2014.04.03 add
|
||
ads_name name;
|
||
acdbGetAdsName(name, this->id());
|
||
Entity ent = name;
|
||
int nShow = _tstof(ReadXdata(this, _T("TG_PIPELABEL_THICK_SHOW")));
|
||
if(nShow == 1 && GetPipeThick() > 0.01)//sr 2008-12-16 支持外径x壁厚
|
||
//if(csLable.Find(_T("%%c")) > -1 && GetPipeThick() > 0.01)//sr 2008-12-16 支持外径x壁厚
|
||
csRet.Format(_T("%s%.0fx%.1f"), sLabel,dDnDiameter, GetPipeThick()); //sr 2009-12-28 由m_dRadiusIn改GetPipeThick存储壁厚信息
|
||
else
|
||
csRet.Format(_T("%s%.0f"), sLabel, dDnDiameter);
|
||
|
||
// cet 2013.2.5 add 标注标高
|
||
if (IsDimEle())
|
||
{
|
||
double dEle = StartPoint().z;
|
||
if (!DocGetMeterUnitDraw())
|
||
{
|
||
dEle *= 0.001;
|
||
}
|
||
CString sEle;
|
||
sEle.Format(_T("（%.2f）"), dEle);
|
||
csRet += sEle;
|
||
}
|
||
}
|
||
CString csTmp, csLen;
|
||
double len = Length();
|
||
|
||
int iPre = GetPipeLenPrecision(this->database());
|
||
CString sHead,sFormat;
|
||
sHead.Format(_T("%d"),iPre);
|
||
sFormat = _T("%.") + sHead + _T("f");
|
||
csLen.Format(sFormat, len);
|
||
|
||
/* cet 2011.5.20 modify 调整标注
|
||
if(fabs(m_dSpare - 1.0) < 0.001) //i=0.003L=12.3m
|
||
csTmp.Format(_T(" i=%s L=%sm"),I2Str(m_dRadiusIn*1000), csLen);
|
||
else if(fabs(m_dSpare - 2.0) < 0.001) //-0.003-12.3m
|
||
csTmp.Format(_T("-%s-%sm"),I2Str(m_dRadiusIn*1000), csLen);
|
||
else if(fabs(m_dSpare - 3.0) < 0.001) //0.00312.3m
|
||
csTmp.Format(_T(" %s %sm"),I2Str(m_dRadiusIn*1000), csLen);
|
||
else if(fabs(m_dSpare - 4.0) < 0.001) //i=0.003
|
||
csTmp.Format(_T(" i=%s"),I2Str(m_dRadiusIn*1000));
|
||
else if(fabs(m_dSpare - 5.0) < 0.001) //-0.003
|
||
csTmp.Format(_T("-%s"),I2Str(m_dRadiusIn*1000));
|
||
else if(fabs(m_dSpare - 6.0) < 0.001) //0.003
|
||
csTmp.Format(_T(" %s"),I2Str(m_dRadiusIn*1000));
|
||
else if(fabs(m_dSpare - 7.0) < 0.001) //L=12.3m
|
||
csTmp.Format(_T(" L=%sm"),csLen);
|
||
else if(fabs(m_dSpare - 8.0) < 0.001) //-12.3m
|
||
csTmp.Format(_T("-%sm"),csLen);
|
||
else if(fabs(m_dSpare - 9.0) < 0.001) //12.3m
|
||
csTmp.Format(_T(" %sm"),csLen);
|
||
else if(fabs(m_dSpare - 10.0) < 0.001) //i0.003 L=12.3m
|
||
csTmp.Format(_T(" i%s L%sm"),I2Str(m_dRadiusIn*1000), csLen);
|
||
else if(fabs(m_dSpare - 11.0) < 0.001) // /12.3 cet 2011.4.28 add
|
||
csTmp.Format(_T("／%s"),csLen);
|
||
else if (fabs(m_dSpare - 12.0) < 0.001) // 12.3m cet 2011.5.18 add
|
||
{
|
||
csRet.Empty();
|
||
csTmp.Format(_T("%sm"),csLen);
|
||
}
|
||
else if (fabs(m_dSpare - 13.0) < 0.001) // 12.3 cet 2011.5.18 add
|
||
{
|
||
csRet.Empty();
|
||
csTmp.Format(_T("%s"),csLen);
|
||
}
|
||
*/
|
||
|
||
if (m_dSpare > 100) // 大于100时，十位百位数表示管线长度样式
|
||
{
|
||
int iDimType = static_cast<int>(m_dSpare);
|
||
CString sPipeLen;
|
||
GetDimPipeLen(sPipeLen, iDimType, csLen);
|
||
|
||
--iDimType;
|
||
iDimType /= 100;
|
||
|
||
if(iDimType == 1) //DN500 i=0.003 12.3m
|
||
{
|
||
csTmp.Format(_T(" i=%s "),I2Str(m_dRadiusIn*1000));
|
||
csTmp += sPipeLen;
|
||
}
|
||
else if(iDimType == 2) //DN500-0.003-12.3m
|
||
{
|
||
csTmp.Format(_T("-%s-"),I2Str(m_dRadiusIn*1000));
|
||
csTmp += sPipeLen;
|
||
}
|
||
else if(iDimType == 3) //DN500 0.003 12.3m
|
||
{
|
||
csTmp.Format(_T(" %s "),I2Str(m_dRadiusIn*1000));
|
||
csTmp += sPipeLen;
|
||
}
|
||
else if(iDimType == 4) //DN500 i=0.003
|
||
{
|
||
csTmp.Format(_T(" i=%s"),I2Str(m_dRadiusIn*1000));
|
||
}
|
||
else if(iDimType == 5) //DN500-0.003
|
||
{
|
||
csTmp.Format(_T("-%s"),I2Str(m_dRadiusIn*1000));
|
||
}
|
||
else if(iDimType == 6) //DN500 0.003
|
||
{
|
||
csTmp.Format(_T(" %s"),I2Str(m_dRadiusIn*1000));
|
||
}
|
||
else if(iDimType == 7) //DN500 12.3m
|
||
{
|
||
csTmp = _T(" ");
|
||
csTmp += sPipeLen;
|
||
}
|
||
else if(iDimType == 8) //DN500-12.3m
|
||
{
|
||
csTmp = _T("-");
|
||
csTmp += sPipeLen;
|
||
}
|
||
else if(iDimType == 9) //DN500 i0.003 L=12.3m
|
||
{
|
||
csTmp.Format(_T(" i%s "),I2Str(m_dRadiusIn*1000));
|
||
csTmp += sPipeLen;
|
||
}
|
||
else if(iDimType == 10) //DN500/12.3
|
||
{
|
||
csTmp = _T("／");
|
||
csTmp += sPipeLen;
|
||
}
|
||
else if (iDimType == 11) // 12.3m
|
||
{
|
||
csRet.Empty();
|
||
csTmp += sPipeLen;
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
if(fabs(m_dSpare - 1.0) < 0.001) //i=0.003L=12.3m
|
||
csTmp.Format(_T(" i=%s L=%sm"),I2Str(m_dRadiusIn*1000), csLen);
|
||
else if(fabs(m_dSpare - 2.0) < 0.001) //-0.003-12.3m
|
||
csTmp.Format(_T("-%s-%sm"),I2Str(m_dRadiusIn*1000), csLen);
|
||
else if(fabs(m_dSpare - 3.0) < 0.001) //0.00312.3m
|
||
csTmp.Format(_T(" %s %sm"),I2Str(m_dRadiusIn*1000), csLen);
|
||
else if(fabs(m_dSpare - 4.0) < 0.001) //i=0.003
|
||
csTmp.Format(_T(" i=%s"),I2Str(m_dRadiusIn*1000));
|
||
else if(fabs(m_dSpare - 5.0) < 0.001) //-0.003
|
||
csTmp.Format(_T("-%s"),I2Str(m_dRadiusIn*1000));
|
||
else if(fabs(m_dSpare - 6.0) < 0.001) //0.003
|
||
csTmp.Format(_T(" %s"),I2Str(m_dRadiusIn*1000));
|
||
else if(fabs(m_dSpare - 7.0) < 0.001) //L=12.3m
|
||
csTmp.Format(_T(" L=%sm"),csLen);
|
||
else if(fabs(m_dSpare - 8.0) < 0.001) //-12.3m
|
||
csTmp.Format(_T("-%sm"),csLen);
|
||
else if(fabs(m_dSpare - 9.0) < 0.001) //12.3m
|
||
csTmp.Format(_T(" %sm"),csLen);
|
||
else if(fabs(m_dSpare - 10.0) < 0.001) //i0.003 L=12.3m
|
||
csTmp.Format(_T(" i%s L%sm"),I2Str(m_dRadiusIn*1000), csLen);
|
||
else if(fabs(m_dSpare - 11.0) < 0.001) // /12.3 cet 2011.4.28 add
|
||
csTmp.Format(_T("／%s"),csLen);
|
||
else if (fabs(m_dSpare - 12.0) < 0.001) // 12.3m cet 2011.5.18 add
|
||
{
|
||
csRet.Empty();
|
||
csTmp.Format(_T("%sm"),csLen);
|
||
}
|
||
else if (fabs(m_dSpare - 13.0) < 0.001) // 12.3 cet 2011.5.18 add
|
||
{
|
||
csRet.Empty();
|
||
csTmp.Format(_T("%s"),csLen);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* if(fabs(m_dSpare - 1.0) < 0.001) //i=0.003L=12.3m
|
||
csTmp.Format(_T(" i=%s L=%.2fm"),I2Str(m_dRadiusIn*1000), len);
|
||
else if(fabs(m_dSpare - 2.0) < 0.001) //-0.003-12.3m
|
||
csTmp.Format(_T("-%s-%.2fm"),I2Str(m_dRadiusIn*1000), len);
|
||
else if(fabs(m_dSpare - 3.0) < 0.001) //0.00312.3m
|
||
csTmp.Format(_T(" %s %.2fm"),I2Str(m_dRadiusIn*1000), len);
|
||
else if(fabs(m_dSpare - 4.0) < 0.001) //i=0.003
|
||
csTmp.Format(_T(" i=%s"),I2Str(m_dRadiusIn*1000));
|
||
else if(fabs(m_dSpare - 5.0) < 0.001) //-0.003
|
||
csTmp.Format(_T("-%s"),I2Str(m_dRadiusIn*1000));
|
||
else if(fabs(m_dSpare - 6.0) < 0.001) //0.003
|
||
csTmp.Format(_T(" %s"),I2Str(m_dRadiusIn*1000));
|
||
else if(fabs(m_dSpare - 7.0) < 0.001) //L=12.3m
|
||
csTmp.Format(_T(" L=%.2fm"),len);
|
||
else if(fabs(m_dSpare - 8.0) < 0.001) //-12.3m
|
||
csTmp.Format(_T("-%.2fm"),len);
|
||
else if(fabs(m_dSpare - 9.0) < 0.001) //12.3m
|
||
csTmp.Format(_T(" %.2fm"),len);
|
||
else if(fabs(m_dSpare - 10.0) < 0.001) //i0.003 L=12.3m
|
||
csTmp.Format(_T(" i%s L%.2fm"),I2Str(m_dRadiusIn*1000), len);*/
|
||
|
||
csRet+=csTmp;
|
||
sLabel = (const TCHAR*)csRet;
|
||
|
||
return sLabel;
|
||
}
|
||
|
||
//double TDbPipe::GetMinLabelTextLen() const
|
||
//{
|
||
// double nVal=0.0;
|
||
// TDbText text;
|
||
// text.setPropertiesFrom(this);
|
||
// text.setLayer(m_idLabelLayer);
|
||
// text.SetStyleId(m_idTextStyle);
|
||
// text.SetText(GetLabelText());
|
||
// text.SetRotation(0);
|
||
// text.SetLocation(XPoint(m_ptLabel.x,m_ptLabel.y,0));
|
||
// text.SetHeight(m_dTextHeight);
|
||
// text.SetAlignment(XExplodeDraw::kMiddleCenter);
|
||
// XPoint ptExt=text.GetExtents();
|
||
// nVal=max(nVal, ptExt.x);
|
||
// return nVal;
|
||
|
||
|
||
Acad::ErrorStatus TDbPipe::DrawLabelText(XExplodeDraw &dc) const
|
||
{
|
||
XPoint ptOnThis;
|
||
if(ProjectToMe(m_ptLabel,ptOnThis)) {
|
||
double dRotation=0;
|
||
// cet 2011.8.29 modify 在ucs下考虑角度
|
||
// if(!IsVertical()) {
|
||
// if(Is(CURVE_LINE))
|
||
// dRotation = Direction(ptOnThis);
|
||
// else if(Is(CURVE_ARC)){
|
||
// XPoint ptCenter;
|
||
// GetArc().Center(ptCenter);
|
||
// dRotation = ads_angle(ptCenter, m_ptLabel) + PI/2;
|
||
// }
|
||
// dRotation = CT_std_angle(dRotation);
|
||
// if(fabs(dRotation) < 1e-2)
|
||
// dRotation = 0;
|
||
// if(fabs(dRotation - PI/2) < 1e-2)
|
||
// dRotation = PI/2;
|
||
// if(fabs(dRotation - PI/2*3) < 1e-2)
|
||
// dRotation = PI/2*3;
|
||
//
|
||
// if((dRotation>PI/2 && dRotation<=PI*3/2)) {
|
||
// dRotation = CT_std_angle(dRotation+PI);
|
||
// }
|
||
// }
|
||
|
||
if(!IsVertical()) {
|
||
if(Is(CURVE_LINE))
|
||
{
|
||
dRotation = Direction(ptOnThis);
|
||
dRotation = Wcs2Ucs(dRotation);
|
||
}
|
||
else if(Is(CURVE_ARC)){
|
||
XPoint ptCenter;
|
||
GetArc().Center(ptCenter);
|
||
dRotation = ads_angle(Wcs2Ucs(ptCenter), Wcs2Ucs(m_ptLabel)) + PI/2;
|
||
}
|
||
dRotation = CT_std_angle(dRotation);
|
||
if(fabs(dRotation) < 1e-2)
|
||
dRotation = 0;
|
||
if(fabs(dRotation - PI/2) < 1e-2)
|
||
dRotation = PI/2;
|
||
if(fabs(dRotation - PI/2*3) < 1e-2)
|
||
dRotation = PI/2*3;
|
||
|
||
if((dRotation>PI/2 + 1e-2 && dRotation<=PI*3/2 + 1e-2)) { // cet 2017.3.8 modify 考虑误差影响
|
||
dRotation = CT_std_angle(dRotation+PI);
|
||
}
|
||
|
||
dRotation = Ucs2Wcs(dRotation);
|
||
}
|
||
|
||
AcDbObjectId idLayerOld=dc.GetLayerId();
|
||
// if(m_idLabelLayer.isValid()){
|
||
// dc.SetLayer(m_idLabelLayer);
|
||
// }
|
||
dc.SetLayer(_T("0")); // 文字图层设置失败时，默认0层
|
||
OPENOBJ_BEGIN(m_idLabelLayer, AcDb::kForRead, AcDbLayerTableRecord, pRec);
|
||
if(pRec){
|
||
dc.SetLayer(m_idLabelLayer);
|
||
}
|
||
OPENOBJ_END();
|
||
// zxl 2012.12.13 modify
|
||
// TDbText text;
|
||
//
|
||
// text.setPropertiesFrom(this);
|
||
// text.setLayer(m_idLabelLayer);
|
||
// AcCmColor color;
|
||
// color.setColorIndex(256);
|
||
// text.setColor(color);
|
||
// text.SetStyleId(m_idTextStyle);
|
||
// text.SetText(GetLabelText());
|
||
// text.SetRotation(dRotation);
|
||
// text.SetLocation(XPoint(m_ptLabel.x,m_ptLabel.y,0));
|
||
// text.SetHeight(m_dTextHeight);
|
||
// text.SetAlignment(XExplodeDraw::kMiddleCenter);
|
||
//
|
||
// TPushProperty vProp(&text, dc);
|
||
// if(dc.IsFullExplode())
|
||
// text.ExplodeOrDraw2d(dc);
|
||
// else
|
||
// dc.DrawEntity(text);
|
||
//
|
||
// dc.SetLayer(idLayerOld);
|
||
// cet 2016.4.11 add 文字样式无效时，设置默认样式
|
||
if (!m_idTextStyle.isValid())
|
||
{
|
||
const_cast<AcDbHardPointerId&>(m_idTextStyle) = InitTextStyle(_T("Standard"));
|
||
}
|
||
if (GetPipeLableDrawType() == 0 || !IsNewDimType())// 旧版标注形式或横排
|
||
{
|
||
TDbText text;
|
||
text.setPropertiesFrom(this);
|
||
text.setLayer(dc.GetLayerId()); // 默认图层
|
||
text.setLayer(m_idLabelLayer);
|
||
AcCmColor color;
|
||
// cet 2018.2.1 modify 可修改文字颜色
|
||
// color.setColorIndex(256);
|
||
color.setColorIndex(GetTextColor());
|
||
text.setColor(color);
|
||
text.SetStyleId(m_idTextStyle);
|
||
text.SetText(GetLabelText());
|
||
text.SetRotation(dRotation);
|
||
text.SetLocation(XPoint(m_ptLabel.x,m_ptLabel.y,0));
|
||
text.SetHeight(m_dTextHeight);
|
||
text.SetAlignment(XExplodeDraw::kMiddleCenter);
|
||
|
||
TPushProperty vProp(&text, dc);
|
||
if(dc.IsFullExplode())
|
||
text.ExplodeOrDraw2d(dc);
|
||
else
|
||
dc.DrawEntity(text);
|
||
}
|
||
else// 标注形式为竖排
|
||
{
|
||
// 竖排时获取每行标注字符
|
||
CString sLabel = GetLabelText().cs();
|
||
std::vector<CString> vecText;
|
||
while (!sLabel.IsEmpty())
|
||
{
|
||
int nIndex = sLabel.Find(_T("\n"));
|
||
CString sText;
|
||
if (nIndex > 0)
|
||
{
|
||
sText = sLabel.Left(nIndex);
|
||
sLabel = sLabel.Right(sLabel.GetLength() - nIndex - 1);
|
||
}
|
||
else
|
||
{
|
||
sText = sLabel;
|
||
vecText.push_back(sText);
|
||
break;
|
||
}
|
||
vecText.push_back(sText);
|
||
}
|
||
|
||
// 获取 标注点到管线的向量
|
||
AcGePoint3d ptStart = GetStartPoint(), ptEnd = GetEndPoint();
|
||
ptStart.z = 0;
|
||
ptEnd.z = 0;
|
||
WCS2UCS(ptStart);
|
||
WCS2UCS(ptEnd);
|
||
AcDbLine line(ptStart, ptEnd);
|
||
AcGePoint3d ptLabel(m_ptLabel.x,m_ptLabel.y,0), ptOnLine;
|
||
WCS2UCS(ptLabel);
|
||
Acad::ErrorStatus es = line.getClosestPointTo(ptLabel, ptOnLine, Adesk::kTrue);
|
||
AcGeVector3d vtDir = ptLabel - ptOnLine;
|
||
vtDir.normalize();
|
||
// 标注点和管线中点重合时
|
||
if (ptLabel.distanceTo(ptOnLine) < 0.001)
|
||
{
|
||
vtDir = ptStart - ptEnd;
|
||
vtDir.rotateBy(-PI / 2, AcGeVector3d::kZAxis);
|
||
vtDir.normalize();
|
||
}
|
||
// cet 2018.6.21 del 根据角度调整向量方向由于误差容易导致错误
|
||
// // 标注水平向量
|
||
// AcGeVector3d vtLeft = vtDir;
|
||
// double dAngle = vtLeft.angleTo(AcGeVector3d::kXAxis, AcGeVector3d::kZAxis);
|
||
// // cet 2017.3.8 add 360转化为0度
|
||
// if (abs(dAngle - PI * 2) < 0.001)
|
||
// {
|
||
// dAngle = 0.0;
|
||
// }
|
||
// if (dAngle > PI - 0.001) // cet 2016.12.13 modify 浮点型数据表示大等于时，有误差
|
||
// {
|
||
// vtLeft.rotateBy(PI / 2, AcGeVector3d::kZAxis);
|
||
// }
|
||
// else
|
||
// {
|
||
// vtLeft.rotateBy(-PI / 2, AcGeVector3d::kZAxis);
|
||
// }
|
||
// vtLeft.normalize();
|
||
|
||
// 逐行标注
|
||
std::vector<CString>::reverse_iterator itRev;
|
||
int i = 0;
|
||
for (itRev = vecText.rbegin(); itRev != vecText.rend(); itRev++)
|
||
{
|
||
TDbText text;
|
||
text.setPropertiesFrom(this);
|
||
text.setLayer(dc.GetLayerId()); // 默认图层
|
||
text.setLayer(m_idLabelLayer);
|
||
AcCmColor color;
|
||
// cet 2018.2.1 modify 可修改文字颜色
|
||
// color.setColorIndex(256);
|
||
color.setColorIndex(GetTextColor());
|
||
text.setColor(color);
|
||
text.SetStyleId(m_idTextStyle);
|
||
text.SetText(*itRev);
|
||
text.SetRotation(dRotation);
|
||
text.SetHeight(m_dTextHeight);
|
||
double dLen = 0.0;
|
||
if (i == 0)
|
||
{
|
||
UCS2WCS(ptLabel);
|
||
text.SetLocation(ptLabel);
|
||
WCS2UCS(ptLabel);
|
||
text.SetAlignment(XExplodeDraw::kMiddleCenter);
|
||
text.SetRotation(0.0);
|
||
XPoint ptMin, ptMax;
|
||
text.GetExtents2d(ptMin, ptMax);
|
||
dLen = fabs(ptMax.x - ptMin.x);
|
||
// cet 2018.6.21 modify 将标注点移到左侧
|
||
// ptLabel += vtLeft * dLen / 2;
|
||
AcGeVector3d vtTemp = AcGeVector3d::kXAxis;
|
||
vtTemp.rotateBy(Wcs2Ucs(dRotation + PI), AcGeVector3d::kZAxis);
|
||
ptLabel += vtTemp * dLen * 0.5;
|
||
// cet 2016.9.26 add 批量转旧版（T3）时，外包框获取失败, 并排文字没有对齐
|
||
if (dLen < 0.001)
|
||
{
|
||
text.SetAlignment(XExplodeDraw::kMiddleLeft);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ptLabel += (vtDir * m_dTextHeight * GetPScale() * 4 / 3);
|
||
UCS2WCS(ptLabel);
|
||
text.SetLocation(ptLabel);
|
||
WCS2UCS(ptLabel);
|
||
text.SetAlignment(XExplodeDraw::kMiddleLeft);
|
||
}
|
||
text.SetRotation(dRotation);
|
||
TPushProperty vProp(&text, dc);
|
||
if(dc.IsFullExplode())
|
||
text.ExplodeOrDraw2d(dc);
|
||
else
|
||
dc.DrawEntity(text);
|
||
i++;
|
||
}
|
||
}
|
||
dc.SetLayer(idLayerOld);
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
//管线加粗后，2段管线连接处，ACAD处理不理想，上华来修补；沈睿2004/8/26
|
||
//得到一个管线的下一段管线，必须是Fitting连接的。
|
||
AcDbObjectId GetNextPipe(AcDbObjectId idPipe, AcDbObjectId idNode)
|
||
{
|
||
AcDbObjectId idRet = NULL;
|
||
OPENOBJ_BEGIN(idNode, AcDb::kForRead, TDbPipeFitting, pFitting);
|
||
if(pFitting){
|
||
int num = pFitting->GetInterfaceNum();
|
||
if(num != 2)
|
||
return idRet;
|
||
TPipeInterface face1, face2;
|
||
pFitting->GetInterface(0, face1);
|
||
pFitting->GetInterface(1, face2);
|
||
if(face1.m_idPipe == idPipe)
|
||
idRet = face2.m_idPipe;
|
||
else
|
||
idRet = face1.m_idPipe;
|
||
}
|
||
OPENOBJ_END();
|
||
OPENOBJ_BEGIN(idRet, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe && !pPipe->IsVertical()){
|
||
return idRet;//必须是横管
|
||
}
|
||
OPENOBJ_END();
|
||
return NULL;
|
||
}
|
||
|
||
|
||
void ChamferPipe(AcDbObjectId idPipe, AcDbObjectId idPipeNext, XPoint &ptInt1, XPoint &ptInt2, XPoint &ptInt3)
|
||
{
|
||
if(!idPipeNext)
|
||
return;
|
||
double nWeight(0), nWeightNext(0);
|
||
XPoint pt1, pt2, ptNext1, ptNext2;
|
||
OPENOBJ_BEGIN(idPipe, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
nWeight = pPipe->GetPipeWeight() * pPipe->GetPScale();
|
||
pt1 = pPipe->StartPoint();
|
||
pt2 = pPipe->EndPoint();
|
||
if(fabs(pPipe->GetBulge()) > 0.001)
|
||
return;
|
||
}
|
||
OPENOBJ_END();
|
||
OPENOBJ_BEGIN(idPipeNext, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
nWeightNext = pPipe->GetPipeWeight() * pPipe->GetPScale();
|
||
ptNext1 = pPipe->StartPoint();
|
||
ptNext2 = pPipe->EndPoint();
|
||
if(fabs(pPipe->GetBulge()) > 0.001)
|
||
return;
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
XLine l1(pt1, pt2, 1);
|
||
XLine l2 = l1.Offset(nWeight/2);
|
||
XLine l3 = l1.Offset(-nWeight/2);
|
||
l2.SetLineFlag(1);
|
||
l3.SetLineFlag(1);
|
||
XLine lNext1(ptNext1, ptNext2, 1);
|
||
XLine lNext2 = lNext1.Offset(nWeightNext/2);
|
||
XLine lNext3 = lNext1.Offset(-nWeightNext/2);
|
||
lNext2.SetLineFlag(1);
|
||
lNext3.SetLineFlag(1);
|
||
l1.Intersection(&lNext1, ptInt1);
|
||
int ret1 = l2.Intersection(&lNext2, ptInt2);
|
||
int ret2 = l3.Intersection(&lNext3, ptInt3);
|
||
if(ret1 == 1 && ret2 == 0){
|
||
l3.SetLineFlag(0);
|
||
lNext3.SetLineFlag(0);
|
||
ret2 = l3.Intersection(&lNext3, ptInt3);
|
||
if(ret2 == 1){
|
||
double n1 = l3.StartPoint().Distance(ptInt3);
|
||
double n2 = l3.EndPoint().Distance(ptInt3);
|
||
if(n1 > n2)
|
||
ptInt2 = l3.EndPoint();
|
||
else
|
||
ptInt2 = l3.StartPoint();
|
||
}
|
||
}
|
||
if(ret2 == 1 && ret1 == 0){
|
||
l2.SetLineFlag(0);
|
||
lNext2.SetLineFlag(0);
|
||
ret1 = l2.Intersection(&lNext2, ptInt3);
|
||
if(ret1 == 1){
|
||
double n1 = l2.StartPoint().Distance(ptInt3);
|
||
double n2 = l2.EndPoint().Distance(ptInt3);
|
||
if(n1 > n2)
|
||
ptInt2 = l2.EndPoint();
|
||
else
|
||
ptInt2 = l2.StartPoint();
|
||
}
|
||
}
|
||
|
||
//2管线不是连续绘制，共同一个起点
|
||
if(ret1 == 0 && ret2 == 0){
|
||
ret1 = l2.Intersection(&lNext3, ptInt2);
|
||
ret2 = l3.Intersection(&lNext2, ptInt3);
|
||
if(ret1 == 1 && ret2 == 0){
|
||
l3.SetLineFlag(0);
|
||
lNext2.SetLineFlag(0);
|
||
ret2 = l3.Intersection(&lNext2, ptInt3);
|
||
if(ret2 == 1){
|
||
double n1 = l3.StartPoint().Distance(ptInt3);
|
||
double n2 = l3.EndPoint().Distance(ptInt3);
|
||
if(n1 > n2)
|
||
ptInt2 = l3.EndPoint();
|
||
else
|
||
ptInt2 = l3.StartPoint();
|
||
}
|
||
}
|
||
if(ret2 == 1 && ret1 == 0){
|
||
l2.SetLineFlag(0);
|
||
lNext3.SetLineFlag(0);
|
||
ret1 = l2.Intersection(&lNext3, ptInt3);
|
||
if(ret1 == 1){
|
||
double n1 = l2.StartPoint().Distance(ptInt3);
|
||
double n2 = l2.EndPoint().Distance(ptInt3);
|
||
if(n1 > n2)
|
||
ptInt2 = l2.EndPoint();
|
||
else
|
||
ptInt2 = l2.StartPoint();
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
|
||
AOLAPI double g_nAcadVer;
|
||
|
||
Acad::ErrorStatus
|
||
TDbPipe::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
||
{
|
||
// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
|
||
AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
|
||
if (player.openStatus() == Acad::eOk && player->isOff())
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
if(!IsVisibleEntity(this)) return es;
|
||
|
||
//以下部分判断本管线所在的dwg是否是粗线模式
|
||
BOOL bIsWeight = g_bPipeWeight;
|
||
if(dc.IsFullExplode()){
|
||
AcDbDatabase *pDb = database();
|
||
if(pDb){
|
||
AcDbDictionary* pRootDict=NULL;
|
||
es=pDb->getNamedObjectsDictionary(pRootDict,AcDb::kForRead);
|
||
assert(es==Acad::eOk);
|
||
AcDbObject* pObj;
|
||
es=pRootDict->getAt(g_sDbPsConfig,pObj,AcDb::kForRead);
|
||
if (es==Acad::eOk) {
|
||
bIsWeight = ((TDbPsConfig *)pObj)->IsLineWeight();
|
||
pObj->close();
|
||
}
|
||
pRootDict->close();
|
||
}
|
||
}
|
||
// sr add 2004/11/2
|
||
|
||
XExplodeDraw &viewDraw = (XExplodeDraw &)dc;
|
||
|
||
// 显示管线
|
||
if (IsVertical())
|
||
es = DrawVerPipe2d(dc);
|
||
else {
|
||
es = DrawHorPipe2d(viewDraw, bIsWeight);
|
||
|
||
if(bIsWeight && dc.IsFullExplode()){
|
||
//2根加粗的管线中间会留有缝隙，这里弥补一下。不支持弧管
|
||
AcDbObjectId idPipe1 = GetNextPipe(objectId(), GetNode(0));
|
||
AcDbObjectId idPipe2 = GetNextPipe(objectId(), GetNode(1));
|
||
if(idPipe1){
|
||
XPoint ptInt1, ptInt2, ptInt3;
|
||
ChamferPipe(objectId(), idPipe1, ptInt1, ptInt2, ptInt3);
|
||
if(!!ptInt1 && !!ptInt2 && !!ptInt3){
|
||
XPoly2D poly;
|
||
poly.AppendNode(ptInt1);
|
||
poly.AppendNode(ptInt2);
|
||
poly.AppendNode(ptInt3);
|
||
viewDraw.DrawSolid(poly);
|
||
}
|
||
}
|
||
if(idPipe2){
|
||
XPoint ptInt1, ptInt2, ptInt3;
|
||
ChamferPipe(objectId(), idPipe2, ptInt1, ptInt2, ptInt3);
|
||
if(!!ptInt1 && !!ptInt2 && !!ptInt3){
|
||
XPoly2D poly2;
|
||
poly2.AppendNode(ptInt1);
|
||
poly2.AppendNode(ptInt2);
|
||
poly2.AppendNode(ptInt3);
|
||
viewDraw.DrawSolid(poly2);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//// 输出流向
|
||
if(es==Acad::eOk && g_bSPipeFDir)
|
||
es = DrawFlowDirection(viewDraw);
|
||
|
||
// 在管线中点位置显示管线的属性
|
||
if(es==Acad::eOk && IsShowPropertyText() && IsModel())
|
||
es = DrawPropertyText(viewDraw);
|
||
|
||
if(IsDrawLabel()) // 显示管线标注
|
||
DrawLabelText(viewDraw);
|
||
|
||
return es;
|
||
}
|
||
|
||
extern Acad::ErrorStatus DrawPolyMesh(XPoint ptS, XPoint ptE, double nRadius, XExplodeDraw &dc);
|
||
|
||
Acad::ErrorStatus
|
||
TDbPipe::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
||
{
|
||
// cet 2018.2.2 modify 通过文件查询外径，对实体绘制效率影响较大
|
||
// double dPipeDiameter = m_dDnDiameter;
|
||
// dPipeDiameter = GetPipeOutDByDn(m_nMaterial, dPipeDiameter);
|
||
double dPipeDiameter = OuterDn();
|
||
// double dArea(1);
|
||
if(DocGetMeterUnitDraw())
|
||
{
|
||
dPipeDiameter = dPipeDiameter / 1000.0;
|
||
// dArea = 0.0001;
|
||
}
|
||
//2007-12-7 sr 删除下面2行 7.5发行版，2005 2006下打开三维，崩溃
|
||
// if(g_nAcadVer>16.01 && g_nAcadVer<17) //在ACAD2006下，如果开1个三维视口，再打开一个新视口，如果设置其为平面，就崩溃（管线粗线）建筑楼梯也如此
|
||
// dc.SetSelectionMarker(1);
|
||
|
||
// if(!dc.IsFullExplode()){ 2008-7-21 SR 删除一下几行代码， R16 17下 炸开管线，崩溃
|
||
// //如果是动态预演，则简单绘制
|
||
// AcGiCommonDraw *dcCommon=((XAcGiViewDraw &)dc).GetCommonDraw();
|
||
// if(dcCommon->isDragging()) {
|
||
//XCurveSegment segTmp = (*this);
|
||
// dc << segTmp;
|
||
// return Acad::eOk;
|
||
// }
|
||
// }
|
||
|
||
// sr add 2005-6-10
|
||
// XPoly2D polyShape(1);
|
||
// XCircle cir(StartPoint(), dPipeDiameter/2);
|
||
// XCurveSegment seg2;
|
||
// seg2 = cir;
|
||
// seg2.AsPoly2D(polyShape);
|
||
|
||
XCurveSegment cv=GetCurve();
|
||
|
||
// AcGeVector3d v3(0,0,1);
|
||
// if(GetModelType() == TPipeSys::kSystem || GetModelType() == TPipeSys::kPrinciple || cv.Is(CURVE_ARC)) {
|
||
// XCurveSegment segTmp = (*this);
|
||
// dc << segTmp;
|
||
// return Acad::eOk;
|
||
// }
|
||
|
||
|
||
|
||
//绘制3维管道的时候，两边都缩50，目的是留给节点位置
|
||
XPoint pt1(GetStartPoint()), pt2(GetEndPoint()), ptTmp(GetStartPoint());
|
||
ptTmp.x += dPipeDiameter;
|
||
XVector3D vtDir(EndPoint() - StartPoint());
|
||
XVector3D vtDir2(ptTmp - StartPoint());
|
||
vtDir.Normalize();
|
||
vtDir.Scale(dPipeDiameter);
|
||
|
||
//如果管端接设备，则不用缩
|
||
AcDbObjectId nodeId1(NULL), nodeId2(NULL);
|
||
nodeId1 = GetNode(0);
|
||
nodeId2 = GetNode(1);
|
||
OPENOBJ_BEGIN(nodeId1, AcDb::kForRead, TDbPipeFitting, pNode);
|
||
if(pNode){
|
||
if(pNode->GetLocation() == StartPoint())
|
||
pt1 += vtDir;
|
||
else
|
||
pt2 -= vtDir;
|
||
}
|
||
OPENOBJ_END();
|
||
OPENOBJ_BEGIN(nodeId2, AcDb::kForRead, TDbPipeFitting, pNode);
|
||
if(pNode){
|
||
if(pNode->GetLocation() == StartPoint())
|
||
pt1 += vtDir;
|
||
else
|
||
pt2 -= vtDir;
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
|
||
|
||
|
||
// cet 2011.5.24 modify
|
||
// DrawPolyMesh(pt1, pt2, dPipeDiameter/2.0, dc);
|
||
if (cv.Is(CURVE_ARC))
|
||
{
|
||
Draw3dArcPipe(dc);
|
||
}
|
||
else
|
||
{
|
||
DrawPolyMesh(pt1, pt2, dPipeDiameter/2.0, dc);
|
||
}
|
||
return Acad::eOk;
|
||
//sr 2009-3-3 删除以下行，改用DrawPolyMesh
|
||
|
||
|
||
/*
|
||
////////////////////////////////////////////////////
|
||
XPoly2D polyBase;
|
||
if(IsVertical()){//立管 TDbCurveMesh本身有bug，无法绘制立管， 所以先把端点横过来，绘制横管，然后cvMesh.SetNormal(v3)设置法向;
|
||
AcGeVector3d v1 = vtDir.AsAcGeVector3d();
|
||
AcGeVector3d v2 = vtDir2.AsAcGeVector3d();
|
||
v3 = v1.crossProduct(v2);
|
||
AcGeMatrix3d mat;
|
||
mat.setToWorldToPlane(v3);
|
||
v3.normalize();
|
||
pt1.TransformBy(mat);
|
||
pt2.TransformBy(mat);
|
||
polyBase.AppendNode(pt1);
|
||
polyBase.AppendNode(pt2);
|
||
}
|
||
else if(Is(CURVE_LINE)){
|
||
polyBase.AppendNode(pt1);
|
||
polyBase.AppendNode(pt2);
|
||
}
|
||
else
|
||
AsPoly2D(polyBase);//横管用路径曲面
|
||
|
||
if(polyBase.IsSelfIntersect()||polyShape.IsSelfIntersect())
|
||
return Acad::eOk;
|
||
if(polyShape.Area() < dArea)
|
||
return Acad::eOk;
|
||
|
||
TDbCurveMesh2 cvMesh;
|
||
cvMesh.SetPathPoly(polyBase, cvMesh.GetNormal());
|
||
cvMesh.SetShapePoly(polyShape);
|
||
cvMesh.SetShapeBase(StartPoint());
|
||
if(cvMesh.IsValid())
|
||
{
|
||
if(dc.IsFullExplode())
|
||
cvMesh.ExplodeOrDraw3d(dc);
|
||
else
|
||
dc.DrawEntity(cvMesh);
|
||
}
|
||
|
||
return Acad::eOk;
|
||
*/
|
||
}
|
||
|
||
Acad::ErrorStatus TDbPipe::subOpen(AcDb::OpenMode mode)
|
||
{
|
||
Acad::ErrorStatus es=TDbPipePrototype::subOpen(mode);
|
||
if(es==Acad::eOk && g_nCmdReactor!=CMD_UPDATE) {
|
||
if(mode==AcDb::kForWrite && database()==acdbCurDwg()) {
|
||
m_dOldRadius=m_dRadius;
|
||
}
|
||
}
|
||
return es;
|
||
}
|
||
|
||
void TDbPipe::ApplyDnDiameterChangeToLabel()
|
||
{
|
||
// cet 2014.6.3 modify 细化标注更新情况
|
||
// for(int i=0;i<m_lstAttachment.Length(); i++) {
|
||
// OPENOBJ_BEGIN(*m_lstAttachment[i],AcDb::kForRead,TDbPipeLabel,pLabel);
|
||
// if(pLabel!=NULL) {
|
||
// double dDia=Length();
|
||
// if(GetPScale() > 10)
|
||
// dDia = dDia / 1000;
|
||
// if(pLabel->upgradeOpen()==Acad::eOk) {
|
||
// pLabel->assertWriteEnabled();
|
||
// pLabel->SetPipeType(TDbPipeLabel::kCommon);
|
||
// pLabel->SetLeftText(m_sLabel);
|
||
// pLabel->SetPipeDiameter(m_dDnDiameter);
|
||
// pLabel->downgradeOpen();
|
||
// }
|
||
// }
|
||
// OPENOBJ_END();
|
||
// }
|
||
|
||
if (GetCurDocData() != NULL) // cet 2015.7.13 modify 需判断返回值是否有效否则在修复图纸时会产生错误
|
||
{
|
||
XString &sCmd = GetCurDocData()->m_sCurCommand;
|
||
if(0 == _tcsicmp(sCmd, _T("erase"))
|
||
|| 0 == _tcsicmp(sCmd,_T("undo"))
|
||
|| 0 == _tcsicmp(sCmd,_T("u")))
|
||
{
|
||
return; // add by hh 2014.7.9 删除和撤销时，不进行处理
|
||
}
|
||
}
|
||
|
||
CString sDimText = GetLinkedPipeDnDimText();
|
||
CString sPipeText = GetLinkedPipeText();
|
||
int nCount = m_lstAttachment.Length();
|
||
for (int i = 0; i < nCount; ++i)
|
||
{
|
||
// TDbPipeLabel
|
||
OPENOBJ_BEGIN(*m_lstAttachment[i], AcDb::kForWrite, TDbPipeLabel, pPipeLabel);
|
||
if (pPipeLabel != NULL && IsLinkedPipeDnDimText()) // 管线存在关联管径标注文字
|
||
{
|
||
pPipeLabel->SetPipeType(TDbPipeLabel::kDuct);
|
||
pPipeLabel->SetLeftText(sDimText);
|
||
continue;
|
||
}
|
||
OPENOBJ_END();
|
||
// TDbPipeText
|
||
OPENOBJ_BEGIN(*m_lstAttachment[i], AcDb::kForWrite, TDbPipeText, pPipeText);
|
||
if (pPipeText != NULL)
|
||
{
|
||
int nDimTextType = pPipeText->DimTextType();
|
||
// add by hh 2014.6.24 冷媒管单独处理
|
||
if(TPipeSys::kVRVMedia == GetSysType())
|
||
{
|
||
if(1 != nDimTextType && -2 != nDimTextType)
|
||
{
|
||
pPipeText->SetText(GetLabelText());
|
||
}
|
||
continue;
|
||
}
|
||
// add end
|
||
|
||
if (nDimTextType == 0 && IsLinkedPipeDnDimText()) // 管径标注文字
|
||
{
|
||
pPipeText->SetText(sDimText);
|
||
}
|
||
else if (nDimTextType == 1 && IsLinkedPipeText()) // 管线文字
|
||
{
|
||
pPipeText->SetText(sPipeText);
|
||
}
|
||
else if (nDimTextType == -1) // 继续分析文字类型
|
||
{
|
||
CString sTemp, sText;
|
||
sText = pPipeText->GetText();
|
||
int nIndex = -1;
|
||
int nCount = sText.GetLength();
|
||
for (int k = 0; k < nCount; ++k)
|
||
{
|
||
TCHAR ch = sText.GetAt(k);
|
||
// 存在数字就当成管径标注
|
||
if (ch >= _T('0') && ch <= _T('9'))
|
||
{
|
||
nIndex = 0;
|
||
break;
|
||
}
|
||
}
|
||
if ( nIndex != -1 && IsLinkedPipeDnDimText()) // 管径标注文字
|
||
{
|
||
pPipeText->SetText(sDimText);
|
||
pPipeText->DimTextType(0);
|
||
}
|
||
else if (nIndex == -1 && IsLinkedPipeText())// 管线文字
|
||
{
|
||
pPipeText->SetText(sPipeText);
|
||
pPipeText->DimTextType(1);
|
||
}
|
||
}
|
||
// add by hh 2014.6.24 DimTextType等于-2时，不进行更新
|
||
else if (nDimTextType == -2)
|
||
{
|
||
;
|
||
}
|
||
continue;
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
|
||
XExtent TDbPipe::GetExtent() const
|
||
{
|
||
if(IsVertical()) {
|
||
return XExtent(m_dRadius*2,m_dRadius*2);
|
||
}
|
||
else
|
||
return TDbPipePrototype::GetExtent();
|
||
}
|
||
|
||
XExtent TDbPipe::GetOldExtent() const
|
||
{
|
||
if(IsVertical())
|
||
return XExtent(m_dOldRadius,m_dOldRadius);
|
||
else
|
||
return TDbPipePrototype::GetOldExtent();
|
||
}
|
||
|
||
int TDbPipe::GetExtend(XPoint &low, XPoint &up) const
|
||
{
|
||
int nRet=RTNORM;
|
||
if(IsVertical()) {
|
||
//if(objectId().isValid()){
|
||
// AcDbExtents extents;// 可能是扣弯
|
||
// if(getGeomExtents(extents)==Acad::eOk) {
|
||
// low=extents.minPoint();
|
||
// up=extents.maxPoint();
|
||
// } else {
|
||
// nRet=RTERROR ;
|
||
// }
|
||
//} else {
|
||
low=up=StartPoint();
|
||
XExtent ex=GetExtent();
|
||
ex /= 2;
|
||
low -= ex;
|
||
up += ex;
|
||
//}
|
||
} else {
|
||
nRet=TDbPipePrototype::GetExtend(low,up);
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
double TDbPipe::GetBreakWidth() const
|
||
{
|
||
double dWidth=2;
|
||
TPSConfig config(AcDb::kForRead, this->database());
|
||
if(!!config) {
|
||
dWidth = config.m_pConfig->GetBreakWidth();
|
||
if(config.m_pConfig->IsLineWeight()) {
|
||
dWidth += m_dPipeWeight;
|
||
}
|
||
}
|
||
dWidth *= GetPScale();
|
||
return dWidth;
|
||
}
|
||
|
||
|
||
|
||
//取动态属性显示数据
|
||
void TDbPipe::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
||
{
|
||
if(IsVertical())
|
||
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("立管")));
|
||
else
|
||
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("管段")));
|
||
TDbPipePrototype::GetTips(lstInfo);
|
||
// cet 2015.8.24 add 更新基类中设置的系统类型
|
||
if (HavePipeSystemName())
|
||
{
|
||
CString sSysName = GetPipeSystemName();
|
||
int nLen = lstInfo.Length();
|
||
for (int i = 0; i < nLen; ++i)
|
||
{
|
||
TObjInfoUnit *pInfo = lstInfo[i];
|
||
if (pInfo->m_sLabel == _T("系统类型"))
|
||
{
|
||
pInfo->m_sValue = sSysName;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
lstInfo.Append(new TObjInfoUnit(_T("管径"), Dist2Str(m_dDnDiameter)));
|
||
if(!IsVertical())
|
||
lstInfo.Append(new TObjInfoUnit(_T("坡度"), XString(_T("%0.3f"),m_dRadiusIn)));
|
||
|
||
|
||
XStringList lstMaterial;
|
||
if(GetPipeMaterial(lstMaterial) && m_nMaterial>=0
|
||
&& m_nMaterial<lstMaterial.Length()) {
|
||
lstInfo.Append(new TObjInfoUnit(_T("材料"),lstMaterial[m_nMaterial]));
|
||
}
|
||
if(GetModelType() == TPipeSys::kSystem && _tcsicmp(GetSysLabel(), _T("")) != 0){
|
||
lstInfo.Append(new TObjInfoUnit(_T("楼层"), GetSysLabel()));
|
||
lstInfo.Append(new TObjInfoUnit(_T("立管编号"), XString(_T("%.0f"), GetRadiusIn())));
|
||
}
|
||
}
|
||
|
||
bool TDbPipe::IsClipMe(const TEntityBase* pEnt)const
|
||
{
|
||
// if(TEntityBase::IsClipMe(pEnt))
|
||
// return true;
|
||
// if(pEnt == NULL || pEnt->GetMe()->isKindOf(TDbEquipment::desc()))
|
||
// return true;
|
||
// if(IsModel())// 2009.7.21 sr 关闭裁剪，速度很慢
|
||
|
||
// change by hh 2011-09-29 支持水管与风管之间的裁剪 仅限暖通
|
||
/* return false;
|
||
if(pEnt == NULL)
|
||
return true;
|
||
if(pEnt != NULL){
|
||
AcDbObjectId id = pEnt->GetMe()->objectId();
|
||
AcDbObjectId id0 = GetNode(0);
|
||
AcDbObjectId id1 = GetNode(1);
|
||
if(id == id0 || id == id1)
|
||
return false;//如果裁剪对象是管线的节点，就不裁剪了
|
||
if(pEnt->GetMe()->isKindOf(TDbEquipment::desc()))
|
||
return true;
|
||
}*/
|
||
if(15 != g_nProductId)
|
||
return false;
|
||
|
||
// 判断是否处理遮挡
|
||
TDbConfig* pConfig = GetDwgGlobal(AcDb::kForRead);
|
||
if(NULL == pConfig)
|
||
return false;
|
||
BOOL bBreak = FALSE;
|
||
pConfig->GetFields().GFD(_T("THvac_PipeDuctBreak"), bBreak);
|
||
pConfig->close();
|
||
if(!bBreak)
|
||
return false;
|
||
|
||
if(NULL == pEnt)
|
||
return true;
|
||
if(NULL != pEnt)
|
||
{
|
||
// 无法访问到暖通风管系统相关的类 使用类名进行运行时判断
|
||
CString sClassName = pEnt->GetMe()->isA()->name();
|
||
if(0 == sClassName.Compare(_T("TDbHvacDuct"))
|
||
|| 0 == sClassName.Compare(_T("TDbHvacFitting"))
|
||
|| 0 == sClassName.Compare(_T("TDbHvacEquipment")))
|
||
{
|
||
// 获得风管的外包围框
|
||
TADSGePoint3d ptLow, ptUp, ptMid;
|
||
pEnt->GetExtents(ptLow, ptUp);
|
||
Midpoint(ptLow, ptUp, ptMid);
|
||
|
||
// 立管
|
||
if(IsVertical())
|
||
{
|
||
double dY = max(StartPoint().z, EndPoint().z);
|
||
if(dY < ptMid.z)
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
TADSGePoint3d ptPipe;
|
||
Midpoint(StartPoint(), EndPoint(), ptPipe);
|
||
if(ptPipe.z < ptMid.z)
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool TDbPipe::IsMeClip()const
|
||
{
|
||
if(15 != g_nProductId)
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
void InitDbPipe(BOOL bTrue)
|
||
{
|
||
if(bTrue) {
|
||
TDbPipe::rxInit();
|
||
TDbPipe::InitMatchProtocol(TRUE);
|
||
} else {
|
||
TDbPipe::InitMatchProtocol(FALSE);
|
||
deleteAcRxClass(TDbPipe::desc());
|
||
}
|
||
}
|
||
|
||
bool TDbPipe::GetSection(const AcDbFace &face, const AcGeVector3d& vtPlaneSecDir,
|
||
std::vector<TObjSectionRecord> §ionRecords,
|
||
AcDbVoidPtrArray& arFillPtrs) const
|
||
{
|
||
bool bRet = false;
|
||
TGGeSectionPlane section_pln(face, vtPlaneSecDir);
|
||
AcGePoint3d ptS = StartPoint(), ptE = EndPoint();
|
||
AcGeLineSeg3d line(ptS, ptE);
|
||
|
||
// 求线与投影面的最短距离
|
||
AcGePlane plane = section_pln.AsAcGePlane();
|
||
AcGePoint3d pt1 = ptS.project(plane, vtPlaneSecDir);
|
||
AcGePoint3d pt2 = ptE.project(plane, vtPlaneSecDir);
|
||
double dDist1 = ptS.distanceTo(pt1), dDist2 = ptE.distanceTo(pt2);
|
||
double dElev = dDist1 < dDist2 ? dDist1 : dDist2;
|
||
dElev *= -1;
|
||
|
||
AcGeLineSeg3d seg;
|
||
AcGePoint3d pt;
|
||
short iRet = SectionUtility::Projection_line2plane(section_pln, line, seg, pt);
|
||
if (iRet == 1) // 垂直
|
||
{
|
||
TGGePoly3D poly2d;
|
||
int nCount = 40; //平分一个圆的份数
|
||
double angle = PI * ( 2.0 / nCount);
|
||
AcGeVector3d vtDir, vtAxis = ptE - ptS;
|
||
vtDir = vtAxis;
|
||
vtDir = vtDir.rotateBy(PI * 0.5, AcGeVector3d::kZAxis);
|
||
vtDir.normalize();
|
||
vtDir *= m_dRadius*GetPScale(); // cet 2011.8.18 modify 圆半径修改为立管默认绘制半径
|
||
for (int i = 0; i < nCount; ++i)
|
||
{
|
||
poly2d.AppendNode(pt + vtDir.rotateBy(angle, vtAxis), angle);
|
||
}
|
||
poly2d.AppendNode(*poly2d.Head());
|
||
poly2d.SetFlag(0x01);
|
||
|
||
TObjSectionRecord record(objectId(), layerId(), TObjSectionRecord::eTCH_PIPE, dElev, poly2d);
|
||
sectionRecords.push_back(record);
|
||
|
||
bRet = true;
|
||
}
|
||
else if (iRet == 0) // 不垂直
|
||
{
|
||
BOOL bV = IsVertical();
|
||
if (m_lstAttachment.Length() == 0) // 无附件
|
||
{
|
||
TGGePoly2D poly2d;
|
||
poly2d.AppendNode(asDblArray(seg.startPoint()));
|
||
poly2d.AppendNode(asDblArray(seg.endPoint()));
|
||
|
||
TObjSectionRecord record(objectId(), layerId(), TObjSectionRecord::eTCH_PIPE, dElev, poly2d);
|
||
sectionRecords.push_back(record);
|
||
}
|
||
else // 有附件打断管
|
||
{
|
||
// 获得管与附件的交点
|
||
AcGeVector3d vt = ptS - ptE;
|
||
std::vector<AcGePoint3d> vecPt;
|
||
for (int i = 0; i < m_lstAttachment.Length(); i++)
|
||
{
|
||
vt.normalize();
|
||
TDbPipeValve *pValve = NULL;
|
||
AcGePoint3d ptLoc;
|
||
double dWidth = 0.0;
|
||
acdbOpenObject(pValve, m_lstAttachment[i], AcDb::kForRead);
|
||
if (pValve != NULL) // 附件
|
||
{
|
||
ptLoc = pValve->GetLocation();
|
||
dWidth = pValve->GetWidth() * pValve->GetScale();
|
||
pValve->close();
|
||
}
|
||
|
||
if (ptLoc != AcGePoint3d::kOrigin)
|
||
{
|
||
double dVal = sin(vt.angleTo(vtPlaneSecDir));
|
||
vt *= dWidth / fabs(dVal) / 2;
|
||
vecPt.push_back(ptLoc + vt);
|
||
vecPt.push_back(ptLoc - vt);
|
||
}
|
||
}
|
||
|
||
// 求各点到管起始点的距离， 按从小到大排序
|
||
std::map<double, AcGePoint3d> mapPt;
|
||
std::vector<AcGePoint3d>::iterator it;
|
||
for (it = vecPt.begin(); it != vecPt.end(); it++)
|
||
{
|
||
mapPt.insert(std::make_pair(ptS.distanceTo(*it), *it));
|
||
}
|
||
mapPt.insert(std::make_pair(ptS.distanceTo(ptE), ptE));
|
||
mapPt.insert(std::make_pair(0, ptS));
|
||
|
||
// 求出打断后的各段管线并投影
|
||
bool bFlag = false;
|
||
std::map<double, AcGePoint3d>::iterator it2, it3;
|
||
for ( it2 = it3 = mapPt.begin(); it3 != mapPt.end(); it3 = it2, ++it3)
|
||
{
|
||
bFlag = false;
|
||
AcGePoint3d &pt1 = (*it2).second;
|
||
++it2;
|
||
AcGePoint3d &pt2 = (*it2).second;
|
||
for (it = vecPt.begin(); it != vecPt.end(); it++)
|
||
{
|
||
AcGePoint3d &pt3 = *it;
|
||
++it;
|
||
AcGePoint3d &pt4 = *it;
|
||
if (pt1.distanceTo(pt3) < 1e-3 && pt2.distanceTo(pt4) < 1e-3
|
||
|| pt1.distanceTo(pt4) < 1e-3 && pt2.distanceTo(pt3) < 1e-3)
|
||
{
|
||
bFlag = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!bFlag)
|
||
{
|
||
AcGePoint3d pt5 = pt1.project(plane, vtPlaneSecDir);
|
||
AcGePoint3d pt6 = pt2.project(plane, vtPlaneSecDir);
|
||
double dDist1 = pt5.distanceTo(pt1), dDist2 = pt6.distanceTo(pt2);
|
||
double dElev = dDist1 < dDist2 ? dDist1 : dDist2;
|
||
dElev *= -1;
|
||
|
||
AcGeLineSeg3d seg;
|
||
AcGePoint3d pt;
|
||
AcGeLineSeg3d line(pt1, pt2);
|
||
SectionUtility::Projection_line2plane(section_pln, line, seg, pt);
|
||
|
||
TGGePoly2D poly2d;
|
||
poly2d.AppendNode(asDblArray(seg.startPoint()));
|
||
poly2d.AppendNode(asDblArray(seg.endPoint()));
|
||
TObjSectionRecord record(objectId(), layerId(), TObjSectionRecord::eTCH_PIPE, dElev, poly2d);
|
||
sectionRecords.push_back(record);
|
||
}
|
||
}
|
||
}
|
||
|
||
//附件
|
||
if (IsVertical()) // 立管
|
||
{
|
||
for(int i = 0; i < m_lstAttachment.Length(); i++)
|
||
{
|
||
AcDbObjectId id = m_lstAttachment[i];
|
||
TDbPipeValve *pValve = NULL;
|
||
acdbOpenObject(pValve, id, AcDb::kForRead);
|
||
if (pValve != NULL)
|
||
{
|
||
pValve->GetSection(face,vtPlaneSecDir, sectionRecords, arFillPtrs);
|
||
pValve->close();
|
||
}
|
||
}
|
||
}
|
||
|
||
bRet = true;
|
||
}
|
||
|
||
return bRet;
|
||
}
|
||
|
||
// Acad::ErrorStatus TDbPipe::getGeomExtents( AcDbExtents& extents ) const
|
||
// {
|
||
// extents.addPoint(GetStartPoint());
|
||
// extents.addPoint(GetEndPoint());
|
||
//
|
||
// return Acad::eOk;
|
||
// }
|
||
|
||
Acad::ErrorStatus TDbPipe::GetExtents(TADSGePoint3d &ptLow, TADSGePoint3d &ptUp) const
|
||
{
|
||
AcDbExtents ent;
|
||
ent.addPoint(GetStartPoint());
|
||
ent.addPoint(GetEndPoint());
|
||
ptLow = ent.minPoint();
|
||
ptUp = ent.maxPoint();
|
||
return Acad::eOk;
|
||
}
|
||
|
||
CString TDbPipe::GetXml(const AcGeMatrix3d& mat) const
|
||
{
|
||
if (m_modelType == TPipeSys::kSystem) // 系统图
|
||
{
|
||
return CString();
|
||
}
|
||
|
||
TXmlTree xmlTree;
|
||
CString csText;
|
||
AcGePoint3d pt;
|
||
CString csX, csY, csZ;
|
||
int nPre = 3; // 精度
|
||
double dDnDiameter = m_dDnDiameter;
|
||
if (DocGetMeterUnitDraw())
|
||
{
|
||
dDnDiameter *= 0.001;
|
||
}
|
||
|
||
POSITION posRoot = xmlTree.Insert(_T("ATS_PIPE"), NULL, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posRoot, _T("name"), _T("水管"));
|
||
xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
|
||
}
|
||
|
||
POSITION posItemMaterial = xmlTree.Insert(_T("Material"),posRoot, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posItemMaterial, _T("name"), _T("水管材料"));
|
||
xmlTree.SetAttribute(posItemMaterial, _T("comment"), _T("水管使用的材料"));
|
||
XStringList lst;
|
||
GetPipeMaterial(lst);
|
||
CString strMat;
|
||
if (lst.Length() > 0) // 成功找到材质信息时，进行查找 cet 2013.6.26 add
|
||
{
|
||
strMat = lst[m_nMaterial];
|
||
}
|
||
|
||
xmlTree.SetItemText(posItemMaterial, strMat);
|
||
}
|
||
|
||
POSITION posItemType = xmlTree.Insert(_T("Style"),posRoot, posItemMaterial);
|
||
{
|
||
xmlTree.SetAttribute(posItemType, _T("name"), _T("系统类型"));
|
||
xmlTree.SetAttribute(posItemType, _T("comment"), _T("水管所属系统"));
|
||
xmlTree.SetItemText(posItemType, GetSystypeName(m_sysType));
|
||
}
|
||
|
||
POSITION posItemDn = xmlTree.Insert(_T("Pipe_caliber"),posRoot, posItemType);
|
||
{
|
||
xmlTree.SetAttribute(posItemDn, _T("name"), _T("外径"));
|
||
xmlTree.SetAttribute(posItemDn, _T("comment"), _T("水管公称直径"));
|
||
xmlTree.SetItemText(posItemDn, DoubleToString(dDnDiameter, nPre));
|
||
}
|
||
|
||
// 内径
|
||
POSITION posInradius = xmlTree.Insert(_T("Pipe_inradius"), posRoot, posItemDn);
|
||
{
|
||
xmlTree.SetAttribute(posInradius, _T("name"), _T("内径"));
|
||
// cet 2018.2.2 modify 通过文件查询内径，对提取信息效率影响较大
|
||
// CString csMat = GetPipeMaterialByIdx(GetMaterial());
|
||
// double dRadius = GetDnDiameter();
|
||
// if (!csMat.IsEmpty()) // 找到材质时，求内径 cet 2013.6.26 add
|
||
// {
|
||
// dRadius = GetPipeDjByDn(csMat, (int)GetDnDiameter()) * 1000;
|
||
// }
|
||
double dRadius = OuterDn() - GetPipeThick() * 2;
|
||
xmlTree.SetItemText(posInradius, DoubleToString(dRadius, nPre));
|
||
}
|
||
|
||
POSITION posItemPt = xmlTree.Insert(_T("Position"), posRoot, posInradius);
|
||
{
|
||
xmlTree.SetAttribute(posItemPt, _T("name"), _T("位置参数"));
|
||
}
|
||
|
||
POSITION posItemStaPt1 = xmlTree.Insert(_T("Start_point1"),posItemPt, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posItemStaPt1, _T("name"), _T("原始起点"));
|
||
pt = StartPoint();
|
||
pt.transformBy(mat);
|
||
csX = DoubleToString(pt.x, nPre);
|
||
csY = DoubleToString(pt.y, nPre);
|
||
csZ = DoubleToString(pt.z, nPre);
|
||
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
||
xmlTree.SetItemText(posItemStaPt1, csText);
|
||
}
|
||
|
||
POSITION posItemEndPt1 = xmlTree.Insert(_T("End_point1"),posItemPt, posItemStaPt1);
|
||
{
|
||
xmlTree.SetAttribute(posItemEndPt1, _T("name"), _T("原始终点"));
|
||
pt = EndPoint();
|
||
pt.transformBy(mat);
|
||
csX = DoubleToString(pt.x, nPre);
|
||
csY = DoubleToString(pt.y, nPre);
|
||
csZ = DoubleToString(pt.z, nPre);
|
||
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
||
xmlTree.SetItemText(posItemEndPt1, csText);
|
||
}
|
||
|
||
POSITION posItemMidPt = xmlTree.Insert(_T("Mid_point"),posItemPt, posItemEndPt1);
|
||
{
|
||
xmlTree.SetAttribute(posItemMidPt, _T("name"), _T("中点"));
|
||
pt = MidPoint();
|
||
pt.transformBy(mat);
|
||
csX = DoubleToString(pt.x, nPre);
|
||
csY = DoubleToString(pt.y, nPre);
|
||
csZ = DoubleToString(pt.z, nPre);
|
||
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
||
xmlTree.SetItemText(posItemMidPt, csText);
|
||
}
|
||
|
||
// 计算绘制起点终点
|
||
//如果管端接设备，则不用缩
|
||
XPoint pt1 = StartPoint();
|
||
XPoint pt2 = EndPoint();
|
||
XCurveSegment seg = GetCurve();
|
||
if (!seg.Is(CURVE_ARC)) // 直管
|
||
{
|
||
AcDbObjectId nodeId1(NULL), nodeId2(NULL);
|
||
nodeId1 = GetNode(0);
|
||
nodeId2 = GetNode(1);
|
||
XVector3D vtDir(EndPoint() - StartPoint());
|
||
vtDir.Normalize();
|
||
vtDir.Scale(dDnDiameter);
|
||
OPENOBJ_BEGIN(nodeId1, AcDb::kForRead, TDbPipeFitting, pNode);
|
||
if(pNode){
|
||
if(pNode->GetLocation() == StartPoint())
|
||
pt1 += vtDir;
|
||
else
|
||
pt2 -= vtDir;
|
||
}
|
||
OPENOBJ_END();
|
||
OPENOBJ_BEGIN(nodeId2, AcDb::kForRead, TDbPipeFitting, pNode);
|
||
if(pNode){
|
||
if(pNode->GetLocation() == StartPoint())
|
||
pt1 += vtDir;
|
||
else
|
||
pt2 -= vtDir;
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
else // 弧管
|
||
{
|
||
double dDist = m_dDnDiameter; // 端点向内缩进距离
|
||
double dMeter = 1.0;
|
||
if (DocGetMeterUnitDraw())
|
||
{
|
||
dDist *= 0.001;
|
||
}
|
||
|
||
XArc arc1 = seg.GetArc();
|
||
AcGePoint3d ptS, ptE;
|
||
AcDbArc arc(arc1.GetCenterPt(), arc1.GetRadius(), arc1.GetStarAngle(), arc1.GetEndAngle());
|
||
AcGeVector3d vtNormal = arc.normal(); // 法向量
|
||
arc.getPointAtDist(dDist, pt1); // 起点向管线内移动
|
||
double dArcLen = 0.0;
|
||
arc.getDistAtPoint(pt2, dArcLen);
|
||
arc.getPointAtDist(dArcLen - dDist, pt2); // 起点向管线内移动
|
||
}
|
||
|
||
POSITION posItemStaPt2 = xmlTree.Insert(_T("Start_point2"),posItemPt, posItemMidPt);
|
||
{
|
||
xmlTree.SetAttribute(posItemStaPt2, _T("name"), _T("绘制起点"));
|
||
pt1.TransformBy(mat);
|
||
csX = DoubleToString(pt1.x, nPre);
|
||
csY = DoubleToString(pt1.y, nPre);
|
||
csZ = DoubleToString(pt1.z, nPre);
|
||
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
||
xmlTree.SetItemText(posItemStaPt2, csText);
|
||
}
|
||
|
||
POSITION posItemEndPt2 = xmlTree.Insert(_T("End_point2"),posItemPt, posItemStaPt2);
|
||
{
|
||
xmlTree.SetAttribute(posItemEndPt2, _T("name"), _T("绘制终点"));
|
||
pt2.TransformBy(mat);
|
||
csX = DoubleToString(pt2.x, nPre);
|
||
csY = DoubleToString(pt2.y, nPre);
|
||
csZ = DoubleToString(pt2.z, nPre);
|
||
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
||
xmlTree.SetItemText(posItemEndPt2, csText);
|
||
}
|
||
|
||
// 坡度
|
||
POSITION posGradient = xmlTree.Insert(_T("Gradient"), posRoot, posItemPt);
|
||
{
|
||
xmlTree.SetAttribute(posGradient, _T("name"), _T("坡度"));
|
||
xmlTree.SetItemText(posGradient, DoubleToString(GetGradient(), nPre));
|
||
}
|
||
|
||
// 流向
|
||
POSITION posFlowDir = xmlTree.Insert(_T("FlowDir"), posRoot, posGradient);
|
||
{
|
||
xmlTree.SetAttribute(posFlowDir, _T("name"), _T("流向"));
|
||
CString sFlowDir;
|
||
if (GetFlowDir() == TPipeSys::kFromStart)
|
||
{
|
||
sFlowDir = _T("从起点到终点");
|
||
}
|
||
else
|
||
{
|
||
sFlowDir = _T("从终点到起点");
|
||
}
|
||
xmlTree.SetItemText(posFlowDir, sFlowDir);
|
||
}
|
||
|
||
// 标注信息 cet 2013.11.19 add
|
||
POSITION posDimInfo = xmlTree.Insert(_T("PipeDim"), posRoot, posFlowDir);
|
||
{
|
||
xmlTree.SetAttribute(posDimInfo, _T("name"), _T("管线标注信息"));
|
||
BOOL bDim = IsDrawLabel();
|
||
POSITION posIsDim = xmlTree.Insert(_T("IsDim"), posDimInfo, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posIsDim, _T("name"), _T("是否标注"));
|
||
csText.Format(_T("%d"), bDim ? 1 : 0);
|
||
xmlTree.SetItemText(posIsDim, csText);
|
||
}
|
||
|
||
if (bDim)
|
||
{
|
||
POSITION posDimText = xmlTree.Insert(_T("DimText"), posDimInfo, posIsDim);
|
||
{
|
||
xmlTree.SetAttribute(posDimText, _T("name"), _T("标注文字"));
|
||
xmlTree.SetItemText(posDimText, GetLabelText());
|
||
}
|
||
|
||
POSITION posLabel = xmlTree.Insert(_T("DimLabel"), posDimInfo, posDimText);
|
||
{
|
||
xmlTree.SetAttribute(posLabel, _T("name"), _T("标注前缀"));
|
||
xmlTree.SetItemText(posLabel, GetLabel());
|
||
}
|
||
|
||
POSITION posDimFormat = xmlTree.Insert(_T("DimFormat"), posDimInfo, posLabel);
|
||
{
|
||
xmlTree.SetAttribute(posDimFormat, _T("name"), _T("标注格式"));
|
||
POSITION posDnDimType = xmlTree.Insert(_T("DnDimType"), posDimFormat, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posDnDimType, _T("name"), _T("管径样式"));
|
||
csText.Format(_T("%d"), GetPipeDnDimType());
|
||
xmlTree.SetItemText(posDnDimType, csText);
|
||
}
|
||
POSITION posGradientDimType = xmlTree.Insert(_T("GradientDimType"), posDimFormat, posDnDimType);
|
||
{
|
||
xmlTree.SetAttribute(posGradientDimType, _T("name"), _T("坡度样式"));
|
||
csText.Format(_T("%d"), GetPipeGradientDimType());
|
||
xmlTree.SetItemText(posGradientDimType, csText);
|
||
}
|
||
POSITION posLenDimType = xmlTree.Insert(_T("LenDimType"), posDimFormat, posGradientDimType);
|
||
{
|
||
xmlTree.SetAttribute(posLenDimType, _T("name"), _T("管长样式"));
|
||
csText.Format(_T("%d"), GetPipeLenDimType());
|
||
xmlTree.SetItemText(posLenDimType, csText);
|
||
}
|
||
POSITION posLableDrawType = xmlTree.Insert(_T("LableDrawType"), posDimFormat, posLenDimType);
|
||
{
|
||
xmlTree.SetAttribute(posLableDrawType, _T("name"), _T("排列样式"));
|
||
xmlTree.SetAttribute(posLableDrawType, _T("comment"), _T("横排竖排"));
|
||
csText.Format(_T("%d"), GetPipeLableDrawType());
|
||
xmlTree.SetItemText(posLableDrawType, csText);
|
||
}
|
||
POSITION posDimLableType = xmlTree.Insert(_T("DimSeparatorType"), posDimFormat, posLableDrawType);
|
||
{
|
||
xmlTree.SetAttribute(posDimLableType, _T("name"), _T("分隔符号样式"));
|
||
csText.Format(_T("%d"), GetPipeDimLableType());
|
||
xmlTree.SetItemText(posDimLableType, csText);
|
||
}
|
||
}
|
||
POSITION posDimLoc = xmlTree.Insert(_T("DimLocation"), posDimInfo, posDimFormat);
|
||
{
|
||
xmlTree.SetAttribute(posDimLoc, _T("name"), _T("标注位置"));
|
||
XPoint pt = m_ptLabel;
|
||
pt.TransformBy(mat);
|
||
csX = DoubleToString(pt.x, nPre);
|
||
csY = DoubleToString(pt.y, nPre);
|
||
csZ = DoubleToString(pt.z, nPre);
|
||
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
||
xmlTree.SetItemText(posDimLoc, csText);
|
||
}
|
||
}
|
||
}
|
||
|
||
POSITION posItemId = xmlTree.Insert(_T("Object_ID"), posRoot, posDimInfo);
|
||
{
|
||
xmlTree.SetAttribute(posItemId, _T("name"), _T("ID"));
|
||
xmlTree.SetAttribute(posItemId, _T("comment"), _T("水管ID"));
|
||
csText.Format(_T("%ld"), objectId().asOldId());
|
||
xmlTree.SetItemText(posItemId, csText);
|
||
}
|
||
|
||
CString sXml = xmlTree.GetXml();
|
||
int nIdex = -1;
|
||
nIdex = sXml.Find(_T("</ATS_PIPE>"));
|
||
if (nIdex != -1)
|
||
{
|
||
CString sTemp = TDbPipePrototype::GetXml(mat);
|
||
sXml.Insert(nIdex, sTemp);
|
||
}
|
||
return sXml;
|
||
}
|
||
|
||
void TDbPipe::GetDimPipeLen(CString &sDimPipeLen, int iType, const CString& sLen) const
|
||
{
|
||
// 获取个位数
|
||
CString sTemp;
|
||
sTemp.Format(_T("%d"), iType);
|
||
int iDimType = static_cast<int>(_tstof(sTemp.Right(2)));
|
||
switch(iDimType)
|
||
{
|
||
case 1: // L=12.3m
|
||
{
|
||
sDimPipeLen.Format(_T("L=%sm"),sLen);
|
||
break;
|
||
}
|
||
case 2: // L=12.3
|
||
{
|
||
sDimPipeLen.Format(_T("L=%s"),sLen);
|
||
break;
|
||
}
|
||
case 3: // L12.3m
|
||
{
|
||
sDimPipeLen.Format(_T("L%sm"),sLen);
|
||
break;
|
||
}
|
||
case 4: // L12.3
|
||
{
|
||
sDimPipeLen.Format(_T("L%s"),sLen);
|
||
break;
|
||
}
|
||
case 5: // 12.3m
|
||
{
|
||
sDimPipeLen.Format(_T("%sm"),sLen);
|
||
break;
|
||
}
|
||
case 6: // 12.3
|
||
{
|
||
sDimPipeLen.Format(_T("%s"),sLen);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 绘制三维弧管
|
||
Acad::ErrorStatus TDbPipe::Draw3dArcPipe(XExplodeDraw &dc) const
|
||
{
|
||
XCurveSegment seg = GetCurve();
|
||
if (!seg.Is(CURVE_ARC))
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
double dDist = m_dDnDiameter; // 端点向内缩进距离
|
||
double dMeter = 1.0;
|
||
if (DocGetMeterUnitDraw())
|
||
{
|
||
dDist *= 0.001;
|
||
dMeter = 1000;
|
||
}
|
||
|
||
XArc arc1 = seg.GetArc();
|
||
AcGePoint3d ptS, ptE;
|
||
AcDbArc arc(arc1.GetCenterPt(), arc1.GetRadius(), arc1.GetStarAngle(), arc1.GetEndAngle());
|
||
AcGeVector3d vtNormal = arc.normal(); // 法向量
|
||
arc.getStartPoint(ptS);
|
||
arc.getEndPoint(ptE);
|
||
arc.getPointAtDist(dDist, ptS); // 起点向管线内移动25
|
||
double dArcLen = 0.0;
|
||
arc.getDistAtPoint(ptE, dArcLen);
|
||
arc.getPointAtDist(dArcLen - dDist, ptE); // 起点向管线内移动25
|
||
|
||
double dMinDiffAng = PI / 60;
|
||
int nSect = int(PI * 2 / dMinDiffAng); // 圆分成的段数
|
||
AcGeVector3d vt1 = ptS - arc.center();
|
||
AcGeVector3d vt2 = ptE - arc.center();
|
||
double dArcAngle = vt1.angleTo(vt2, vtNormal); // 弧度角度
|
||
int nSect1 = int(dArcAngle / dMinDiffAng); // 弧管分成的段数
|
||
|
||
// 将ptS点的圆划分为nSect份
|
||
AcGePoint3dArray arptCircle;
|
||
AcGePoint3dArray arptSides;
|
||
AcGePoint3d pt = ptS + vtNormal * m_dDnDiameter / dMeter * 0.5;
|
||
AcGePoint3d ptTemp;
|
||
arc.getPointAtDist(Length() / nSect, ptTemp);
|
||
AcGeVector3d vt = ptTemp - ptS;
|
||
vt.normal();
|
||
ptTemp = pt;
|
||
for (int i = 0; i < nSect + 1 ; i++)
|
||
{
|
||
arptCircle.append(pt);
|
||
pt = ptTemp.rotateBy(dMinDiffAng, vt, ptS);
|
||
}
|
||
|
||
//将ptStart处的圆上nSect个点按照dMinDiffAng旋转出nSect1个圆截面
|
||
double dAngle = 0.0;
|
||
AcGePoint3d ptCen = arc.center();
|
||
for (i = 0; i <= nSect1; i++)
|
||
{
|
||
dAngle = dMinDiffAng * i;
|
||
for (int j = 0; j < nSect + 1 ;j++)
|
||
{
|
||
ptTemp = pt = arptCircle[j];
|
||
pt = ptTemp.rotateBy(dAngle, vtNormal, ptCen);
|
||
arptSides.append(pt);
|
||
}
|
||
}
|
||
|
||
double dAngle2 = 0.0; // 剩余角度
|
||
dAngle2 = dArcAngle - dMinDiffAng * nSect1;
|
||
if (dAngle2 > 0.0)
|
||
{
|
||
for (int j = 0; j < nSect + 1 ;j++)
|
||
{
|
||
ptTemp = pt = arptCircle[j];
|
||
pt = ptTemp.rotateBy(dArcAngle, vtNormal, ptCen);
|
||
arptSides.append(pt);
|
||
}
|
||
++nSect1;
|
||
}
|
||
|
||
//最后一个圆截面是ptStart处的圆上nSect个点按照PI/2 90°或者dAngle旋转出来
|
||
for (int j = 0; j < nSect + 1 ;j++)
|
||
{
|
||
pt = arptCircle[j].rotateBy(dAngle, vtNormal, ptCen);
|
||
arptSides.append(pt);
|
||
}
|
||
|
||
dc.DrawMesh(nSect1 + 2 , nSect + 1, arptSides.asArrayPtr());
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
bool TDbPipe::IsDimEle() const
|
||
{
|
||
const TEntityFields &fd = GetFields();
|
||
Adesk::Boolean bDimEle = Adesk::kTrue;
|
||
if (!fd.GFD(_T("PIPE_DIM_ELE"), bDimEle))
|
||
{
|
||
bDimEle = Adesk::kFalse;
|
||
}
|
||
return bDimEle ? true : false;
|
||
}
|
||
|
||
void TDbPipe::SetDimEle( bool bDim )
|
||
{
|
||
assertWriteEnabled();
|
||
TEntityFields &fd = Fields();
|
||
fd.SFD(_T("PIPE_DIM_ELE"), bDim ? Adesk::kTrue : Adesk::kFalse);
|
||
}
|
||
|
||
void TDbPipe::SetLinkedPipeDnDimText( const CString &sDimText )
|
||
{
|
||
assertWriteEnabled();
|
||
TEntityFields &fd = Fields();
|
||
fd.SFD(_T("LINKED_DIM_TEXT"), sDimText);
|
||
}
|
||
|
||
CString TDbPipe::GetLinkedPipeDnDimText()
|
||
{
|
||
CString sText;
|
||
TEntityFields &fd = Fields();
|
||
fd.GFD(_T("LINKED_DIM_TEXT"), sText);
|
||
return sText;
|
||
}
|
||
|
||
bool TDbPipe::IsLinkedPipeDnDimText()
|
||
{
|
||
CString sText;
|
||
TEntityFields &fd = Fields();
|
||
return fd.GFD(_T("LINKED_DIM_TEXT"), sText);
|
||
}
|
||
|
||
void TDbPipe::UpdateLinkedPipeDnDimText()
|
||
{
|
||
// 没有关联标注文字
|
||
if (!IsLinkedPipeDnDimText())
|
||
{
|
||
CString sTemp;
|
||
sTemp.Format(_T("%s%.0f"), m_sLabel, m_dDnDiameter);
|
||
SetLinkedPipeDnDimText(sTemp);
|
||
return;
|
||
}
|
||
|
||
CString sDimText = GetLinkedPipeDnDimText();
|
||
int nIndex = sDimText.Find(_T("x"));
|
||
CString sTemp;
|
||
// cet 2015.3.11 modify 更新外径判断方式
|
||
// if (nIndex != -1) // 外径标注如“φ50x2.8”
|
||
// {
|
||
// sTemp.Format(_T("%s%.0fx%.1f"), m_sLabel, m_dDnDiameter, GetPipeThick());
|
||
// }
|
||
if (DimDnType() == 1 || nIndex != -1)
|
||
{
|
||
if (nIndex != -1)
|
||
{
|
||
sTemp.Format(_T("%s%.0fx%.1f"), m_sLabel, DimDnType() == 1 ? OuterDn() : m_dDnDiameter, GetPipeThick());
|
||
}
|
||
else
|
||
{
|
||
sTemp.Format(_T("%s%.0f"), m_sLabel, DimDnType() == 1 ? OuterDn() : m_dDnDiameter);
|
||
}
|
||
}
|
||
else // 内径标注如“DN20”
|
||
{
|
||
sTemp.Format(_T("%s%.0f"), m_sLabel, m_dDnDiameter);
|
||
}
|
||
SetLinkedPipeDnDimText(sTemp);
|
||
}
|
||
|
||
bool TDbPipe::IsLinkedPipeText()
|
||
{
|
||
CString sText;
|
||
TEntityFields &fd = Fields();
|
||
return fd.GFD(_T("PIPE_TEXT"), sText);
|
||
}
|
||
|
||
CString TDbPipe::GetLinkedPipeText()
|
||
{
|
||
CString sText;
|
||
TEntityFields &fd = Fields();
|
||
fd.GFD(_T("PIPE_TEXT"), sText);
|
||
return sText;
|
||
}
|
||
|
||
void TDbPipe::SetLinkedPipeText( const CString &sPipeText )
|
||
{
|
||
assertWriteEnabled();
|
||
TEntityFields &fd = Fields();
|
||
fd.SFD(_T("PIPE_TEXT"), sPipeText);
|
||
}
|
||
|
||
int TDbPipe::DimDnType() const
|
||
{
|
||
const TEntityFields &fd = GetFields();
|
||
Adesk::Int8 nType = -1;
|
||
fd.GFD(_T("PIPE_DIM_DN_TYPE"), nType);
|
||
return nType == -1 ? 0 : (int)nType;
|
||
}
|
||
|
||
void TDbPipe::SetDimDnType(int nDnType)
|
||
{
|
||
assertWriteEnabled();
|
||
TEntityFields &fd = Fields();
|
||
fd.SFD(_T("PIPE_DIM_DN_TYPE"), (Adesk::Int8)nDnType);
|
||
m_bUpdateLinkedDim = true; // cet 2015.4.14 add
|
||
}
|
||
|
||
double TDbPipe::OuterDn() const
|
||
{
|
||
const TEntityFields &fd = GetFields();
|
||
double dDn = m_dDnDiameter;
|
||
fd.GFD(_T("PIPE_OUTER_DN"), dDn);
|
||
return dDn;
|
||
}
|
||
|
||
void TDbPipe::SetOuterDn(double dDn)
|
||
{
|
||
assertWriteEnabled();
|
||
TEntityFields &fd = Fields();
|
||
fd.SFD(_T("PIPE_OUTER_DN"), dDn);
|
||
m_bUpdateLinkedDim = true; // cet 2015.3.11 add 更新关联标注
|
||
}
|
||
|
||
Acad::ErrorStatus TDbPipe::subClose()
|
||
{
|
||
// 更新管线关联标注的显示信息
|
||
if (m_bUpdateLinkedDim)
|
||
{
|
||
m_bUpdateLinkedDim = false;
|
||
UpdateLinkedPipeDnDimText();
|
||
}
|
||
return TDbPipePrototype::subClose();
|
||
}
|
||
|
||
Adesk::UInt16 TDbPipe::GetTextColor() const
|
||
{
|
||
const TEntityFields &fd = GetFields();
|
||
Adesk::UInt16 color = 256;
|
||
fd.GFD(_T("TEXT_COLOR"), color);
|
||
return color;
|
||
}
|
||
|
||
void TDbPipe::SetTextColor(Adesk::UInt16 color)
|
||
{
|
||
assertWriteEnabled();
|
||
TEntityFields &fd = Fields();
|
||
fd.SFD(_T("TEXT_COLOR"), color);
|
||
}
|
||
|
||
CString TDbPipe::GetPipeSystemName() const
|
||
{
|
||
const TEntityFields &fd = GetFields();
|
||
CString sName;
|
||
if (!fd.GFD(_T("PIPE_SYSTEM_NAME"), sName)) // 没有设置管道系统名时，通过旧系统类型获取
|
||
{
|
||
sName = GetSystypeName(GetSysType());
|
||
}
|
||
return sName;
|
||
}
|