2961 lines
61 KiB
C++
2961 lines
61 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbPipeHanger.h"
|
|
#include "KTExpressCalc.h"
|
|
#include "AecGripCback.h"
|
|
|
|
|
|
Adesk::UInt32 AecDbPipeHanger::kCurrentVersionNumber = 2;
|
|
|
|
static const Adesk::UInt16 kColorByBlock = 0;
|
|
static const Adesk::UInt16 kRed = 1;
|
|
static const Adesk::UInt16 kYellow = 2;
|
|
static const Adesk::UInt16 kGreen = 3;
|
|
static const Adesk::UInt16 kCyan = 4;
|
|
static const Adesk::UInt16 kBlue = 5;
|
|
static const Adesk::UInt16 kMagenta = 6;
|
|
static const Adesk::UInt16 kWhite = 7;
|
|
static const Adesk::UInt16 kColorByLayer = 256;
|
|
|
|
static void FreeBuffer(AcDbVoidPtrArray &arEntPtrs)
|
|
{
|
|
AcDbEntity *pEnt = NULL;
|
|
while ( !arEntPtrs.isEmpty() )
|
|
{
|
|
pEnt = (AcDbEntity *)arEntPtrs.last();
|
|
delete pEnt;
|
|
|
|
arEntPtrs.removeLast();
|
|
}
|
|
}
|
|
|
|
static int ExtractSubString(CString& str, LPCTSTR pszSteps, CStringArray& arSubStrs)
|
|
{
|
|
TCHAR* pchToken = _tcstok((LPTSTR)(LPCTSTR)str, pszSteps);
|
|
while (pchToken != NULL)
|
|
{
|
|
arSubStrs.Add(pchToken);
|
|
pchToken = _tcstok(NULL, pszSteps);
|
|
}
|
|
return arSubStrs.GetSize();
|
|
}
|
|
|
|
static AcDbRegion *CreateRegFromCurves(AcDbVoidPtrArray& arCurs)
|
|
{
|
|
AcDbVoidPtrArray arRegPtrs;
|
|
AcDbRegion *pReg = NULL;
|
|
if (Acad::eOk == AcDbRegion::createFromCurves(arCurs, arRegPtrs))
|
|
{
|
|
return (AcDbRegion *)arRegPtrs.first();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static AcDbRegion *CreateRegFromCurve(AcDbCircle& cir)
|
|
{
|
|
AcDbVoidPtrArray arCurs;
|
|
arCurs.append(&cir);
|
|
|
|
AcDbVoidPtrArray arRegPtrs;
|
|
AcDbRegion *pReg = NULL;
|
|
if (Acad::eOk == AcDbRegion::createFromCurves(arCurs, arRegPtrs))
|
|
{
|
|
return (AcDbRegion *)arRegPtrs.first();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static AcDbObjectId AddToModelSpace(AcDbEntity* pEnt, bool bClose = true)
|
|
{
|
|
if (!pEnt) return AcDbObjectId::kNull;
|
|
|
|
AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
|
|
AcDbObjectId id(AcDbObjectId::kNull);
|
|
|
|
AcDbBlockTable* pTbl = NULL;
|
|
Acad::ErrorStatus es;
|
|
if (Acad::eOk == (es = pDb->getBlockTable(pTbl, AcDb::kForRead)))
|
|
{
|
|
AcDbBlockTableRecord* pBTR = NULL;
|
|
if (Acad::eOk == (es = pTbl->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForWrite)))
|
|
{
|
|
pTbl->close();
|
|
es = pBTR->appendAcDbEntity(id, pEnt);
|
|
pBTR->close();
|
|
if (bClose) pEnt->close();
|
|
}
|
|
}
|
|
return id;
|
|
}
|
|
|
|
static AcDbRegion * CreatePointsRegion(AcGePoint3dArray& arPts,bool bTest = false)
|
|
{
|
|
int nSize = arPts.length();
|
|
AcDbVoidPtrArray arCurPtrs;
|
|
for (int i = 0; i < nSize - 1; i++)//5
|
|
{
|
|
AcDbLine *pLine = new AcDbLine(arPts[i], arPts[i + 1]);
|
|
arCurPtrs.append(pLine);
|
|
}
|
|
|
|
AcDbVoidPtrArray arRegPtrs;
|
|
AcDbRegion *pReg = NULL;
|
|
if (Acad::eOk == AcDbRegion::createFromCurves(arCurPtrs, arRegPtrs))
|
|
{
|
|
//FREE
|
|
if (bTest)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
for (int i = 0; i < arCurPtrs.length(); i++)
|
|
{
|
|
pEnt = (AcDbEntity*)arCurPtrs.at(i);
|
|
pEnt->setColorIndex(1);
|
|
AddToModelSpace(pEnt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FreeBuffer(arCurPtrs);
|
|
}
|
|
return (AcDbRegion *)arRegPtrs.first();
|
|
}
|
|
|
|
//FREE
|
|
if (bTest)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
for (int i = 0; i < arCurPtrs.length(); i++)
|
|
{
|
|
pEnt = (AcDbEntity*)arCurPtrs.at(i);
|
|
pEnt->setColorIndex(1);
|
|
AddToModelSpace(pEnt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FreeBuffer(arCurPtrs);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static AcDbRegion * CreateCirRegion(AcGePoint3d& pt, double dR, const AcGeVector3d& vtDir)
|
|
{
|
|
AcDbCircle cir;
|
|
cir.setCenter(pt);
|
|
cir.setRadius(dR);
|
|
cir.setNormal(vtDir);
|
|
|
|
AcDbVoidPtrArray arCurPtrs;
|
|
arCurPtrs.append(&cir);
|
|
|
|
AcDbVoidPtrArray arRegPtrs;
|
|
AcDbRegion *pReg = NULL;
|
|
if (Acad::eOk == AcDbRegion::createFromCurves(arCurPtrs, arRegPtrs))
|
|
{
|
|
return (AcDbRegion *)arRegPtrs.first();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
typedef CMap<CString, LPCTSTR, AcGePoint2d, AcGePoint2d> CMapStringToPoint;
|
|
static CMapStringToPoint g_mapMx;
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(AecDbPipeHanger, AecDbEntityBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_PIPEHNGR,
|
|
"AecDbPipeHanger"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
AecDbPipeHanger::AecDbPipeHanger()
|
|
{
|
|
if (g_mapMx.IsEmpty())
|
|
{
|
|
g_mapMx.SetAt(_T("M5"), AcGePoint2d(4.6, 7.64));
|
|
g_mapMx.SetAt(_T("M6"), AcGePoint2d(5.6, 9.64));
|
|
g_mapMx.SetAt(_T("M8"), AcGePoint2d(7.25, 12.57));
|
|
g_mapMx.SetAt(_T("M10"), AcGePoint2d(8.75, 16.57));
|
|
g_mapMx.SetAt(_T("M12"), AcGePoint2d(10.75, 18.48));
|
|
g_mapMx.SetAt(_T("M16"), AcGePoint2d(13.9, 23.16));
|
|
g_mapMx.SetAt(_T("M20"), AcGePoint2d(16.9, 29.16));
|
|
g_mapMx.SetAt(_T("M22"), AcGePoint2d(18.9, 31.0));
|
|
g_mapMx.SetAt(_T("M24"), AcGePoint2d(20.05, 35.0));
|
|
g_mapMx.SetAt(_T("M27"), AcGePoint2d(23.05, 40.0));
|
|
g_mapMx.SetAt(_T("M30"), AcGePoint2d(25.05, 45.0));
|
|
}
|
|
|
|
m_ptIns.set(0,0,0);
|
|
m_dRot = 0;
|
|
m_pElbowArc = NULL;
|
|
m_dElbowOD = 0;
|
|
m_pGripAppData = new AecGripData[GRIP_MAXNUM];
|
|
}
|
|
|
|
AecDbPipeHanger::~AecDbPipeHanger()
|
|
{
|
|
if (m_pElbowArc != NULL)
|
|
delete m_pElbowArc;
|
|
m_pElbowArc = NULL;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPipeHanger::dwgInFields(AcDbDwgFiler *pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = AecDbEntityBase::dwgInFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return (es);
|
|
|
|
//----- Object version number needs to be read first
|
|
Adesk::UInt32 version = 0;
|
|
if ((es = pFiler->readUInt32(&version)) != Acad::eOk)
|
|
return (es);
|
|
|
|
if (version > AecDbPipeHanger::kCurrentVersionNumber)
|
|
return (Acad::eMakeMeProxy);
|
|
|
|
Adesk::UInt32 nLen = 0;
|
|
pFiler->readUInt32(&nLen);
|
|
|
|
m_arLines.RemoveAll();
|
|
TCHAR *pszTmp = NULL;
|
|
for (int i = 0;i < nLen;i++)
|
|
{
|
|
pszTmp = NULL;
|
|
pFiler->readString(&pszTmp);
|
|
if (pszTmp != NULL)
|
|
{
|
|
m_arLines.Add(pszTmp);
|
|
acutDelString(pszTmp);
|
|
}
|
|
}
|
|
|
|
pFiler->readPoint3d(&m_ptIns);
|
|
pFiler->readDouble(&m_dRot);
|
|
|
|
m_mapSpecXData.dwgInFields(pFiler);
|
|
|
|
if (version > 1)
|
|
{
|
|
AcGePoint3d ptC;
|
|
double dr = 0, dSA = 0, dEA = 0;
|
|
AcGeVector3d vtN(0,0,0);
|
|
|
|
pFiler->readPoint3d(&ptC);
|
|
pFiler->readDouble(&dr);
|
|
pFiler->readDouble(&dSA);
|
|
pFiler->readDouble(&dEA);
|
|
pFiler->readVector3d(&vtN);
|
|
|
|
if (!vtN.isZeroLength() && dr > 1.e-3)
|
|
{
|
|
if (m_pElbowArc == NULL)
|
|
{
|
|
m_pElbowArc = new AcDbArc;
|
|
}
|
|
m_pElbowArc->setCenter(ptC);
|
|
m_pElbowArc->setRadius(dr);
|
|
m_pElbowArc->setStartAngle(dSA);
|
|
m_pElbowArc->setEndAngle(dEA);
|
|
m_pElbowArc->setNormal(vtN);
|
|
}
|
|
pFiler->readDouble(&m_dElbowOD);
|
|
}
|
|
|
|
AcGePoint3d pt = m_ptIns;
|
|
double dRot = m_dRot;
|
|
Insert(pt, dRot);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPipeHanger::dwgOutFields(AcDbDwgFiler *pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = AecDbEntityBase::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return (es);
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ((es = pFiler->writeUInt32(AecDbPipeHanger::kCurrentVersionNumber)) != Acad::eOk)
|
|
return (es);
|
|
|
|
Adesk::UInt32 nLen = m_arLines.GetSize();
|
|
pFiler->writeUInt32(nLen);
|
|
|
|
CString sLn;
|
|
for (int i = 0;i < nLen;i++)
|
|
{
|
|
sLn = m_arLines.GetAt(i);
|
|
pFiler->writeString((LPCTSTR)sLn);
|
|
}
|
|
|
|
pFiler->writePoint3d(m_ptIns);
|
|
pFiler->writeDouble(m_dRot);
|
|
|
|
m_mapSpecXData.dwgOutFields(pFiler);
|
|
|
|
AcGePoint3d ptC;
|
|
AcGeVector3d vtN(0, 0, 0);
|
|
double dr = 0, dSA = 0, dEA = 0;
|
|
if (m_pElbowArc != NULL)
|
|
{
|
|
ptC = m_pElbowArc->center();
|
|
dr = m_pElbowArc->radius();
|
|
dSA = m_pElbowArc->startAngle();
|
|
dEA = m_pElbowArc->endAngle();
|
|
vtN = m_pElbowArc->normal();
|
|
|
|
pFiler->writePoint3d(ptC);
|
|
pFiler->writeDouble(dr);
|
|
pFiler->writeDouble(dSA);
|
|
pFiler->writeDouble(dEA);
|
|
pFiler->writeVector3d(vtN);
|
|
}
|
|
else
|
|
{
|
|
pFiler->writePoint3d(ptC);
|
|
pFiler->writeDouble(dr);
|
|
pFiler->writeDouble(dSA);
|
|
pFiler->writeDouble(dEA);
|
|
pFiler->writeVector3d(vtN);
|
|
}
|
|
pFiler->writeDouble(m_dElbowOD);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPipeHanger::dxfInFields(AcDbDxfFiler *pFiler)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPipeHanger::dxfOutFields(AcDbDxfFiler *pFiler) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbPipeHanger::subList() const
|
|
{
|
|
assertReadEnabled();
|
|
AecDbEntityBase::subList();
|
|
|
|
CString sName;
|
|
m_mapSpecXData.GetAt(KEY_NAME, sName);
|
|
acutPrintf(_T("\n托架名称:%s"),sName);
|
|
|
|
m_mapSpecXData.List();
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPipeHanger::copyFrom(const AcRxObject *pSrc)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
AecDbPipeHanger *pFit = AecDbPipeHanger::cast(pSrc);
|
|
if (pFit != NULL)
|
|
{
|
|
m_arLines.RemoveAll();
|
|
m_arLines.Append(pFit->m_arLines);
|
|
|
|
m_mapSpecXData.Empty();
|
|
m_mapSpecXData.AppendFrom(&pFit->m_mapSpecXData);
|
|
|
|
if (pFit->m_pElbowArc != NULL)
|
|
{
|
|
if (m_pElbowArc == NULL)
|
|
m_pElbowArc = new AcDbArc;
|
|
|
|
m_pElbowArc->copyFrom(pFit->m_pElbowArc);
|
|
}
|
|
|
|
m_dElbowOD = pFit->m_dElbowOD;
|
|
m_ptIns = pFit->m_ptIns;
|
|
m_dRot = pFit->m_dRot;
|
|
m_arRecPts.removeAll();
|
|
//m_ar3DSlds.removeAll();
|
|
FreeBuffer(m_ar3DSlds);
|
|
|
|
AcGePoint3d pt = m_ptIns;
|
|
double dRot = m_dRot;
|
|
Insert(pt, dRot);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPipeHanger::subTransformBy(const AcGeMatrix3d &xform)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
m_arRecPts.removeAll();
|
|
m_ptIns.transformBy(xform);
|
|
|
|
if (m_pElbowArc != NULL)
|
|
m_pElbowArc->transformBy(xform);
|
|
|
|
AcGeVector3d vt(1,0,0);
|
|
vt.rotateBy(m_dRot, AcGeVector3d::kZAxis);
|
|
vt.transformBy(xform);
|
|
|
|
m_dRot = AcGeVector3d::kXAxis.angleTo(vt, AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d pt = m_ptIns;
|
|
double dRot = m_dRot;
|
|
Insert(pt, dRot);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
#ifndef KEY_MODE
|
|
#define KEY_MODE _T("MODE")
|
|
#endif
|
|
|
|
static void Get45Pts(AcGePoint3d& pt0, AcGePoint3d& pt1, AcGeLineSeg3d& ln, double dW, int nDir)
|
|
{
|
|
AcGeVector3d vt = pt1 - pt0;
|
|
vt.normalize();
|
|
|
|
AcGePoint3d ptGe[2];
|
|
|
|
ptGe[0] = pt0 + vt * 0.5 * dW;
|
|
|
|
double dAng = nDir * PI / 4.0;
|
|
vt.rotateBy(dAng, AcGeVector3d::kZAxis);
|
|
|
|
ptGe[1] = ptGe[0] + 0.707 * dW * vt;
|
|
ptGe[0] -= 0.707 * dW * vt;
|
|
|
|
ln.set(ptGe[0], ptGe[1]);
|
|
}
|
|
|
|
static void Get45Pts(AcGePoint3d& pt0, AcGePoint3d& pt1, AcDbLine* pLn, double dW, int nDir)
|
|
{
|
|
if (pLn == NULL)
|
|
return;
|
|
|
|
AcGeVector3d vt = pt1 - pt0;
|
|
vt.normalize();
|
|
|
|
AcGePoint3d ptGe[2];
|
|
|
|
ptGe[0] = pt0 + vt * 0.5 * dW;
|
|
|
|
double dAng = nDir * PI / 4.0;
|
|
vt.rotateBy(dAng, AcGeVector3d::kZAxis);
|
|
|
|
ptGe[1] = ptGe[0] + 0.707 * dW * vt;
|
|
ptGe[0] -= 0.707 * dW * vt;
|
|
|
|
pLn->setStartPoint(ptGe[0]);
|
|
pLn->setEndPoint(ptGe[1]);
|
|
}
|
|
|
|
#ifndef KEY_2DStyle
|
|
#define KEY_2DStyle _T("2dStl")
|
|
#endif
|
|
|
|
Acad::ErrorStatus AecDbPipeHanger::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int nMode = 0,n2dStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_MODE, nMode);
|
|
m_mapSpecXData.GetAt(KEY_2DStyle, n2dStyle);
|
|
|
|
AcGePoint3d pt0, pt1, ptM;
|
|
AcGeLineSeg3d ln;
|
|
|
|
if (nMode == 4)//弯管支座
|
|
{
|
|
for (int i = 0; i < m_arRecPts.length() - 1; i++)
|
|
{
|
|
ln.set(m_arRecPts.at(i), m_arRecPts.at(i + 1));
|
|
dc.DrawLine(ln);
|
|
}
|
|
|
|
if (m_arRecPts.length() >= 4)
|
|
{
|
|
ln.set(m_arRecPts.at(0), m_arRecPts.at(2));
|
|
dc.DrawLine(ln);
|
|
ln.set(m_arRecPts.at(1), m_arRecPts.at(3));
|
|
dc.DrawLine(ln);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
switch (n2dStyle)
|
|
{
|
|
case 0://[x]
|
|
{
|
|
for (int i = 0; i < m_arRecPts.length() - 1; i++)
|
|
{
|
|
ln.set(m_arRecPts.at(i), m_arRecPts.at(i + 1));
|
|
dc.DrawLine(ln);
|
|
}
|
|
|
|
if (m_arRecPts.length() >= 4)
|
|
{
|
|
ln.set(m_arRecPts.at(0), m_arRecPts.at(2));
|
|
dc.DrawLine(ln);
|
|
ln.set(m_arRecPts.at(1), m_arRecPts.at(3));
|
|
dc.DrawLine(ln);
|
|
}
|
|
break;
|
|
}
|
|
case 1://*---*
|
|
{
|
|
Midpoint(m_arRecPts.at(0), m_arRecPts.at(3),pt0);
|
|
Midpoint(m_arRecPts.at(1), m_arRecPts.at(2),pt1);
|
|
ln.set(pt0, pt1);
|
|
dc.DrawLine(ln);
|
|
|
|
Get45Pts(pt0, pt1, ln,m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
|
|
dc.DrawLine(ln);
|
|
|
|
Get45Pts(pt0, pt1, ln,m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
|
|
dc.DrawLine(ln);
|
|
|
|
Get45Pts(pt1, pt0, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
|
|
dc.DrawLine(ln);
|
|
|
|
Get45Pts(pt1, pt0, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
|
|
dc.DrawLine(ln);
|
|
|
|
break;
|
|
}
|
|
case 2://--*--
|
|
{
|
|
Midpoint(m_arRecPts.at(0), m_arRecPts.at(3), pt0);
|
|
Midpoint(m_arRecPts.at(1), m_arRecPts.at(2), pt1);
|
|
ln.set(pt0, pt1);
|
|
dc.DrawLine(ln);
|
|
|
|
Midpoint(pt0,pt1,ptM);
|
|
|
|
Get45Pts(ptM, pt0, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
|
|
dc.DrawLine(ln);
|
|
|
|
Get45Pts(ptM, pt0, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
|
|
dc.DrawLine(ln);
|
|
|
|
Get45Pts(ptM, pt1, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
|
|
dc.DrawLine(ln);
|
|
|
|
Get45Pts(ptM, pt1, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
|
|
dc.DrawLine(ln);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//获取二维视图显示的图形
|
|
int AecDbPipeHanger::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecDbObjXDataMap xData;
|
|
xData.CopyFrom(&m_mapSpecXData);
|
|
|
|
AcDbLine* pLn = NULL;
|
|
int nMode = 0, n2dStyle = 0;
|
|
m_mapSpecXData.GetAt(KEY_MODE, nMode);
|
|
m_mapSpecXData.GetAt(KEY_2DStyle, n2dStyle);
|
|
|
|
AcGePoint3d pt0, pt1, ptM;
|
|
AcGeLineSeg3d ln;
|
|
|
|
if (nMode == 4)//弯管支座
|
|
{
|
|
for (int i = 0; i < m_arRecPts.length() - 1; i++)
|
|
{
|
|
pLn = new AcDbLine(m_arRecPts.at(i), m_arRecPts.at(i + 1));
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
}
|
|
|
|
if (m_arRecPts.length() >= 4)
|
|
{
|
|
pLn = new AcDbLine(m_arRecPts.at(0), m_arRecPts.at(2));
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
pLn = new AcDbLine(m_arRecPts.at(1), m_arRecPts.at(3));
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
}
|
|
return arEntPtrs.length();
|
|
}
|
|
|
|
switch (n2dStyle)
|
|
{
|
|
case 0://[x]
|
|
{
|
|
for (int i = 0; i < m_arRecPts.length() - 1; i++)
|
|
{
|
|
pLn = new AcDbLine(m_arRecPts.at(i), m_arRecPts.at(i + 1));
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
}
|
|
|
|
if (m_arRecPts.length() >= 4)
|
|
{
|
|
pLn = new AcDbLine(m_arRecPts.at(0), m_arRecPts.at(2));
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
pLn = new AcDbLine(m_arRecPts.at(1), m_arRecPts.at(3));
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
}
|
|
break;
|
|
}
|
|
case 1://*---*
|
|
{
|
|
Midpoint(m_arRecPts.at(0), m_arRecPts.at(3), pt0);
|
|
Midpoint(m_arRecPts.at(1), m_arRecPts.at(2), pt1);
|
|
|
|
pLn = new AcDbLine(pt0, pt1);
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
pLn = new AcDbLine;
|
|
Get45Pts(pt0, pt1, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
pLn = new AcDbLine;
|
|
Get45Pts(pt0, pt1, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
pLn = new AcDbLine;
|
|
Get45Pts(pt1, pt0, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
pLn = new AcDbLine;
|
|
Get45Pts(pt1, pt0, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
break;
|
|
}
|
|
case 2://--*--
|
|
{
|
|
Midpoint(m_arRecPts.at(0), m_arRecPts.at(3), pt0);
|
|
Midpoint(m_arRecPts.at(1), m_arRecPts.at(2), pt1);
|
|
|
|
pLn = new AcDbLine(pt0, pt1);
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
Midpoint(pt0, pt1, ptM);
|
|
|
|
pLn = new AcDbLine;
|
|
Get45Pts(ptM, pt0, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
pLn = new AcDbLine;
|
|
Get45Pts(ptM, pt0, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
pLn = new AcDbLine;
|
|
Get45Pts(ptM, pt1, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
pLn = new AcDbLine;
|
|
Get45Pts(ptM, pt1, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
|
|
pLn->setLayer(layerId());
|
|
xData.Write(pLn, BIMDATA_APP);
|
|
arEntPtrs.append(pLn);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return arEntPtrs.length();
|
|
}
|
|
|
|
//获取三维显示图形
|
|
int AecDbPipeHanger::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs, bool bWriteBimInfo) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecDbObjXDataMap xData;
|
|
xData.CopyFrom(&m_mapSpecXData);
|
|
|
|
AcDbEntity* pEnt = NULL, *pEntClone = NULL;
|
|
for (int i = 0;i < m_ar3DSlds.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)m_ar3DSlds.at(i);
|
|
pEntClone = (AcDbEntity*)pEnt->clone();
|
|
|
|
pEntClone->setLayer(layerId());
|
|
if (bWriteBimInfo)
|
|
{
|
|
m_mapSpecXData.Write(pEntClone, BIMDATA_APP);
|
|
}
|
|
arEntPtrs.append(pEntClone);
|
|
}
|
|
return arEntPtrs.length();
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPipeHanger::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
BOOL nHlr = 0;
|
|
const AecDbObjXDataMap *pMap(&m_mapSpecXData);
|
|
const_cast<AecDbObjXDataMap *>(pMap)->GetAt(HLR_CALC, nHlr);
|
|
if (nHlr)
|
|
return Acad::eOk;
|
|
|
|
AcCmTransparency tr = transparency();
|
|
|
|
//管线系统屏蔽掉
|
|
if (dc.IsDragging())
|
|
{
|
|
//return Acad::eOk;
|
|
}
|
|
|
|
//图层
|
|
AcDbObjectId idLay = dc.GetLayerId();
|
|
dc.SetLayer(layerId());
|
|
|
|
int nCrBk = dc.GetColor();
|
|
int nColor = nCrBk;
|
|
if (m_mapSpecXData.GetAt(_T("COLOR"), nColor))
|
|
{
|
|
dc.SetColor(nColor);
|
|
}
|
|
|
|
if (!m_ar3DSlds.isEmpty())
|
|
{
|
|
AcDbEntity *pEnt = NULL;
|
|
for (int i = 0; i < m_ar3DSlds.length(); i++)
|
|
{
|
|
pEnt = (AcDbEntity *)m_ar3DSlds.at(i);
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
|
|
dc.SetLayer(idLay);
|
|
dc.SetColor(nCrBk);
|
|
return Acad::eOk;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AecDbObjXDataMap *AecDbPipeHanger::GetSpecialtyData(AcDb::OpenMode bMode/* = AcDb::kForWrite*/)
|
|
{
|
|
switch (bMode)
|
|
{
|
|
case AcDb::kForRead:
|
|
{
|
|
assertReadEnabled();
|
|
break;
|
|
}
|
|
case AcDb::kForWrite:
|
|
{
|
|
if (!isWriteEnabled())
|
|
{
|
|
upgradeOpen();
|
|
}
|
|
assertWriteEnabled();
|
|
break;
|
|
}
|
|
case AcDb::kForNotify:
|
|
{
|
|
assertReadEnabled();
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
const AecDbObjXDataMap *AecDbPipeHanger::GetSpecialtyData() const
|
|
{
|
|
assertReadEnabled();
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPipeHanger::subGetGripPoints(AcDbGripDataPtrArray &grips,
|
|
const double curViewUnitSize,
|
|
const int gripSize,
|
|
const AcGeVector3d &curViewDir,
|
|
const int bitflags) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int i = 0;
|
|
AcDbGripData* pGripData = new AcDbGripData;
|
|
memset(&m_pGripAppData[i], 0, sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = eStart;
|
|
m_pGripAppData[i].ptGrip = m_ptIns;
|
|
m_pGripAppData[i].nColor = kBlue;
|
|
_tcscpy(m_pGripAppData[i].szTip, _T("位置夹点"));
|
|
m_pGripAppData[i].pOwner = (AcDbEntity *)this;
|
|
m_pGripAppData[i].idHost = objectId();
|
|
|
|
pGripData->setGripPoint(m_ptIns);
|
|
pGripData->setAppData((void *)&m_pGripAppData[i]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
grips.append(pGripData);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPipeHanger::subMoveGripPointsAt(const AcDbVoidPtrArray &appData, const AcGeVector3d &offset, const int bitflags)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
m_ptIns += offset;
|
|
|
|
AcGePoint3d pt = m_ptIns;
|
|
double dRot = m_dRot;
|
|
Insert(pt, dRot);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::AddVar(AecDbObjXDataMap *pXData)
|
|
{
|
|
assertWriteEnabled();
|
|
m_mapSpecXData.SetAt(_T("PI"), 3.1415926);
|
|
return m_mapSpecXData.AppendFrom(pXData);
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::GetVar(AecDbObjXDataMap& xData) const
|
|
{
|
|
assertReadEnabled();
|
|
xData.CopyFrom(&m_mapSpecXData);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::CLC(CString &sTxt)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
CString sKey, sVal;
|
|
AecXData xData;
|
|
AecDbObjXDataMap::It it = m_mapSpecXData.Begin();
|
|
AecDbObjXDataMap::It end = m_mapSpecXData.End();
|
|
KTExpressCalc cal;
|
|
|
|
for (; it != end; )
|
|
{
|
|
m_mapSpecXData.GetNext(it, sKey, xData);
|
|
if (xData.nVt == VT_UI4 ||
|
|
xData.nVt == VT_I4)
|
|
{
|
|
cal.SetVariableData(sKey, 1.0 * xData.nVal);
|
|
}
|
|
else if (xData.nVt == VT_R8)
|
|
{
|
|
cal.SetVariableData(sKey, xData.dVal[0]);
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
}
|
|
}
|
|
|
|
double dVal = 0.0;
|
|
if (cal.Calculate(sTxt, dVal))
|
|
sTxt.Format(_T("%.3f"), dVal);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::AddLine(LPCTSTR pszLine)
|
|
{
|
|
assertWriteEnabled();
|
|
CString sLine = pszLine;
|
|
int nPos = sLine.Find(_T(';'));
|
|
if (nPos == 0)
|
|
return FALSE;
|
|
|
|
m_arLines.Add(pszLine);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::LoadPmsFile(LPCTSTR pszSrcFullFile)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
CStdioFile file;
|
|
if (file.Open(pszSrcFullFile, CFile::modeRead | CFile::typeText))
|
|
{
|
|
m_arLines.RemoveAll();
|
|
FreeBuffer(m_ar3DSlds);
|
|
|
|
CString sLn;
|
|
while (file.ReadString(sLn))
|
|
{
|
|
sLn.TrimRight();
|
|
AddLine(sLn);
|
|
}
|
|
file.Close();
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::SetElbow(AcDbArc* pElbowBase, double dOD)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
m_pElbowArc = pElbowBase;
|
|
m_dElbowOD = dOD;
|
|
return TRUE;
|
|
}
|
|
|
|
void AecDbPipeHanger::CLC(CStringArray &arLt)
|
|
{
|
|
CString sTmp;
|
|
for (int i = 0; i < arLt.GetSize(); i++)
|
|
{
|
|
sTmp = arLt.GetAt(i);
|
|
CLC(sTmp);
|
|
arLt.SetAt(i, sTmp);
|
|
}
|
|
}
|
|
|
|
static AcDbRegion *CreateFromPoints(AcGePoint3dArray& arPts)
|
|
{
|
|
AcDbLine *pLn = NULL;
|
|
AcDbVoidPtrArray arLns;
|
|
for (int i = 0; i < arPts.length() - 1; i++)
|
|
{
|
|
pLn = new AcDbLine(arPts.at(i), arPts.at(i + 1));
|
|
arLns.append(pLn);
|
|
}
|
|
|
|
AcDbVoidPtrArray arRgs;
|
|
AcDbRegion::createFromCurves(arLns, arRgs);
|
|
|
|
FreeBuffer(arLns);
|
|
//TEST
|
|
/*static int nColor = 1;
|
|
AcDbEntity *pEnt = NULL;
|
|
while (!arLns.isEmpty())
|
|
{
|
|
pEnt = (AcDbEntity *)arLns.last();
|
|
pEnt->setColorIndex(nColor);
|
|
AddToModelSpace(pEnt);
|
|
arLns.removeLast();
|
|
}
|
|
nColor += 1;*/
|
|
|
|
if (!arRgs.isEmpty())
|
|
{
|
|
return (AcDbRegion *)arRgs.first();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
AcDbRegion *AecDbPipeHanger::AI(CStringArray& arLt,AcGePoint3d& ptOrg)
|
|
{
|
|
if (arLt.GetSize() >= 8)
|
|
{
|
|
CLC(arLt);
|
|
|
|
double dL = _ttof(arLt.GetAt(0)), dt = _ttof(arLt.GetAt(1));
|
|
|
|
AcGeVector3d vtX(_ttof(arLt[2]), _ttof(arLt[3]), _ttof(arLt[4]));
|
|
AcGeVector3d vtY(_ttof(arLt[5]), _ttof(arLt[6]), _ttof(arLt[7]));
|
|
vtX.normalize(); vtY.normalize();
|
|
|
|
AcGePoint3d pt = ptOrg, pt1;
|
|
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(pt);
|
|
|
|
pt += vtX * dL;
|
|
arPts.append(pt);
|
|
|
|
pt += vtY * dt;
|
|
arPts.append(pt);
|
|
|
|
double dX1 = (dL - dt);
|
|
pt -= vtX * dX1;
|
|
arPts.append(pt);
|
|
|
|
pt += vtY * dX1;
|
|
arPts.append(pt);
|
|
|
|
pt -= vtX * dt;
|
|
arPts.append(pt);
|
|
|
|
arPts.append(arPts.first());
|
|
|
|
return CreateFromPoints(arPts);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
AcDbRegion *AecDbPipeHanger::CS(CStringArray& arLt, AcGePoint3d& ptOrg)
|
|
{
|
|
if (arLt.GetSize() >= 9)
|
|
{
|
|
CLC(arLt);
|
|
|
|
double dL = _ttof(arLt.GetAt(0));
|
|
double dt = _ttof(arLt.GetAt(1));
|
|
double db = _ttof(arLt.GetAt(2));
|
|
|
|
AcGeVector3d vtX(_ttof(arLt[3]), _ttof(arLt[4]), _ttof(arLt[5]));
|
|
AcGeVector3d vtY(_ttof(arLt[6]), _ttof(arLt[7]), _ttof(arLt[8]));
|
|
vtX.normalize(); vtY.normalize();
|
|
|
|
AcGePoint3d pt = ptOrg, pt1;
|
|
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(pt);
|
|
|
|
pt += vtX * dL;
|
|
arPts.append(pt);
|
|
|
|
pt += vtY * db;
|
|
arPts.append(pt);
|
|
|
|
pt -= vtX * dt;
|
|
arPts.append(pt);
|
|
|
|
double dbt = (db - dt);
|
|
pt -= vtY * dbt;
|
|
arPts.append(pt);
|
|
|
|
double dl2t = (dL - 2.0 * dt);
|
|
pt -= vtX * dl2t;
|
|
arPts.append(pt);
|
|
|
|
pt += vtY * dbt;
|
|
arPts.append(pt);
|
|
|
|
pt -= vtX * dt;
|
|
arPts.append(pt);
|
|
|
|
arPts.append(arPts.first());
|
|
|
|
return CreateFromPoints(arPts);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
AcDbRegion *AecDbPipeHanger::RX(CStringArray &arLt, AcGePoint3d &ptOrg)
|
|
{
|
|
if (arLt.GetSize() >= 8)
|
|
{
|
|
CLC(arLt);
|
|
|
|
double dX = _ttof(arLt.GetAt(0));
|
|
double dY = _ttof(arLt.GetAt(1));
|
|
|
|
AcGeVector3d vtX(_ttof(arLt[2]), _ttof(arLt[3]), _ttof(arLt[4]));
|
|
AcGeVector3d vtY(_ttof(arLt[5]), _ttof(arLt[6]), _ttof(arLt[7]));
|
|
vtX.normalize(); vtY.normalize();
|
|
|
|
AcGePoint3d pt = ptOrg;
|
|
AcGePoint3dArray arPts;
|
|
|
|
pt -= vtX * 0.5 * dX;
|
|
pt -= vtY * 0.5 * dY;
|
|
arPts.append(pt);
|
|
|
|
pt += vtX * dX;
|
|
arPts.append(pt);
|
|
|
|
pt += vtY * dY;
|
|
arPts.append(pt);
|
|
|
|
pt -= vtX * dX;
|
|
arPts.append(pt);
|
|
|
|
arPts.append(arPts.first());
|
|
|
|
return CreateFromPoints(arPts);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::Ex(AcDbRegion* pRg, const AcGePoint3d& pt0, const AcGePoint3d & pt1, BOOL bDelRg)
|
|
{
|
|
if (pRg != NULL)
|
|
{
|
|
AcDbLine ln(pt0, pt1);
|
|
return Ex(pRg, &ln, 0.0, bDelRg);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static void Mir(AcGePoint3dArray& arPts, AcGePoint3d& ptOrg, AcGeVector3d& vtN)
|
|
{
|
|
AcGePlane plan;
|
|
plan.set(ptOrg, vtN);
|
|
|
|
AcGePoint3dArray arPts2;
|
|
arPts2.append(arPts);
|
|
|
|
AcGePoint3d pt;
|
|
while(!arPts2.isEmpty())
|
|
{
|
|
pt = arPts2.last();
|
|
arPts2.removeLast();
|
|
|
|
pt.mirror(plan);
|
|
arPts.append(pt);
|
|
}
|
|
}
|
|
|
|
AcDbRegion* AecDbPipeHanger::HS(CStringArray& arLt, AcGePoint3d& ptOrg)
|
|
{
|
|
if (arLt.GetSize() >= 10)
|
|
{
|
|
CLC(arLt);
|
|
|
|
double dH = _ttof(arLt.GetAt(0));
|
|
double dB = _ttof(arLt.GetAt(1));
|
|
double dt1 = _ttof(arLt.GetAt(2));
|
|
double dt2 = _ttof(arLt.GetAt(3));
|
|
|
|
AcGeVector3d vtX(_ttof(arLt[4]), _ttof(arLt[5]), _ttof(arLt[6]));
|
|
AcGeVector3d vtZ(_ttof(arLt[7]), _ttof(arLt[8]), _ttof(arLt[9]));
|
|
vtX.normalize(); vtZ.normalize();
|
|
|
|
AcGePoint3d pt = ptOrg;
|
|
AcGePoint3dArray arPts;
|
|
|
|
pt += vtZ * dH;
|
|
pt += vtX * 0.5 * dB;
|
|
arPts.append(pt);
|
|
|
|
pt -= vtZ * dt2;
|
|
arPts.append(pt);
|
|
|
|
pt -= vtX * (0.5 * dB - 0.5 * dt1);
|
|
arPts.append(pt);
|
|
|
|
pt -= vtZ * (dH - 2.0 * dt2);
|
|
arPts.append(pt);
|
|
|
|
pt += vtX * (0.5 * dB - 0.5 * dt1);
|
|
arPts.append(pt);
|
|
|
|
pt -= vtZ * dt2;
|
|
arPts.append(pt);
|
|
|
|
Mir(arPts, ptOrg, vtX);
|
|
arPts.append(arPts.first());
|
|
|
|
return CreatePointsRegion(arPts);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
AcDbRegion* AecDbPipeHanger::PIP(CStringArray& arLt, AcGePoint3d& ptOrg)
|
|
{
|
|
if (arLt.GetSize() >= 5)
|
|
{
|
|
CLC(arLt);
|
|
|
|
double dID = _ttof(arLt.GetAt(0));
|
|
double dt = _ttof(arLt.GetAt(1));
|
|
|
|
AcGeVector3d vtN(_ttof(arLt[2]), _ttof(arLt[3]), _ttof(arLt[4]));
|
|
|
|
AcDbCircle cirI;
|
|
cirI.setCenter(ptOrg);
|
|
cirI.setRadius(0.5*dID);
|
|
cirI.setNormal(vtN);
|
|
|
|
AcDbCircle cirO;
|
|
cirO.setCenter(ptOrg);
|
|
cirO.setRadius(0.5*dID + dt);
|
|
cirO.setNormal(vtN);
|
|
|
|
AcDbRegion *pRgO = CreateRegFromCurve(cirO);
|
|
if (pRgO != NULL)
|
|
{
|
|
if (dt < 1.e-6)
|
|
{
|
|
return pRgO;
|
|
}
|
|
else
|
|
{
|
|
AcDbRegion *pRgI = CreateRegFromCurve(cirI);
|
|
if (pRgI != NULL)
|
|
{
|
|
if (Acad::eOk == pRgO->booleanOper(AcDb::kBoolSubtract, pRgI))
|
|
{
|
|
return pRgO;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::EX(CString &sLn)
|
|
{
|
|
int nPos1 = -1, nPos2 = -1;
|
|
nPos1 = sLn.Find(_T('('));
|
|
nPos2 = sLn.Find(_T(')'));
|
|
|
|
CString sTxt,sXYZ;
|
|
CStringArray arTxts;
|
|
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
//pt ...
|
|
sTxt = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
ExtractSubString(sTxt, _T(","), arTxts);
|
|
|
|
AcGeDoubleArray arVals;
|
|
for (int j = 0;j < arTxts.GetSize();j++)
|
|
{
|
|
sXYZ = arTxts.GetAt(j);
|
|
CLC(sXYZ);
|
|
|
|
arVals.append(_ttof(sXYZ));
|
|
}
|
|
|
|
if (arVals.length() >= 6)
|
|
{
|
|
AcGePoint3d pt0(arVals[0], arVals[1], arVals[2]);
|
|
AcGePoint3d pt1(arVals[3], arVals[4], arVals[5]);
|
|
CString sSec, sLt;
|
|
CStringArray arLt;
|
|
|
|
nPos1 = sLn.Find( _T(':') );
|
|
if (nPos1 != -1)
|
|
{
|
|
sSec = sLn.Mid(nPos1 + 1);
|
|
|
|
if (sSec.Find(_T("AI")) != -1)
|
|
{
|
|
nPos1 = sSec.Find(_T('('));
|
|
nPos2 = sSec.Find(_T(')'));
|
|
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
sLt = sSec.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
ExtractSubString(sLt, _T(","), arLt);
|
|
|
|
if (arLt.GetSize() >= 8)
|
|
{
|
|
AcDbRegion *pRg = AI(arLt, pt0);
|
|
if (pRg != NULL)
|
|
{
|
|
Ex(pRg, pt0, pt1,TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (sSec.Find(_T("CS")) != -1)
|
|
{
|
|
nPos1 = sSec.Find(_T('('));
|
|
nPos2 = sSec.Find(_T(')'));
|
|
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
sLt = sSec.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
ExtractSubString(sLt, _T(","), arLt);
|
|
|
|
if (arLt.GetSize() >= 9)
|
|
{
|
|
CString sb = arLt.GetAt(2);
|
|
CLC(sb);
|
|
|
|
double db = _ttof(sb);
|
|
if (db < 1.e-3)//L
|
|
{
|
|
arLt.RemoveAt(2);
|
|
AcDbRegion *pRg = AI(arLt, pt0);
|
|
if (pRg != NULL)
|
|
{
|
|
Ex(pRg, pt0, pt1, TRUE);
|
|
}
|
|
}
|
|
else//[
|
|
{
|
|
AcDbRegion *pRg = CS(arLt, pt0);
|
|
if (pRg != NULL)
|
|
{
|
|
Ex(pRg, pt0, pt1, TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (sSec.Find(_T("RX")) != -1)
|
|
{
|
|
nPos1 = sSec.Find(_T('('));
|
|
nPos2 = sSec.Find(_T(')'));
|
|
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
sLt = sSec.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
ExtractSubString(sLt, _T(","), arLt);
|
|
|
|
if (arLt.GetSize() >= 8)
|
|
{
|
|
AcDbRegion *pRg = RX(arLt, pt0);
|
|
if (pRg != NULL)
|
|
{
|
|
Ex(pRg, pt0, pt1, TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (sSec.Find(_T("PL")) != -1)
|
|
{
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
|
|
}
|
|
}
|
|
else if (sSec.Find(_T("HS")) != -1)
|
|
{
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
nPos1 = sSec.Find(_T('('));
|
|
nPos2 = sSec.Find(_T(')'));
|
|
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
sLt = sSec.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
ExtractSubString(sLt, _T(","), arLt);
|
|
|
|
if (arLt.GetSize() >= 10)
|
|
{
|
|
AcDbRegion* pRg = HS(arLt, pt0);
|
|
if (pRg != NULL)
|
|
{
|
|
Ex(pRg, pt0, pt1, TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (sSec.Find(_T("PIP")) != -1)
|
|
{
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
nPos1 = sSec.Find(_T('('));
|
|
nPos2 = sSec.Find(_T(')'));
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
sLt = sSec.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
ExtractSubString(sLt, _T(","), arLt);
|
|
|
|
if (arLt.GetSize() >= 5)
|
|
{
|
|
AcDbRegion* pRg = PIP(arLt, pt0);
|
|
if (pRg != NULL)
|
|
{
|
|
Ex(pRg, pt0, pt1, TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::SLC(CString &sLn)
|
|
{
|
|
int nPos1 = sLn.Find(_T('('));
|
|
int nPos2 = sLn.Find(_T(')'));
|
|
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
CString sTxt;
|
|
sTxt = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
|
|
CStringArray arXYZ;
|
|
ExtractSubString(sTxt, _T(","), arXYZ);
|
|
|
|
for (int i = 0;i < arXYZ.GetSize();i++)
|
|
{
|
|
sTxt = arXYZ.GetAt(i);
|
|
CLC(sTxt);
|
|
|
|
arXYZ.SetAt(i, sTxt);
|
|
}
|
|
|
|
if (arXYZ.GetSize() == 6)
|
|
{
|
|
AcGePoint3d ptOrg( _ttof(arXYZ[0]), _ttof(arXYZ[1]), _ttof(arXYZ[2]));
|
|
AcGeVector3d vtNm( _ttof(arXYZ[3]), _ttof(arXYZ[4]), _ttof(arXYZ[5]));
|
|
|
|
AcGePlane pln;
|
|
pln.set(ptOrg, vtNm);
|
|
|
|
if ( !m_ar3DSlds.isEmpty() )
|
|
{
|
|
AcDb3dSolid *pSld = (AcDb3dSolid *)m_ar3DSlds.last();
|
|
if (pSld != NULL)
|
|
{
|
|
AcDb3dSolid *pNeg = NULL;
|
|
if (Acad::eOk == pSld->getSlice(pln, Adesk::kFalse, pNeg))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::NUT(AcGePoint3d& pt, CString& sMx, const AcGeVector3d& vtDir,AcGePoint3d& ptTo,BOOL bGst)
|
|
{
|
|
CString sMxKey;
|
|
sMxKey.Format(_T("M%d"), _ttoi(sMx));
|
|
|
|
AcGePoint2d ptMs;
|
|
if (!g_mapMx.Lookup(sMxKey, ptMs))
|
|
return FALSE;
|
|
|
|
int nDn = _ttoi(sMx);
|
|
|
|
AcGeVector3d vtP = vtDir.perpVector();
|
|
vtP.normalize();
|
|
|
|
double dR = 0.5 * ptMs.y / cos(PI / 6.0);
|
|
AcGePoint3d pt2 = pt + vtP * dR;
|
|
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(pt2);
|
|
|
|
for (int i = 0; i < 6; i++)
|
|
{
|
|
pt2.rotateBy(PI / 3.0, vtDir, pt);
|
|
arPts.append(pt2);
|
|
}
|
|
|
|
AcDbRegion *pRg = CreatePointsRegion(arPts);
|
|
if (pRg != NULL)
|
|
{
|
|
AcDbEntity *p3dEnt = NULL;
|
|
if (bGst)
|
|
{
|
|
AcDbRegion *pRgGst = CreateCirRegion(pt, dR, vtDir);
|
|
if (pRgGst != NULL)
|
|
{
|
|
AcGePoint3d pt1 = pt + vtDir * 1.5;
|
|
AcDbLine ln2(pt, pt1);
|
|
Ex(pRgGst, &ln2);
|
|
}
|
|
}
|
|
|
|
AcGeVector3d vtM;
|
|
vtM = vtDir;
|
|
if (bGst)
|
|
{
|
|
vtM *= 1.5;
|
|
AcGeMatrix3d xM;
|
|
xM.setToTranslation(vtM);
|
|
pRg->transformBy(xM);
|
|
}
|
|
|
|
AcGePoint3d ptF, ptT;
|
|
ptF = pt + vtM;
|
|
ptT = ptF + ptMs.x * vtDir;
|
|
ptTo = ptT;
|
|
AcDbLine ln1(ptF, ptT);
|
|
Ex(pRg, &ln1);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::PZT(AcGePoint3d &pt, CString &sMx, AcGeVector3d &vtDir)
|
|
{
|
|
CString sMxKey;
|
|
sMxKey.Format(_T("M%d"), _ttoi(sMx));
|
|
|
|
AcGePoint2d ptMs;
|
|
if (!g_mapMx.Lookup(sMxKey, ptMs))
|
|
return FALSE;
|
|
|
|
int nDn = _ttoi(sMx);
|
|
|
|
AcGeVector3d vtP = vtDir.perpVector();
|
|
vtP.normalize();
|
|
|
|
double dR = 0.5 * ptMs.y;
|
|
AcDbRegion *pRg = CreateCirRegion(pt, dR, vtDir);
|
|
if (pRg != NULL)
|
|
{
|
|
AcDbEntity *p3dEnt = NULL;
|
|
|
|
AcGeVector3d vtM;
|
|
vtM = vtDir;
|
|
|
|
AcGePoint3d ptF, ptT;
|
|
ptF = pt + vtM;
|
|
ptT = ptF + ptMs.x * vtDir;
|
|
AcDbLine ln1(ptF, ptT);
|
|
Ex(pRg, &ln1, PI / 36.0,TRUE);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::SCR(AcGePoint3d &pt, CString &sMx, const AcGeVector3d &vtDir, double dL)
|
|
{
|
|
CString sMxKey;
|
|
sMxKey.Format(_T("M%d"), _ttoi(sMx));
|
|
|
|
AcGePoint2d ptMs;
|
|
if (!g_mapMx.Lookup(sMxKey, ptMs))
|
|
return FALSE;
|
|
|
|
int nDn = _ttoi(sMx);
|
|
|
|
AcDbRegion *pRgH = CreateCirRegion(pt, 0.5 * nDn, vtDir);
|
|
if (pRgH != NULL)
|
|
{
|
|
AcGePoint3d pt1 = pt + vtDir * dL;
|
|
AcDbLine ln2(pt, pt1);
|
|
Ex(pRgH, &ln2);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::Blt(AcGePoint3d& pt, CString& sMx, AcGeVector3d& vtDir,double dL,int nNutE)
|
|
{
|
|
AcGeVector3d vt = vtDir;
|
|
vt.negate();
|
|
|
|
AcGePoint3d ptTo1;
|
|
NUT(pt, sMx, vt,ptTo1,TRUE);
|
|
|
|
SCR(pt,sMx,vtDir,dL);
|
|
|
|
if (nNutE > 0)
|
|
{
|
|
pt += vtDir * dL;
|
|
vtDir.negate();
|
|
|
|
AcGePoint3d ptTo2;
|
|
NUT(pt, sMx, vt, ptTo2, FALSE);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * dL;
|
|
vtDir.negate();
|
|
PZT(pt, sMx, vt);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::BLT(CString &sLn)
|
|
{
|
|
int nPos1 = sLn.Find(_T('('));
|
|
int nPos2 = sLn.Find(_T(')'));
|
|
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
CString sBt = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
|
|
CStringArray arTxts;
|
|
ExtractSubString(sBt, _T(","), arTxts);
|
|
|
|
CString sTx;
|
|
for (int i = 0;i < arTxts.GetSize();i++)
|
|
{
|
|
sTx = arTxts.GetAt(i);
|
|
CLC(sTx);
|
|
|
|
arTxts.SetAt(i, sTx);
|
|
}
|
|
|
|
int nNutE = 1;
|
|
if (arTxts.GetSize() > 8)
|
|
{
|
|
nNutE = _ttoi(arTxts.GetAt(arTxts.GetSize()-1));
|
|
}
|
|
|
|
if (arTxts.GetSize() >= 8)
|
|
{
|
|
AcGePoint3d pt(_ttof(arTxts[0]), _ttof(arTxts[1]), _ttof(arTxts[2]));
|
|
CString sMx = arTxts.GetAt(3);
|
|
|
|
AcGeVector3d vtDir(_ttof(arTxts[4]), _ttof(arTxts[5]), _ttof(arTxts[6]));
|
|
double dL = _ttof(arTxts[7]);
|
|
|
|
return Blt(pt,sMx,vtDir,dL,nNutE);
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::Ex(double dr, AcDbCurve* pCur)
|
|
{
|
|
if (pCur != NULL)
|
|
{
|
|
AcGeVector3d vtN;
|
|
double dS = 0.0;
|
|
pCur->getStartParam(dS);
|
|
pCur->getFirstDeriv(dS, vtN);
|
|
|
|
AcGePoint3d ptS;
|
|
pCur->getStartPoint(ptS);
|
|
|
|
AcDbCircle cir;
|
|
cir.setCenter(ptS);
|
|
cir.setRadius(dr);
|
|
cir.setNormal(vtN);
|
|
|
|
AcDbRegion *pRg = CreateRegFromCurve(cir);
|
|
if (pRg != NULL)
|
|
{
|
|
Acad::ErrorStatus es;
|
|
AcDb3dSolid *pSolid = new AcDb3dSolid;
|
|
if (Acad::eOk == (es = pSolid->extrudeAlongPath(pRg, pCur)))
|
|
{
|
|
m_ar3DSlds.append(pSolid);
|
|
delete pRg;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
delete pRg;
|
|
delete pSolid;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::Ex(AcDbRegion* pRg, AcDbCurve* pCur, double dTrag, BOOL bDeleteRg)
|
|
{
|
|
if (pRg != NULL)
|
|
{
|
|
Acad::ErrorStatus es;
|
|
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
|
if (Acad::eOk == (es = pSolid->extrudeAlongPath(pRg, pCur,dTrag)))
|
|
{
|
|
m_ar3DSlds.append(pSolid);
|
|
if (bDeleteRg) delete pRg;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (bDeleteRg) delete pRg;
|
|
delete pSolid;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::PCP(CString &sLn)
|
|
{
|
|
return PCP6(sLn);
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::PCP5(CString &sLn)
|
|
{
|
|
int nPos1 = sLn.Find(_T('('));
|
|
int nPos2 = sLn.Find(_T(')'));
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
CString sPIPECP = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
|
|
AcGeVector3d vtPip = AcGeVector3d::kYAxis;
|
|
AcGeVector3d vtNUT = AcGeVector3d::kZAxis;
|
|
|
|
int nNPs1 = sLn.Find(_T('['));
|
|
int nNPs2 = sLn.Find(_T(']'));
|
|
if (nNPs1 != -1 && nNPs2 != -1)
|
|
{
|
|
CString sPipeDir = sLn.Mid(nNPs1 + 1, nNPs2 - nNPs1 - 1);
|
|
|
|
CStringArray arXYZ;
|
|
ExtractSubString(sPipeDir, _T(","), arXYZ);
|
|
if (arXYZ.GetSize() == 3)
|
|
{
|
|
vtPip.set(_ttof(arXYZ[0]), _ttof(arXYZ[1]), _ttof(arXYZ[2]));
|
|
}
|
|
}
|
|
|
|
CStringArray arTxts;
|
|
ExtractSubString(sPIPECP, _T(","), arTxts);
|
|
|
|
CString sTxt;
|
|
for (int i = 0; i < arTxts.GetSize(); i++)
|
|
{
|
|
sTxt = arTxts.GetAt(i);
|
|
CLC(sTxt);
|
|
arTxts.SetAt(i, sTxt);
|
|
}
|
|
|
|
if (arTxts.GetSize() >= 17)
|
|
{
|
|
AcGePoint3d ptPos(_ttof(arTxts[0]), _ttof(arTxts[1]), _ttof(arTxts[2]));
|
|
AcGeVector3d vtDir(_ttof(arTxts[3]), _ttof(arTxts[4]), _ttof(arTxts[5]));
|
|
|
|
vtNUT = vtDir.crossProduct(vtPip);//XxY=Z
|
|
vtNUT.normalize();//Z
|
|
|
|
double dA = _ttof(arTxts[12]);
|
|
double dt = _ttof(arTxts[15]);
|
|
double dH = _ttof(arTxts[10]);
|
|
double dd = _ttof(arTxts.GetAt(8));
|
|
double dR = _ttof(arTxts.GetAt(7));
|
|
double dw = _ttof(arTxts.GetAt(13));
|
|
double db = _ttof(arTxts.GetAt(14));
|
|
CString sMx = arTxts.GetAt(6);
|
|
|
|
AcGePoint3d ptNut1, ptNut2, ptA1, ptA2, ptNs, ptNe,ptNut11,ptNut22;
|
|
ptNut1 = ptPos;
|
|
|
|
ptNut1 -= vtDir * 0.5 * dA;
|
|
ptNut1 -= vtNUT * dt;
|
|
|
|
NUT(ptNut1, sMx, -vtNUT, ptNut11,TRUE);
|
|
|
|
ptNut2 = ptNut1 + vtDir * dA;
|
|
NUT(ptNut2, sMx, -vtNUT, ptNut22,TRUE);
|
|
|
|
double dLS = dR + dt;//不可以用H,H为冗长
|
|
ptA1 = ptNut1 + vtNUT * dLS;
|
|
ptA2 = ptNut2 + vtNUT * dLS;
|
|
|
|
ptNs = ptNut11 - vtNUT * 5.0;
|
|
ptNe = ptNut22 - vtNUT * 5.0;
|
|
|
|
AcDbLine ln(ptNs, ptA1);
|
|
Ex(0.5 * dd, &ln);
|
|
|
|
ln.setStartPoint(ptNe);
|
|
ln.setEndPoint(ptA2);
|
|
Ex(0.5 * dd, &ln);
|
|
|
|
AcGePoint3d ptCen = ptA1 + vtDir * 0.5 * dA;
|
|
AcDbArc arc;
|
|
arc.setCenter(ptCen);
|
|
arc.setRadius(0.5 * dA);
|
|
arc.setStartAngle(0);
|
|
arc.setEndAngle(PI);
|
|
arc.setNormal(vtPip);
|
|
|
|
Ex(0.5 * dd, &arc);
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::OMG(AcGePoint3d& ptPos, double dR, double dA, double da1, double db,double dt2,double dr,AcGeVector3d& vtDir)
|
|
{
|
|
AcGePoint3d pt;
|
|
AcDbPolyline pl;
|
|
pl.setNormal(AcGeVector3d::kYAxis);
|
|
pl.setElevation(ptPos.y);
|
|
|
|
AcGePlane pln(AcGePoint3d::kOrigin, AcGeVector3d::kYAxis);
|
|
|
|
int i = 0;
|
|
pt = ptPos;
|
|
pt += AcGeVector3d(0, 0, 1) * dt2;
|
|
|
|
pt -= vtDir * 0.5 * dA;
|
|
pt -= vtDir * da1;
|
|
pl.addVertexAt(i++, pt.convert2d(pln));
|
|
|
|
pt += vtDir * (2.0 * da1 - dr - 0.5 * dt2);
|
|
pl.addVertexAt(i++, pt.convert2d(pln), -tan(PI / 8.0));
|
|
|
|
pt += vtDir * dr;
|
|
pt += AcGeVector3d::kZAxis * dr;
|
|
pl.addVertexAt(i++, pt.convert2d(pln), 0);
|
|
|
|
pt += AcGeVector3d::kZAxis * (dR - dr - db);
|
|
pl.addVertexAt(i++, pt.convert2d(pln), 1.0);
|
|
|
|
pt += vtDir * (2.0 * dR + 2.0 * dt2);
|
|
pl.addVertexAt(i++, pt.convert2d(pln));
|
|
|
|
pt -= AcGeVector3d::kZAxis * (dR - dr - db);
|
|
pl.addVertexAt(i++, pt.convert2d(pln), -tan(PI / 8.0));
|
|
|
|
pt -= AcGeVector3d::kZAxis * dr;
|
|
pt += vtDir * dr;
|
|
pl.addVertexAt(i++, pt.convert2d(pln));
|
|
|
|
pt = ptPos;
|
|
pt += vtDir * 0.5 * dA;
|
|
pt += vtDir * da1;
|
|
pt += AcGeVector3d(0, 0, 1) * dt2;
|
|
pl.addVertexAt(i++, pt.convert2d(pln));
|
|
|
|
double dX = db;
|
|
double dY = dt2;
|
|
|
|
AcGeVector3d vtX = AcGeVector3d(0,1,0);
|
|
AcGeVector3d vtY = AcGeVector3d(0, 0, -1);
|
|
vtX.normalize(); vtY.normalize();
|
|
|
|
pt = ptPos;
|
|
pt += AcGeVector3d(0, 0, 1) * dt2;
|
|
|
|
pt -= vtDir * 0.5 * dA;
|
|
pt -= vtDir * da1;
|
|
|
|
AcGePoint3dArray arPts;
|
|
|
|
pt -= vtX * 0.5 * dX;
|
|
arPts.append(pt);
|
|
|
|
pt += vtX * dX;
|
|
arPts.append(pt);
|
|
|
|
pt += vtY * dY;
|
|
arPts.append(pt);
|
|
|
|
pt -= vtX * dX;
|
|
arPts.append(pt);
|
|
|
|
arPts.append(arPts.first());
|
|
|
|
AcDbRegion* pRg = CreateFromPoints(arPts);
|
|
return Ex(pRg, &pl);
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::PCP7(CString& sLn)
|
|
{
|
|
int nPos1 = sLn.Find(_T('('));
|
|
int nPos2 = sLn.Find(_T(')'));
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
CString sPIPECP = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
|
|
CStringArray arTxts;
|
|
ExtractSubString(sPIPECP, _T(","), arTxts);
|
|
|
|
CString sTxt;
|
|
for (int i = 0; i < arTxts.GetSize(); i++)
|
|
{
|
|
sTxt = arTxts.GetAt(i);
|
|
CLC(sTxt);
|
|
arTxts.SetAt(i, sTxt);
|
|
}
|
|
|
|
if (arTxts.GetSize() >= 20)
|
|
{
|
|
AcGePoint3d ptPos(_ttof(arTxts[0]), _ttof(arTxts[1]), _ttof(arTxts[2]));
|
|
AcGeVector3d vtDir(_ttof(arTxts[3]), _ttof(arTxts[4]), _ttof(arTxts[5]));
|
|
|
|
double dA = _ttof(arTxts[13]);
|
|
double dt3 = _ttof(arTxts[9]);
|
|
double dt2 = _ttof(arTxts[16]);
|
|
double dt1 = _ttof(arTxts[17]);
|
|
double dt_ = _ttof(arTxts[18]);
|
|
double dr = _ttof(arTxts[19]);
|
|
double da1 = _ttof(arTxts[10]);
|
|
double dR = _ttof(arTxts[7]);
|
|
double db = _ttof(arTxts[15]);
|
|
|
|
CString sMx = arTxts.GetAt(6);
|
|
|
|
AcGePoint3d ptNut1, ptNut2, ptA1, ptA2, ptNs, ptNe, ptNut11, ptNut22,pt;
|
|
ptNut1 = ptPos;
|
|
|
|
ptNut1 -= vtDir * 0.5 * dA;
|
|
ptNut1 -= AcGeVector3d::kZAxis * dt2;
|
|
|
|
NUT(ptNut1, sMx, -AcGeVector3d::kZAxis, ptNut11, TRUE);
|
|
|
|
SCR(ptNut1, sMx, AcGeVector3d(0, 0, 1), dt3 + dt2 );
|
|
|
|
ptNut2 = ptNut1 + vtDir * dA;
|
|
NUT(ptNut2, sMx, -AcGeVector3d::kZAxis, ptNut22, TRUE);
|
|
|
|
SCR(ptNut2, sMx, AcGeVector3d(0, 0, 1), dt3 + dt2 );
|
|
|
|
SCR(ptNut2, sMx, AcGeVector3d(0, 0, 1), dt3 + dt2);
|
|
|
|
ptNut1 = ptPos;
|
|
ptNut1 -= vtDir * 0.5 * dA;
|
|
ptNut1 += AcGeVector3d::kZAxis * dt1;
|
|
NUT(ptNut1, sMx, AcGeVector3d(0,0,1), ptNut11, TRUE);
|
|
|
|
SCR(ptNut11, sMx, AcGeVector3d(0, 0, 1), 5.0);
|
|
|
|
ptNut2 = ptNut1 + vtDir * dA;
|
|
NUT(ptNut2, sMx, AcGeVector3d(0,0,1), ptNut22, TRUE);
|
|
|
|
SCR(ptNut22, sMx, AcGeVector3d(0, 0, 1), 5.0);
|
|
|
|
OMG(ptPos,dR,dA,da1, db,dt1,dr,vtDir);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::PCP6(CString &sLn)
|
|
{
|
|
int nPos1 = sLn.Find(_T('('));
|
|
int nPos2 = sLn.Find(_T(')'));
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
CString sPIPECP = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
|
|
AcGeVector3d vtPip = AcGeVector3d::kYAxis;
|
|
AcGeVector3d vtNUT = AcGeVector3d::kZAxis;
|
|
|
|
int nNPs1 = sLn.Find(_T('['));
|
|
int nNPs2 = sLn.Find(_T(']'));
|
|
if (nNPs1 != -1 && nNPs2 != -1)
|
|
{
|
|
CString sPipeDir = sLn.Mid(nNPs1 + 1, nNPs2 - nNPs1 - 1);
|
|
|
|
CStringArray arXYZ;
|
|
ExtractSubString(sPipeDir, _T(","), arXYZ);
|
|
if (arXYZ.GetSize() == 3)
|
|
{
|
|
vtPip.set(_ttof(arXYZ[0]), _ttof(arXYZ[1]), _ttof(arXYZ[2]));
|
|
}
|
|
}
|
|
|
|
CStringArray arTxts;
|
|
ExtractSubString(sPIPECP, _T(","), arTxts);
|
|
|
|
CString sTxt;
|
|
for (int i = 0; i < arTxts.GetSize(); i++)
|
|
{
|
|
sTxt = arTxts.GetAt(i);
|
|
CLC(sTxt);
|
|
arTxts.SetAt(i, sTxt);
|
|
}
|
|
|
|
if (arTxts.GetSize() >= 17)
|
|
{
|
|
if (arTxts.GetSize() >= 20)
|
|
{
|
|
return PCP7(sLn);
|
|
}
|
|
|
|
double dt1 = _ttof(arTxts[16]);
|
|
double dt2 = _ttof(arTxts.GetAt(9));
|
|
if (dt1 < 1.e-3 || dt2 < 1.e-3)
|
|
{
|
|
return PCP5(sLn);
|
|
}
|
|
|
|
AcGePoint3d ptPos(_ttof(arTxts[0]), _ttof(arTxts[1]), _ttof(arTxts[2]));
|
|
AcGeVector3d vtDir(_ttof(arTxts[3]), _ttof(arTxts[4]), _ttof(arTxts[5]));
|
|
vtNUT = vtDir.crossProduct(vtPip);//XxY=Z
|
|
vtNUT.normalize();//Z
|
|
|
|
double dA = _ttof(arTxts[12]);
|
|
double dt = _ttof(arTxts[15]);
|
|
double dH = _ttof(arTxts[10]);
|
|
double dd = _ttof(arTxts.GetAt(8));
|
|
double dR = _ttof(arTxts.GetAt(7));
|
|
double dw = _ttof(arTxts.GetAt(13));
|
|
double db = _ttof(arTxts.GetAt(14));
|
|
CString sMx = arTxts.GetAt(6);
|
|
|
|
AcGePoint3d ptNut1, ptNut2,ptA1,ptA2,ptNs,ptNe, ptNut11, ptNut22;
|
|
ptNut1 = ptPos;
|
|
|
|
ptNut1 -= vtDir * 0.5 * dA;
|
|
ptNut1 -= vtNUT * dt;
|
|
|
|
NUT(ptNut1, sMx, -vtNUT, ptNut11, TRUE);
|
|
|
|
ptNut2 = ptNut1 + vtDir * dA;
|
|
NUT(ptNut2, sMx, -vtNUT, ptNut22, TRUE);
|
|
|
|
double dLS = dR + dt2+ dt;//不可以用H,H为冗长
|
|
ptA1 = ptNut1 + vtNUT * dLS;
|
|
ptA2 = ptNut2 + vtNUT * dLS;
|
|
|
|
//伸出
|
|
ptNs = ptNut11 - vtNUT * 5.0;
|
|
ptNe = ptNut22 - vtNUT * 5.0;
|
|
|
|
AcDbLine ln(ptNs, ptA1);
|
|
Ex(0.5 * dd, &ln);
|
|
|
|
ln.setStartPoint(ptNe);
|
|
ln.setEndPoint(ptA2);
|
|
Ex(0.5 * dd, &ln);
|
|
|
|
AcGePoint3d ptCen = ptA1 + vtDir * 0.5*dA;
|
|
AcDbArc arc;
|
|
arc.setCenter(ptCen);
|
|
arc.setRadius(0.5*dA);
|
|
arc.setStartAngle(0);
|
|
arc.setEndAngle(PI);
|
|
arc.setNormal(vtPip);
|
|
|
|
Ex(0.5 * dd, &arc);
|
|
|
|
AcDbArc arc1;
|
|
arc1.setCenter(ptCen);
|
|
arc1.setRadius(dR);
|
|
arc1.setStartAngle(1.25*PI);
|
|
arc1.setEndAngle(1.74*PI);
|
|
arc1.setNormal(vtPip);
|
|
|
|
AcDbArc arc2;
|
|
arc2.setCenter(ptCen);
|
|
arc2.setRadius(dR + dt2);
|
|
arc2.setStartAngle(1.25 * PI);
|
|
arc2.setEndAngle(1.74 * PI);
|
|
arc2.setNormal(vtPip);
|
|
|
|
AcGePoint3d pt1, pt2;
|
|
arc1.getStartPoint(pt1);
|
|
arc2.getStartPoint(pt2);
|
|
AcDbLine ln1(pt1, pt2);
|
|
|
|
arc1.getEndPoint(pt1);
|
|
arc2.getEndPoint(pt2);
|
|
AcDbLine ln2(pt1, pt2);
|
|
|
|
AcDbVoidPtrArray arCrs;
|
|
arCrs.append(&arc1);
|
|
arCrs.append(&arc2);
|
|
arCrs.append(&ln1);
|
|
arCrs.append(&ln2);
|
|
AcDbRegion* pRg = CreateRegFromCurves(arCrs);
|
|
|
|
if (pRg != NULL)
|
|
{
|
|
Ex(pRg, ptCen, ptCen + dw * vtPip,FALSE);
|
|
Ex(pRg, ptCen, ptCen - dw * vtPip,TRUE);
|
|
}
|
|
|
|
arCrs.removeAll();
|
|
AcDbCircle cir1;
|
|
cir1.setRadius(dR-dt1);
|
|
cir1.setCenter(ptCen);
|
|
cir1.setNormal(vtPip);
|
|
arCrs.append(&cir1);
|
|
AcDbRegion* pRg1 = CreateRegFromCurves(arCrs);
|
|
|
|
AcDbCircle cir2;
|
|
cir2.setRadius(dR);
|
|
cir2.setCenter(ptCen);
|
|
cir2.setNormal(vtPip);
|
|
arCrs.removeAll();
|
|
arCrs.append(&cir2);
|
|
AcDbRegion *pRg2 = CreateRegFromCurves(arCrs);
|
|
if (pRg2 != NULL)
|
|
{
|
|
pRg2->booleanOper(AcDb::kBoolSubtract, pRg1);
|
|
}
|
|
|
|
if (pRg2 != NULL)
|
|
{
|
|
Ex(pRg2, ptCen, ptCen + dw * vtPip, FALSE);
|
|
Ex(pRg2, ptCen, ptCen - dw * vtPip, TRUE);
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::YL(CString& sLn)
|
|
{
|
|
int nPos1 = sLn.Find(_T('('));
|
|
int nPos2 = sLn.Find(_T(')'));
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
CString sYD = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
|
|
CStringArray arTxts;
|
|
ExtractSubString(sYD, _T(","), arTxts);
|
|
|
|
CString sTxt;
|
|
for (int i = 0; i < arTxts.GetSize(); i++)
|
|
{
|
|
sTxt = arTxts.GetAt(i);
|
|
CLC(sTxt);
|
|
arTxts.SetAt(i, sTxt);
|
|
}
|
|
|
|
double dY = _ttof(arTxts.GetAt(6));
|
|
if (dY == 0)//不建模Y
|
|
return FALSE;
|
|
|
|
AcGePoint3d ptF = AcGePoint3d(_ttof(arTxts.GetAt(0)),_ttof(arTxts.GetAt(1)),_ttof(arTxts.GetAt(2)));
|
|
AcGeVector3d vt = AcGeVector3d(_ttof(arTxts.GetAt(3)), _ttof(arTxts.GetAt(4)), _ttof(arTxts.GetAt(5)));
|
|
vt.normalize();
|
|
|
|
double dL = _ttof(arTxts.GetAt(7));
|
|
double dt = _ttof(arTxts.GetAt(8));
|
|
double dYX = 10.0;
|
|
double dLx = dY - dYX;
|
|
|
|
AcGePoint3d ptT = ptF - AcGeVector3d::kZAxis * dL;
|
|
AcGePoint3d pt = ptF;
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(pt);
|
|
|
|
pt.x -= dLx;
|
|
arPts.append(pt);
|
|
|
|
pt.y -= dt;
|
|
arPts.append(pt);
|
|
|
|
pt.x += dLx;
|
|
arPts.append(pt);
|
|
|
|
arPts.append(arPts.first());
|
|
|
|
AcDbRegion *pRg = CreatePointsRegion(arPts);
|
|
if (pRg != NULL)
|
|
{
|
|
Ex(pRg, ptF, ptT, TRUE);
|
|
|
|
AcGeVector3d vtV1(-1, 1, 0);//XY面左上
|
|
vtV1.normalize();
|
|
|
|
AcGeVector3d vtV2(-1, -1, 0);//XY面左下
|
|
vtV2.normalize();
|
|
|
|
AcGeVector3d vt3(1, 1, 0);
|
|
vt3.normalize();
|
|
|
|
AcGeVector3d vt4(1, -1, 0);
|
|
vt4.normalize();
|
|
|
|
pt = arPts.at(1);
|
|
|
|
AcGePoint3dArray arPts1;
|
|
arPts1.append(arPts);
|
|
arPts.removeAll();
|
|
|
|
//0
|
|
arPts.append(pt);
|
|
|
|
//1
|
|
pt += vtV1 * 14.14;
|
|
arPts.append(pt);
|
|
|
|
//2
|
|
pt += vtV2 * dt;
|
|
arPts.append(pt);
|
|
|
|
//3
|
|
arPts.append(pt);
|
|
//4
|
|
arPts.append(pt);
|
|
//5
|
|
arPts.append(pt);
|
|
|
|
//6
|
|
pt = arPts1.at(2);
|
|
arPts.append(pt);
|
|
|
|
//5
|
|
pt += vtV2 * 14.14;
|
|
arPts.setAt(5, pt);
|
|
|
|
//4
|
|
pt += vtV1 * dt;
|
|
arPts.setAt(4, pt);
|
|
|
|
AcDbXline xLn1;
|
|
xLn1.setBasePoint(arPts.at(2));
|
|
xLn1.setUnitDir(vtV1);
|
|
|
|
AcDbXline xLn2;
|
|
xLn2.setBasePoint(arPts.at(4));
|
|
xLn2.setUnitDir(vtV2);
|
|
|
|
arPts1.removeAll();
|
|
xLn1.intersectWith(&xLn2, AcDb::kOnBothOperands, arPts1);
|
|
|
|
if (!arPts1.isEmpty())
|
|
{
|
|
arPts.setAt(3,arPts1.first());
|
|
}
|
|
arPts.append(arPts.first());
|
|
|
|
pRg = CreatePointsRegion(arPts);
|
|
if (pRg != NULL)
|
|
{
|
|
ptF = arPts.first();
|
|
ptT = ptF - AcGeVector3d::kZAxis * dL;
|
|
|
|
Ex(pRg, ptF, ptT, TRUE);
|
|
}
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::CX(CString &sLn)
|
|
{
|
|
int nPos1 = sLn.Find(_T('('));
|
|
int nPos2 = sLn.Find(_T(')'));
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
CString sEXPL = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
|
|
CStringArray arTxts;
|
|
ExtractSubString(sEXPL, _T(","), arTxts);
|
|
|
|
CString sTxt;
|
|
for (int i = 0; i < arTxts.GetSize(); i++)
|
|
{
|
|
sTxt = arTxts.GetAt(i);
|
|
CLC(sTxt);
|
|
arTxts.SetAt(i, sTxt);
|
|
}
|
|
|
|
if (arTxts.GetSize() >= 12)
|
|
{
|
|
double dr = _ttof(arTxts.GetAt(6));
|
|
double dR = _ttof(arTxts.GetAt(10));
|
|
double dL1 = _ttof(arTxts.GetAt(3));
|
|
double dL0 = _ttof(arTxts.GetAt(11));
|
|
double dL11 = dL1 - dR;// _ttof(arTxts.GetAt(11));
|
|
|
|
AcGePoint3d pt0 = AcGePoint3d(_ttof(arTxts.GetAt(0)), _ttof(arTxts.GetAt(1)), _ttof(arTxts.GetAt(2)));
|
|
AcGePoint3d pt1 = AcGePoint3d(_ttof(arTxts.GetAt(3)), _ttof(arTxts.GetAt(4)), _ttof(arTxts.GetAt(4)));
|
|
AcGeVector3d vt = pt1 - pt0;
|
|
vt.normalize();
|
|
|
|
int nSePs = sLn.Find(_T(":"));
|
|
if (nSePs != -1)
|
|
{
|
|
nPos1 = sLn.Find(_T('('), nSePs);
|
|
if (nPos1 != -1)
|
|
{
|
|
CString sSe = sLn.Mid(nSePs + 1, nPos1 - nSePs - 1);
|
|
if (sSe.CompareNoCase(_T("SE")) == 0)
|
|
{
|
|
nPos1 = sLn.Find(_T('('), nSePs);
|
|
nPos2 = sLn.Find(_T(')'), nSePs);
|
|
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
CString sSe = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
|
|
CStringArray arSeTxts;
|
|
ExtractSubString(sSe, _T(","), arSeTxts);
|
|
|
|
for (int i = 0; i < arSeTxts.GetSize(); i++)
|
|
{
|
|
sTxt = arSeTxts.GetAt(i);
|
|
CLC(sTxt);
|
|
arSeTxts.SetAt(i, sTxt);
|
|
}
|
|
|
|
if (arSeTxts.GetSize() >= 4)
|
|
{
|
|
double dY = _ttof(arSeTxts[3]);
|
|
double dL = _ttof(arSeTxts[0]);
|
|
double dt3 = _ttof(arSeTxts[1]);
|
|
double dd = _ttof(arSeTxts[2]);
|
|
double dAng = atan(dL0 / (dR + dd));
|
|
|
|
AcDbPolyline pl;
|
|
double dr = 0;
|
|
AcGePoint3d pt = pt0;
|
|
if (dY < 1.e-3)//圆钩
|
|
{
|
|
AcDbLine ln;
|
|
dr = dd;
|
|
ln.setStartPoint(pt);
|
|
|
|
pt.x += (dL11+dt3);
|
|
ln.setEndPoint(pt);
|
|
|
|
Ex(0.5*dd, &ln);
|
|
|
|
AcDbArc cir;
|
|
pt = pt0;
|
|
pt.x += dL1;
|
|
pt.y += 0.5*dd;
|
|
cir.setCenter(pt);
|
|
cir.setRadius(dR);
|
|
cir.setStartAngle(PI);
|
|
cir.setEndAngle(PI + 1.5*PI + dAng);
|
|
cir.setNormal(AcGeVector3d::kZAxis);
|
|
|
|
Ex(0.5*dd, &cir);
|
|
}
|
|
else//矩形钩
|
|
{
|
|
pt = pt0;
|
|
|
|
AcGePoint3dArray arPts;
|
|
pt.z += 0.5 * dL;
|
|
arPts.append(pt);
|
|
|
|
pt.y += dt3;
|
|
arPts.append(pt);
|
|
|
|
pt.z -= dL;
|
|
arPts.append(pt);
|
|
|
|
pt.y -= dt3;
|
|
arPts.append(pt);
|
|
|
|
arPts.append(arPts.first());
|
|
|
|
AcDbRegion* pRg = CreateFromPoints(arPts);
|
|
if (pRg != NULL)
|
|
{
|
|
AcDbLine ln;
|
|
dr = dd;
|
|
ln.setStartPoint(pt);
|
|
|
|
pt.x += (dL11 + dt3);
|
|
|
|
ln.setEndPoint(pt);
|
|
|
|
Ex(pRg, &ln, 0.0, TRUE);
|
|
|
|
AcDbArc cir;
|
|
pt = pt0;
|
|
pt.x += dL1;
|
|
pt.y += dt3;
|
|
|
|
cir.setCenter(pt);
|
|
cir.setRadius(dR);
|
|
cir.setStartAngle(PI);
|
|
cir.setEndAngle(PI + 1.5*PI + dAng);
|
|
cir.setNormal(AcGeVector3d::kZAxis);
|
|
|
|
pt = pt0;
|
|
pt.x += dL11;
|
|
|
|
arPts.removeAll();
|
|
pt.z += 0.5 * dL;
|
|
arPts.append(pt);
|
|
|
|
pt.x += dt3;
|
|
arPts.append(pt);
|
|
|
|
pt.z -= dL;
|
|
arPts.append(pt);
|
|
|
|
pt.x -= dt3;
|
|
arPts.append(pt);
|
|
|
|
arPts.append(arPts.first());
|
|
|
|
pRg = CreateFromPoints(arPts);
|
|
if (pRg != NULL)
|
|
{
|
|
Ex(pRg, &cir, 0.0, TRUE);
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
AcDbRegion* AecDbPipeHanger::PL(CString& sPl, AcGeVector3d& vtNm)
|
|
{
|
|
CStringArray arTxts;
|
|
ExtractSubString(sPl, _T(","), arTxts);
|
|
|
|
CString sTxt;
|
|
for (int i = 0; i < arTxts.GetSize(); i++)
|
|
{
|
|
sTxt = arTxts.GetAt(i);
|
|
CLC(sTxt);
|
|
arTxts.SetAt(i, sTxt);
|
|
}
|
|
|
|
int nMod = arTxts.GetSize() % 3;
|
|
if (nMod != 0)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
int nPts = arTxts.GetSize() / 3;
|
|
|
|
AcGePoint3d pt;
|
|
AcGePoint3dArray arPts;
|
|
|
|
for (int i = 0;i < nPts;i++)
|
|
{
|
|
pt.set(_ttof(arTxts[i*3]), _ttof(arTxts[i*3 + 1]), _ttof(arTxts[i*3 + 2]));
|
|
arPts.append(pt);
|
|
}
|
|
|
|
if (!arPts.isEmpty())
|
|
{
|
|
vtNm = arPts.last().asVector();
|
|
arPts.removeLast();
|
|
|
|
return CreatePointsRegion(arPts);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
AcDbRegion* AecDbPipeHanger::POR(CString& sPl, AcGeVector3d& vtNm)
|
|
{
|
|
CStringArray arTxts;
|
|
ExtractSubString(sPl, _T(","), arTxts);
|
|
|
|
CString sTxt;
|
|
for (int i = 0; i < arTxts.GetSize(); i++)
|
|
{
|
|
sTxt = arTxts.GetAt(i);
|
|
CLC(sTxt);
|
|
arTxts.SetAt(i, sTxt);
|
|
}
|
|
|
|
ads_point pt0, pt1;
|
|
if (arTxts.GetSize() >= 3)
|
|
{
|
|
pt0[X] = _ttof(arTxts[0]);
|
|
pt0[Y] = _ttof(arTxts[1]);
|
|
pt0[Z] = _ttof(arTxts[2]);
|
|
|
|
if (arTxts.GetSize() >= 6)
|
|
{
|
|
int nLast = arTxts.GetSize() - 1 - 1 - 1;
|
|
vtNm.set(_ttof(arTxts[nLast]), _ttof(arTxts[nLast + 1]), _ttof(arTxts[nLast + 2]));
|
|
|
|
arTxts.RemoveAt(arTxts.GetSize() - 1);
|
|
arTxts.RemoveAt(arTxts.GetSize() - 1);
|
|
arTxts.RemoveAt(arTxts.GetSize() - 1);
|
|
|
|
arTxts.RemoveAt(0);
|
|
arTxts.RemoveAt(0);
|
|
arTxts.RemoveAt(0);
|
|
|
|
int nPors = arTxts.GetSize() / 2;
|
|
int nPorsM = arTxts.GetSize() % 2;
|
|
if (nPorsM == 0)
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(asPnt3d(pt0));
|
|
|
|
double dAng = 0;
|
|
double dLen = 0;
|
|
for (int i = 0;i < nPors;i++)
|
|
{
|
|
dAng = _ttof(arTxts.GetAt(2*i));
|
|
dAng *= PI / 180.0;
|
|
dLen = _ttof(arTxts.GetAt(2 * i+1));
|
|
|
|
ads_polar(asDblArray(arPts.last()), dAng, dLen, pt1);
|
|
arPts.append(asPnt3d(pt1));
|
|
}
|
|
arPts.append(arPts.first());
|
|
AcDbRegion* pRg = CreatePointsRegion(arPts);
|
|
if (pRg != NULL)
|
|
{
|
|
AcGeMatrix3d xm;
|
|
xm.setToPlaneToWorld(vtNm);
|
|
pRg->transformBy(xm);
|
|
|
|
return pRg;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::PLR(CString& sLn)
|
|
{
|
|
int nPos1 = sLn.Find(_T('('));
|
|
int nPos2 = sLn.Find(_T(')'));
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
CString sPlr = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
|
|
CStringArray arTxts;
|
|
ExtractSubString(sPlr, _T(","), arTxts);
|
|
|
|
CString sTxt;
|
|
for (int i = 0; i < arTxts.GetSize(); i++)
|
|
{
|
|
sTxt = arTxts.GetAt(i);
|
|
CLC(sTxt);
|
|
arTxts.SetAt(i, sTxt);
|
|
}
|
|
|
|
if (arTxts.GetSize() >= 4)
|
|
{
|
|
AcGePoint3d pt(0, 0, 0);
|
|
double dR = _ttof(arTxts.GetAt(0));
|
|
double dAng = _ttof(arTxts.GetAt(1));
|
|
double dZ = _ttof(arTxts.GetAt(2));
|
|
double dt = _ttof(arTxts.GetAt(3));
|
|
|
|
dAng *= PI / 180.0;
|
|
|
|
//水平移动
|
|
AcGeVector3d vtM(dR, 0, 0);
|
|
|
|
int nPlPos = sLn.Find(_T(":"));
|
|
if (nPlPos != -1)
|
|
{
|
|
nPos1 = sLn.Find(_T('('), nPlPos);
|
|
nPos2 = sLn.ReverseFind(_T(')'));
|
|
|
|
if (nPos1 != -1 && nPos2 != -1)
|
|
{
|
|
CString sPl = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
|
|
|
|
//0123:POR(--- 4 -- 8-4-1
|
|
CString sPLType = sLn.Mid(nPlPos + 1, nPos1 - nPlPos - 1);
|
|
if (sPLType.CompareNoCase(_T("PL")) == 0)
|
|
{
|
|
AcGeVector3d vtNm;
|
|
AcDbRegion* pRg = PL(sPl, vtNm);
|
|
if (pRg != NULL)
|
|
{
|
|
AcDbLine ln;
|
|
ln.setStartPoint(AcGePoint3d(0, 0, 0));
|
|
ln.setEndPoint(AcGePoint3d(0, 0, 0) + vtNm * dt);
|
|
|
|
AcGeMatrix3d xM;
|
|
xM.setToTranslation(vtM);
|
|
|
|
AcGeVector3d vZ(0, 0, 1);
|
|
vZ *= dZ;
|
|
AcGeMatrix3d xZ;
|
|
xZ.setTranslation(vZ);
|
|
|
|
AcGeMatrix3d xR;
|
|
xR.setToRotation(dAng, AcGeVector3d::kZAxis);
|
|
|
|
//off
|
|
pRg->transformBy(xM);
|
|
//rot
|
|
pRg->transformBy(xR);
|
|
//z--
|
|
pRg->transformBy(xZ);
|
|
|
|
//off
|
|
ln.transformBy(xM);
|
|
//rot
|
|
ln.transformBy(xR);
|
|
//z
|
|
ln.transformBy(xZ);
|
|
|
|
if (pRg != NULL)
|
|
{
|
|
return Ex(pRg, &ln, 0.0, TRUE);
|
|
}
|
|
}
|
|
}
|
|
else if (sPLType.CompareNoCase(_T("POR")) == 0)
|
|
{
|
|
AcGeVector3d vtNm;
|
|
AcDbRegion* pRg = POR(sPl, vtNm);
|
|
if (pRg != NULL)
|
|
{
|
|
AcDbLine ln;
|
|
ln.setStartPoint(AcGePoint3d(0, 0, 0));
|
|
ln.setEndPoint(AcGePoint3d(0, 0, 0) + vtNm * dt);
|
|
|
|
AcGeMatrix3d xM;
|
|
xM.setToTranslation(vtM);
|
|
|
|
AcGeVector3d vZ(0, 0, 1);
|
|
vZ *= dZ;
|
|
AcGeMatrix3d xZ;
|
|
xZ.setTranslation(vZ);
|
|
|
|
AcGeMatrix3d xR;
|
|
xR.setToRotation(dAng, AcGeVector3d::kZAxis);
|
|
|
|
//off
|
|
pRg->transformBy(xM);
|
|
//rot
|
|
pRg->transformBy(xR);
|
|
//z--
|
|
pRg->transformBy(xZ);
|
|
|
|
//off
|
|
ln.transformBy(xM);
|
|
//rot
|
|
ln.transformBy(xR);
|
|
//z
|
|
ln.transformBy(xZ);
|
|
|
|
if (pRg != NULL)
|
|
{
|
|
return Ex(pRg, &ln, 0.0, TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void AecDbPipeHanger::SwitchVar()
|
|
{
|
|
int nVt = 0;
|
|
CString sKey,sKey2;
|
|
AecXData xdata1,xdata2;
|
|
CStringArray arKeys;
|
|
for (AecDbObjXDataMap::It it = m_mapSpecXData.Begin(); it != m_mapSpecXData.End(); )
|
|
{
|
|
if (!m_mapSpecXData.GetNext(it, sKey, xdata1))
|
|
{
|
|
break;
|
|
}
|
|
if (sKey.Find(_T("#")) != -1)
|
|
{
|
|
arKeys.Add(sKey);
|
|
}
|
|
}
|
|
|
|
//切换
|
|
for (int i = 0;i < arKeys.GetSize();i++)
|
|
{
|
|
//A#
|
|
sKey = arKeys.GetAt(i);
|
|
|
|
//A
|
|
sKey2 = sKey;
|
|
sKey2.TrimRight(_T('#'));
|
|
|
|
//A#
|
|
memset(&xdata1, 0, sizeof(AecXData));
|
|
m_mapSpecXData.GetAt(sKey, xdata1);
|
|
|
|
//A
|
|
memset(&xdata2, 0, sizeof(AecXData));
|
|
m_mapSpecXData.GetAt(sKey2, xdata2);
|
|
|
|
//A#
|
|
m_mapSpecXData.SetAt(sKey, xdata2);
|
|
|
|
//A
|
|
m_mapSpecXData.SetAt(sKey2, xdata1);
|
|
}
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::Insert(const AcGePoint3d &pt, double dRot,BOOL bAddDraw)
|
|
{
|
|
FreeBuffer(m_ar3DSlds);
|
|
|
|
CString sLn;
|
|
int nPCP = 0;
|
|
int nPCPMinIndex = -1;
|
|
m_mapSpecXData.GetAt(_T("PCP#"), nPCPMinIndex);
|
|
|
|
for (int i = 0; i < m_arLines.GetSize(); i++)
|
|
{
|
|
sLn = m_arLines.GetAt(i);
|
|
if (sLn.Find(_T("EX")) != -1)
|
|
{
|
|
EX(sLn);
|
|
}
|
|
else if (sLn.Find(_T("SLC")) != -1)
|
|
{
|
|
SLC(sLn);
|
|
}
|
|
else if (sLn.Find(_T("BLT")) != -1)
|
|
{
|
|
BLT(sLn);
|
|
}
|
|
else if (sLn.Find(_T("PCP")) != -1)
|
|
{
|
|
if (nPCPMinIndex == nPCP)
|
|
{
|
|
//使用变量切换#
|
|
SwitchVar();
|
|
}
|
|
|
|
PCP(sLn);
|
|
|
|
if (nPCPMinIndex == nPCP)
|
|
{
|
|
//切换回变量切换
|
|
SwitchVar();
|
|
}
|
|
|
|
nPCP += 1;
|
|
}
|
|
else if (sLn.Find(_T("YL")) != -1)
|
|
{
|
|
YL(sLn);
|
|
}
|
|
else if (sLn.Find(_T("CX")) != -1)
|
|
{
|
|
CX(sLn);
|
|
}
|
|
else if (sLn.Find(_T("PLR")) != -1)
|
|
{
|
|
PLR(sLn);
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
}
|
|
}
|
|
|
|
AcDb3dSolid* pElbowSolid = NULL;
|
|
if (m_pElbowArc != NULL && m_dElbowOD > 1.e-3)
|
|
{
|
|
AcGePoint3d ptS;
|
|
AcGeVector3d vtN;
|
|
m_pElbowArc->getStartPoint(ptS);
|
|
m_pElbowArc->getFirstDeriv(ptS, vtN);
|
|
|
|
AcDbRegion* pRg = CreateCirRegion(ptS, 0.5*m_dElbowOD, vtN);
|
|
if (pRg != NULL)
|
|
{
|
|
Acad::ErrorStatus es;
|
|
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
|
if (Acad::eOk == (es = pSolid->extrudeAlongPath(pRg, m_pElbowArc)))
|
|
{
|
|
pElbowSolid = pSolid;
|
|
delete pRg;
|
|
}
|
|
else
|
|
{
|
|
delete pRg;
|
|
delete pSolid;
|
|
}
|
|
}
|
|
}
|
|
|
|
//2D
|
|
|
|
m_ptIns = pt;
|
|
m_dRot = dRot;
|
|
|
|
AcGeMatrix3d xr;
|
|
xr.setToRotation(m_dRot, AcGeVector3d::kZAxis);
|
|
|
|
AcGeVector3d vt = m_ptIns.asVector();
|
|
AcGeMatrix3d xm;
|
|
xm.setToTranslation(vt);
|
|
|
|
AcDbExtents ext, ext1;
|
|
AcDbEntity* pEnt3d = NULL;
|
|
for (int i = 0; i < m_ar3DSlds.length(); i++)
|
|
{
|
|
pEnt3d = (AcDbEntity*)m_ar3DSlds.at(i);
|
|
|
|
pEnt3d->getGeomExtents(ext1);
|
|
ext.addExt(ext1);
|
|
|
|
pEnt3d->transformBy(xr);
|
|
pEnt3d->transformBy(xm);
|
|
|
|
if (pElbowSolid != NULL)
|
|
{
|
|
AcDb3dSolid* pSolid = AcDb3dSolid::cast(pEnt3d);
|
|
if (pSolid != NULL)
|
|
{
|
|
AcDb3dSolid* pElbow3d = (AcDb3dSolid*)pElbowSolid->clone();
|
|
if (pElbow3d != NULL)
|
|
{
|
|
pSolid->booleanOper(AcDb::kBoolSubtract, pElbow3d);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//TEST
|
|
if (bAddDraw)
|
|
{
|
|
AcDbObjectId id;
|
|
for (int i = 0; i < m_ar3DSlds.length(); i++)
|
|
{
|
|
AcDbEntity *pEnt = (AcDbEntity *)m_ar3DSlds.at(i);
|
|
if (pEnt != NULL)
|
|
{
|
|
id = AddToModelSpace(pEnt);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_arRecPts.removeAll();
|
|
|
|
AcGePoint3d ptMin = ext.minPoint();
|
|
AcGePoint3d ptMax = ext.maxPoint();
|
|
//ptMin.z = 0; ptMax.z = 0;
|
|
ptMin.z = ptMax.z;
|
|
|
|
AcGePoint3d ptT;
|
|
ptT = ptMin;
|
|
|
|
//0
|
|
ptT.transformBy(xr);
|
|
ptT.transformBy(xm);
|
|
m_arRecPts.append(ptT);
|
|
|
|
//1
|
|
ptT = ptMax;
|
|
ptT.y = ptMin.y;
|
|
ptT.transformBy(xr);
|
|
ptT.transformBy(xm);
|
|
m_arRecPts.append(ptT);
|
|
|
|
//2
|
|
ptT = ptMax;
|
|
ptT.transformBy(xr);
|
|
ptT.transformBy(xm);
|
|
m_arRecPts.append(ptT);
|
|
|
|
//3
|
|
ptT = ptMin;
|
|
ptT.y = ptMax.y;
|
|
ptT.transformBy(xr);
|
|
ptT.transformBy(xm);
|
|
m_arRecPts.append(ptT);
|
|
|
|
//4
|
|
m_arRecPts.append(m_arRecPts.first());//closed
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbPipeHanger::GetDirLine(AcDbLine& lnDir) const
|
|
{
|
|
assertReadEnabled();
|
|
if (m_arRecPts.length() >= 4)
|
|
{
|
|
AcGePoint3d pt0, pt1;
|
|
Midpoint(m_arRecPts.at(0), m_arRecPts.at(3), pt0);
|
|
Midpoint(m_arRecPts.at(1), m_arRecPts.at(2), pt1);
|
|
lnDir.setStartPoint(pt0);
|
|
lnDir.setEndPoint(pt1);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
AcGePoint3d AecDbPipeHanger::position() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_ptIns;
|
|
}
|
|
|
|
double AecDbPipeHanger::rotation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_dRot;
|
|
}
|
|
|
|
#include "HlrCutOption.h"
|
|
void AecDbPipeHanger::ProcessHlrResult(const AcArray<AcDbEntity *> &ar
|
|
, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr
|
|
, AcArray<AcDbEntity *> &output) const
|
|
{
|
|
const AecDbObjXDataMap *pMap(&m_mapSpecXData);
|
|
const_cast<AecDbObjXDataMap *>(pMap)->SetAt(HLR_CALC, FALSE);
|
|
if (ar.isEmpty() && preAr.empty()) return;
|
|
HlrCutOption::ProcessHlrResult(this
|
|
, false
|
|
, .0
|
|
, HlrCutOption::getHlrBLK_EQU()
|
|
, ar
|
|
, preAr
|
|
, output);
|
|
}
|
|
|
|
void AecDbPipeHanger::PreprocessForHlr(const AcGePoint3d &ptPlnO, const AcGeVector3d &vtPlnN, AcArray<AcDbEntity *> &ar) const
|
|
{
|
|
const AecDbObjXDataMap *pMap(&m_mapSpecXData);
|
|
|
|
AcGeVector3d vtDir = AcGeVector3d::kXAxis;
|
|
vtDir.rotateBy(m_dRot,AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d pt0, pt1,ptMid;
|
|
if (m_arRecPts.length() >= 4)
|
|
{
|
|
Midpoint(m_arRecPts.at(0), m_arRecPts.at(3), pt0);
|
|
Midpoint(m_arRecPts.at(1), m_arRecPts.at(2), pt1);
|
|
}
|
|
double dLx = pt1.distanceTo(pt0);
|
|
Midpoint(pt0, pt1, ptMid);
|
|
|
|
// 原2d绘制平面
|
|
AcGePlane _pln(m_ptIns, vtPlnN);
|
|
AcGeMatrix3d mat(AcGeMatrix3d::kIdentity)
|
|
, mat2(AcGeMatrix3d::kIdentity)
|
|
, mat3(AcGeMatrix3d::kIdentity);
|
|
|
|
mat3.setToTranslation(AcGeVector3d(-vtPlnN).normalize() * dLx);
|
|
|
|
if (vtPlnN.isParallelTo(AcGeVector3d::kZAxis)) // 俯视图
|
|
{
|
|
AcDbEntity *pEnt = NULL;
|
|
AcDbVoidPtrArray ar2d;
|
|
GetDraw2dables(0, ar2d);
|
|
for (int n = 0;n < ar2d.length();n++)
|
|
{
|
|
ar.append((AcDbEntity*)ar2d.at(n));
|
|
}
|
|
|
|
ar2d.removeAll();
|
|
GetDraw2dables(0, ar2d);
|
|
for (int n = 0; n < ar2d.length(); n++)
|
|
{
|
|
pEnt = (AcDbEntity *)ar2d.at(n);
|
|
pEnt->transformBy(mat3);
|
|
ar.append(pEnt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//投影
|
|
return;
|
|
}
|
|
const_cast<AecDbObjXDataMap *>(pMap)->SetAt(HLR_CALC, TRUE);
|
|
} |