2001 lines
43 KiB
C++
2001 lines
43 KiB
C++
#include "stdafx.h"
|
|
#include "stdarx.h"
|
|
#include "AecDbAssembleWell.h"
|
|
#include "dbgrip.h"
|
|
#include "AecGripCback.h"
|
|
#include "MFCDbDwgFiler.h"
|
|
#include "KTExpressCalc.h"
|
|
|
|
|
|
Adesk::UInt32 AecDbAssembleWell::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;
|
|
extern AcDbPolyline *FormatPolyline(AcGePoint3d *ppPts, int nCount);
|
|
extern AcGePoint3d MidPoint(const AcGePoint3d &pt1, const AcGePoint3d &pt2);
|
|
|
|
static void FreeBuffer(int n, AcDbVoidPtrArray &arEntPtrs)
|
|
{
|
|
AcDbEntity *pEnt = NULL;
|
|
while (arEntPtrs.length() > n)
|
|
{
|
|
pEnt = (AcDbEntity *)arEntPtrs.last();
|
|
pEnt->erase();
|
|
pEnt->close();
|
|
DELETE_PTR(pEnt);
|
|
arEntPtrs.removeLast();
|
|
}
|
|
}
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(AecDbAssembleWell, AecDbEntityBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_ASMBLWELL,
|
|
"AecDbAssembleWell"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
AecDbAssembleWell::AecDbAssembleWell(void)
|
|
{
|
|
m_pGripAppData = new AecGripData[6];
|
|
}
|
|
|
|
AecDbAssembleWell::~AecDbAssembleWell(void)
|
|
{
|
|
delete[] m_pGripAppData;
|
|
}
|
|
|
|
bool AecDbAssembleWell::AppendScriptLine(const TCHAR *pszLine, bool bIs3D)
|
|
{
|
|
AssertWriteEnabled();
|
|
//Programming language syntax check
|
|
if ( IsPLSyntaxCheck(pszLine))
|
|
{
|
|
if (bIs3D)
|
|
m_arScrLines3d.Add(pszLine);
|
|
else
|
|
m_arScrLines2d.Add(pszLine);
|
|
return true;
|
|
}
|
|
acutPrintf(_T("Programming language syntax check error!"));
|
|
return false;
|
|
}
|
|
|
|
void AecDbAssembleWell::ResetContent()
|
|
{
|
|
AssertWriteEnabled();
|
|
m_arScrLines3d.RemoveAll();
|
|
m_arScrLines2d.RemoveAll();
|
|
}
|
|
|
|
bool AecDbAssembleWell::GetScriptLines(CStringArray &arLines, bool bIs3D) const
|
|
{
|
|
assertReadEnabled();
|
|
if (bIs3D)
|
|
{
|
|
if (!m_arScrLines3d.IsEmpty())
|
|
{
|
|
arLines.Append(m_arScrLines3d);
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!m_arScrLines2d.IsEmpty())
|
|
{
|
|
arLines.Append(m_arScrLines2d);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AecDbAssembleWell::IsEmpty() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_arScrLines3d.IsEmpty() ? true : false;
|
|
}
|
|
|
|
void AecDbAssembleWell::SetPosition(const AcGePoint3d &ptIns)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_ptIns = ptIns;
|
|
}
|
|
|
|
bool AecDbAssembleWell::GetPosition(AcGePoint3d &ptIns) const
|
|
{
|
|
assertReadEnabled();
|
|
ptIns = m_ptIns;
|
|
return true;
|
|
}
|
|
|
|
void AecDbAssembleWell::SetRotation(double dAng)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_dRotate = dAng;
|
|
}
|
|
|
|
double AecDbAssembleWell::GetRotation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_dRotate;
|
|
}
|
|
|
|
//专业数据 和绘制设置
|
|
AecDbObjXDataMap *AecDbAssembleWell::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 *AecDbAssembleWell::GetSpecialtyData() const
|
|
{
|
|
assertReadEnabled();
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
void AecDbAssembleWell::subList() const
|
|
{
|
|
assertReadEnabled();
|
|
acutPrintf(_T("\n名称:井"));
|
|
AecDbEntityBase::subList();
|
|
m_mapSpecXData.List();
|
|
|
|
acutPrintf(_T("\nSML 3D"));
|
|
CString sLn;
|
|
for (int i = 0;i < m_arScrLines3d.GetSize();i++)
|
|
{
|
|
sLn = m_arScrLines3d.GetAt(i);
|
|
acutPrintf(_T("\n%s"), sLn);
|
|
}
|
|
|
|
acutPrintf(_T("\nSML 2D"));
|
|
for (int i = 0; i < m_arScrLines2d.GetSize(); i++)
|
|
{
|
|
sLn = m_arScrLines2d.GetAt(i);
|
|
acutPrintf(_T("\n%s"), sLn);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbAssembleWell::copyFrom(const AcRxObject *pSrc)
|
|
{
|
|
AecDbEntityBase::copyFrom(pSrc);
|
|
|
|
AecDbAssembleWell *pSrcOp = AecDbAssembleWell::cast(pSrc);
|
|
if (pSrcOp != NULL)
|
|
{
|
|
m_mapSpecXData.CopyFrom(&pSrcOp->m_mapSpecXData);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbAssembleWell::subTransformBy(const AcGeMatrix3d &xform)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
m_ptIns.transformBy(xform);
|
|
|
|
AcGeVector3d vt;
|
|
vt.rotateBy(m_dRotate, AcGeVector3d::kZAxis);
|
|
vt.transformBy(xform);
|
|
vt.z = 0.0;//始终水平
|
|
m_dRotate = AcGeVector3d::kXAxis.angleTo(vt, AcGeVector3d::kZAxis);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
#if ARX>16
|
|
Acad::ErrorStatus AecDbAssembleWell::subGetGripPoints(AcDbGripDataPtrArray &grips,
|
|
const double curViewUnitSize,
|
|
const int gripSize,
|
|
const AcGeVector3d &curViewDir,
|
|
const int bitflags) const
|
|
{
|
|
assertReadEnabled();
|
|
int i = 0;
|
|
memset(&m_pGripAppData[i], 0, sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].nSegIndex = -1;
|
|
m_pGripAppData[i].ePos = eMid;
|
|
m_pGripAppData[i].nColor = kBlue;
|
|
m_pGripAppData[i].ptGrip = m_ptIns;
|
|
_tcscpy(m_pGripAppData[i].szTip, _T("插入点"));
|
|
//_tcscpy(m_pGripAppData[i].szID,m_sGUID);
|
|
m_pGripAppData[i].pOwner = (AcDbEntity *)this;
|
|
|
|
AcDbGripData* pGripData = new AcDbGripData;
|
|
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 AecDbAssembleWell::subMoveGripPointsAt(const AcDbVoidPtrArray &appData, const AcGeVector3d &offset, const int bitflags)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_ptIns += offset;
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbAssembleWell::subGetStretchPoints(AcGePoint3dArray &stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
stretchPoints.append(m_ptIns);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbAssembleWell::subMoveStretchPointsAt(const AcDbIntArray &indices, const AcGeVector3d &offset)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_ptIns += offset;
|
|
return Acad::eOk;
|
|
}
|
|
|
|
#endif
|
|
|
|
Acad::ErrorStatus AecDbAssembleWell::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//图层
|
|
AcDbObjectId idLay = dc.GetLayerId();
|
|
AcDbObjectId idLt = dc.GetLineTypeId();
|
|
dc.SetLayer(layerId());
|
|
dc.SetLineType(linetypeId());
|
|
|
|
if (Has2DBuffer())
|
|
{
|
|
Draw2DBuffers(dc);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcGeVector3d vtM = m_ptIns.asVector();
|
|
AcGeMatrix3d xM;
|
|
xM.setToTranslation(vtM);
|
|
|
|
AcGeMatrix3d xR;
|
|
xR.setToRotation(m_dRotate, AcGeVector3d::kZAxis);
|
|
|
|
CString sSml;
|
|
AcDbEntity *pEnt = NULL;
|
|
|
|
//绘制二维
|
|
AcDbVoidPtrArray arEntPtrs;
|
|
for (int i = 0; i < m_arScrLines2d.GetSize(); i++)
|
|
{
|
|
sSml = m_arScrLines2d.GetAt(i);
|
|
NewAcDbEntity(arEntPtrs, sSml);
|
|
}
|
|
|
|
for (int i = 0;i < arEntPtrs.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)arEntPtrs.at(i);
|
|
pEnt->transformBy(xR);
|
|
pEnt->transformBy(xM);
|
|
dc.DrawEntity(pEnt);
|
|
Add2DBuffer(pEnt);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
typedef CMap<CString, LPCTSTR, int, int> CMapString2Int;
|
|
bool AecDbAssembleWell::NewAcDbEntity(AcDbVoidPtrArray& arEntPtrs, CString& sSml) const
|
|
{
|
|
//关键字
|
|
CMapString2Int mapClass2Type;
|
|
mapClass2Type.SetAt(_T("RECT"), 1);
|
|
mapClass2Type.SetAt(_T("CIR"), 2);
|
|
mapClass2Type.SetAt(_T("ARC"), 3);
|
|
mapClass2Type.SetAt(_T("LINE"), 4);
|
|
mapClass2Type.SetAt(_T("PLINE"), 5);
|
|
|
|
sSml.TrimLeft();
|
|
sSml.TrimRight();
|
|
|
|
int nPos = sSml.Find(_T(" "), 0);
|
|
if (nPos == -1)
|
|
{
|
|
acutPrintf(_T("\n脚本语法错误!没有发现关键字!"));
|
|
return NULL;
|
|
}
|
|
|
|
CString sClass = sSml.Mid(0, nPos);
|
|
int nType = 0;
|
|
if (!mapClass2Type.Lookup(sClass, nType))
|
|
{
|
|
acutPrintf(_T("\n脚本语法错误!没有发现关键字类型!"));
|
|
return NULL;
|
|
}
|
|
|
|
CStringArray arInfo;
|
|
AecDbEntityBase::SplitStrintToArray(sSml, arInfo, _T(' '));
|
|
|
|
double dX = 0, dY = 0;
|
|
int nColor = 0;
|
|
double dRotate = 0,dSA = 0,dEA = 0;
|
|
CString sXYOff;
|
|
AcGePoint3d ptGe[10];
|
|
AcGeVector3d vM;
|
|
AcGeMatrix3d xM;
|
|
ads_point pt;
|
|
|
|
//RECT
|
|
double dL = 0, dW = 0;
|
|
|
|
switch (nType)
|
|
{
|
|
case 1://RECT
|
|
{
|
|
//RECT L W (dx,dy) DIR COLOR
|
|
if (arInfo.GetSize() < 6)
|
|
{
|
|
acutPrintf(_T("\n二维矩形数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
if (!CalValue(arInfo.GetAt(1), dL))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(2), dW))
|
|
return false;
|
|
|
|
sXYOff = arInfo.GetAt(3);
|
|
CalXYOffset(sXYOff, dX, dY);
|
|
|
|
vM.set(dX, dY, 0);
|
|
xM.setToTranslation(vM);
|
|
|
|
if (!CalValue(arInfo.GetAt(4), dRotate))
|
|
return false;
|
|
dRotate *= PI / 180.0;
|
|
|
|
nColor = _ttoi(arInfo.GetAt(5));
|
|
|
|
ptGe[0].set(-0.5 * dL, -0.5 * dW, 0);
|
|
ptGe[1].set(-0.5 * dL, 0.5 * dW, 0);
|
|
ptGe[2].set( 0.5 * dL, 0.5 * dW, 0);
|
|
ptGe[3].set( 0.5 * dL, -0.5 * dW, 0);
|
|
ptGe[4] = ptGe[0];
|
|
|
|
for (int ii = 0;ii < 5;ii++)
|
|
{
|
|
ptGe[ii].rotateBy(dRotate, AcGeVector3d::kZAxis);
|
|
}
|
|
|
|
AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setColorIndex(nColor);
|
|
pPl->transformBy(xM);
|
|
arEntPtrs.append(pPl);
|
|
}
|
|
break;
|
|
}
|
|
case 2://CIR
|
|
{
|
|
//CIR D (dx,dy) COLOR
|
|
if (arInfo.GetSize() < 4)
|
|
{
|
|
acutPrintf(_T("\n二维圆数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
if (!CalValue(arInfo.GetAt(1), dL))
|
|
return false;
|
|
|
|
sXYOff = arInfo.GetAt(2);
|
|
CalXYOffset(sXYOff, dX, dY);
|
|
|
|
vM.set(dX, dY, 0);
|
|
xM.setToTranslation(vM);
|
|
|
|
nColor = _ttoi(arInfo.GetAt(3));
|
|
|
|
AcDbCircle *pCir = new AcDbCircle;
|
|
pCir->setCenter(AcGePoint3d::kOrigin);
|
|
pCir->setRadius(0.5 * dL);
|
|
pCir->setNormal(AcGeVector3d::kZAxis);
|
|
pCir->transformBy(xM);
|
|
pCir->setColorIndex(nColor);
|
|
|
|
arEntPtrs.append(pCir);
|
|
|
|
break;
|
|
}
|
|
case 3://ARC
|
|
{
|
|
//ARC D SA EA (dx,dy) COLOR
|
|
if (arInfo.GetSize() < 6)
|
|
{
|
|
acutPrintf(_T("\n二维圆弧数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
if (!CalValue(arInfo.GetAt(1), dL))
|
|
return false;
|
|
|
|
if (!CalValue(arInfo.GetAt(2), dSA))
|
|
return false;
|
|
dSA *= PI / 180.0;
|
|
|
|
if (!CalValue(arInfo.GetAt(3), dEA))
|
|
return false;
|
|
dEA *= PI / 180.0;
|
|
|
|
sXYOff = arInfo.GetAt(4);
|
|
CalXYOffset(sXYOff, dX, dY);
|
|
|
|
vM.set(dX, dY, 0);
|
|
xM.setToTranslation(vM);
|
|
|
|
nColor = _ttoi(arInfo.GetAt(5));
|
|
|
|
AcDbArc *pArc = new AcDbArc;
|
|
pArc->setCenter(AcGePoint3d::kOrigin);
|
|
pArc->setRadius(0.5 * dL);
|
|
pArc->setStartAngle(dSA);
|
|
pArc->setEndAngle(dEA);
|
|
pArc->setNormal(AcGeVector3d::kZAxis);
|
|
pArc->setColorIndex(nColor);
|
|
pArc->transformBy(xM);
|
|
arEntPtrs.append(pArc);
|
|
|
|
break;
|
|
}
|
|
case 4://LINE
|
|
{
|
|
//LINE pt1 pt2 (dx,dy) COLOR
|
|
if (arInfo.GetSize() < 5)
|
|
{
|
|
acutPrintf(_T("\n二维直线数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
sXYOff = arInfo.GetAt(1);
|
|
CalXYOffset(sXYOff, dX, dY);
|
|
ptGe[0].set(dX, dY, 0.0);
|
|
|
|
sXYOff = arInfo.GetAt(2);
|
|
CalXYOffset(sXYOff, dX, dY);
|
|
ptGe[1].set(dX, dY, 0.0);
|
|
|
|
sXYOff = arInfo.GetAt(3);
|
|
CalXYOffset(sXYOff, dX, dY);
|
|
|
|
vM.set(dX, dY, 0);
|
|
xM.setToTranslation(vM);
|
|
|
|
nColor = _ttoi(arInfo.GetAt(4));
|
|
|
|
AcDbLine *pLn = new AcDbLine;
|
|
pLn->setStartPoint(ptGe[0]);
|
|
pLn->setEndPoint(ptGe[1]);
|
|
pLn->transformBy(xM);
|
|
arEntPtrs.append(pLn);
|
|
break;
|
|
}
|
|
case 5://PLINE
|
|
{
|
|
//PLINE pt1,pt2,pt3,pt4... (dx,dy) COLOR
|
|
if (arInfo.GetSize() < 5)//至少2个点
|
|
{
|
|
acutPrintf(_T("\n二维PLINE数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
int nTo = arInfo.GetSize() - 2;//偏移 颜色
|
|
int nFr = 1;
|
|
int nEnd = arInfo.GetSize() - 1;
|
|
|
|
AcDbPolyline *pPl = new AcDbPolyline;
|
|
AcGePoint2dArray arPts;
|
|
for (int j = nFr; j < nTo; j++)
|
|
{
|
|
sXYOff = arInfo.GetAt(j);
|
|
CalPoint2d(sXYOff, pt);
|
|
pPl->addVertexAt(j - nFr, asPnt2d(pt));
|
|
}
|
|
|
|
sXYOff = arInfo.GetAt(nTo);
|
|
CalXYOffset(sXYOff, dX, dY);
|
|
|
|
vM.set(dX, dY, 0);
|
|
xM.setToTranslation(vM);
|
|
|
|
nColor = _ttoi( arInfo.GetAt(nEnd));
|
|
|
|
pPl->transformBy(xM);
|
|
pPl->setColorIndex(nColor);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbAssembleWell::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//图层
|
|
AcDbObjectId idLay = dc.GetLayerId();
|
|
AcDbObjectId idLt = dc.GetLineTypeId();
|
|
dc.SetLayer(layerId());
|
|
dc.SetLineType(linetypeId());
|
|
|
|
int nCrBk = dc.GetColor();
|
|
|
|
int nColor = nCrBk;
|
|
if (m_mapSpecXData.GetAt(_T("COLOR"), nColor))
|
|
{
|
|
dc.SetColor(nColor);
|
|
}
|
|
|
|
AcDbEntity *pEnt = NULL;
|
|
if (Has3DBuffer())
|
|
{
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0; i < ar3D.length(); i++)
|
|
{
|
|
pEnt = (AcDbEntity *)ar3D.at(i);
|
|
pEnt->setColorIndex(nColor);
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcGeVector3d vtM = m_ptIns.asVector();
|
|
AcGeMatrix3d xM;
|
|
xM.setToTranslation(vtM);
|
|
|
|
AcGeMatrix3d xR;
|
|
xR.setToRotation(m_dRotate, AcGeVector3d::kZAxis);
|
|
|
|
CString sSml;
|
|
AcDbVoidPtrArray arUnt,arSub;
|
|
int nAddOrSub = 0;
|
|
AecDbEntityBase *pAecEntBase = NULL;
|
|
AecDbCurveBase* pAecCurBase = NULL;
|
|
|
|
for (int i = 0;i < m_arScrLines3d.GetSize();i++)
|
|
{
|
|
sSml = m_arScrLines3d.GetAt(i);
|
|
|
|
AcDbVoidPtrArray arEntPtrs;
|
|
NewAecEntity(arEntPtrs,sSml,nAddOrSub);
|
|
|
|
for (int j = 0; j < arEntPtrs.length(); j++)
|
|
{
|
|
pEnt = (AcDbEntity *)arEntPtrs.at(j);
|
|
|
|
if (pEnt != NULL)
|
|
{
|
|
pAecEntBase = AecDbEntityBase::cast(pEnt);
|
|
if (pAecEntBase != NULL)
|
|
{
|
|
pAecEntBase->setLayer(layerId());
|
|
//pAecEntBase->Draw3d(dc);
|
|
dc.DrawEntity(pAecEntBase);
|
|
|
|
if (nAddOrSub)
|
|
arUnt.append(pAecEntBase->Get3DBuffer());
|
|
else
|
|
arSub.append(pAecEntBase->Get3DBuffer());
|
|
|
|
pAecEntBase->Clean3DBufferNoDel();
|
|
|
|
delete pEnt;
|
|
continue;
|
|
}
|
|
|
|
pAecCurBase = AecDbCurveBase::cast(pEnt);
|
|
if (pAecCurBase != NULL)
|
|
{
|
|
pAecCurBase->setLayer(layerId());
|
|
//pAecCurBase->Draw3d(dc);
|
|
dc.DrawEntity(pAecCurBase);
|
|
|
|
if (nAddOrSub)
|
|
arUnt.append(pAecCurBase->Get3DBuffer());
|
|
else
|
|
arSub.append(pAecCurBase->Get3DBuffer());
|
|
pAecCurBase->Clean3DBufferNoDel();
|
|
|
|
delete pEnt;
|
|
continue;
|
|
}
|
|
|
|
//其他 旋转并移到指定位置
|
|
pEnt->transformBy(xR);
|
|
pEnt->transformBy(xM);
|
|
dc.DrawEntity(pEnt);
|
|
Add3DBuffer(pEnt);
|
|
}
|
|
}
|
|
}
|
|
|
|
//然后执行布尔运算减
|
|
Acad::ErrorStatus es;
|
|
AcDbEntity *pSub = NULL;
|
|
for (int i = 0;i < arUnt.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)arUnt.at(i);
|
|
AcDb3dSolid *pSolid = AcDb3dSolid::cast(pEnt);
|
|
if (pSolid != NULL)
|
|
{
|
|
//去除洞口
|
|
for (int j = 0;j < arSub.length();j++)
|
|
{
|
|
pSub = (AcDbEntity*)arSub.at(j);
|
|
acutPrintf(_T("\n%s"),pSub->isA()->name());
|
|
AcDb3dSolid *pSolid2 = AcDb3dSolid::cast(pSub->clone());
|
|
if (pSolid2 != NULL)
|
|
{
|
|
es = pSolid->booleanOper(AcDb::kBoolSubtract, pSolid2);
|
|
if (pSolid2 != NULL) delete pSolid2;
|
|
}
|
|
}
|
|
}
|
|
|
|
//旋转并移到指定位置
|
|
pEnt->transformBy(xR);
|
|
pEnt->transformBy(xM);
|
|
dc.DrawEntity(pEnt);
|
|
Add3DBuffer(pEnt);
|
|
}
|
|
|
|
FreeBuffer(0, arSub);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbAssembleWell::dwgInFields(AcDbDwgFiler *pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if (!pFiler->isKindOf(CMFCDbDwgFiler::desc()))
|
|
{
|
|
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 > AecDbAssembleWell::kCurrentVersionNumber)
|
|
return (Acad::eMakeMeProxy);
|
|
|
|
//2D
|
|
m_mapSpecXData.dwgInFields(pFiler);
|
|
|
|
Adesk::Int32 nLines = 0;
|
|
pFiler->readInt32(&nLines);
|
|
|
|
m_arScrLines2d.RemoveAll();
|
|
|
|
TCHAR *pszLine = NULL;
|
|
for (int i = 0;i < nLines;i++)
|
|
{
|
|
pszLine = NULL;
|
|
pFiler->readString(&pszLine);
|
|
|
|
if (pszLine != NULL)
|
|
m_arScrLines2d.Add(pszLine);
|
|
}
|
|
|
|
nLines = 0;
|
|
pFiler->readInt32(&nLines);
|
|
|
|
m_arScrLines3d.RemoveAll();
|
|
for (int i = 0; i < nLines; i++)
|
|
{
|
|
pszLine = NULL;
|
|
pFiler->readString(&pszLine);
|
|
|
|
if (pszLine != NULL)
|
|
m_arScrLines3d.Add(pszLine);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbAssembleWell::dwgOutFields(AcDbDwgFiler *pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if (!pFiler->isKindOf(CMFCDbDwgFiler::desc()))
|
|
{
|
|
es = AecDbEntityBase::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return (es);
|
|
}
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ((es = pFiler->writeUInt32(AecDbAssembleWell::kCurrentVersionNumber)) != Acad::eOk)
|
|
return (es);
|
|
|
|
//2D
|
|
m_mapSpecXData.dwgOutFields(pFiler);
|
|
|
|
Adesk::Int32 nLines = m_arScrLines2d.GetSize();
|
|
pFiler->writeInt32(nLines);
|
|
|
|
CString sLine;
|
|
for (int i = 0;i < nLines;i++)
|
|
{
|
|
sLine = m_arScrLines2d.GetAt(i);
|
|
pFiler->writeString((const TCHAR*)sLine);
|
|
}
|
|
|
|
nLines = m_arScrLines3d.GetSize();
|
|
pFiler->writeInt32(nLines);
|
|
|
|
for (int i = 0; i < nLines; i++)
|
|
{
|
|
sLine = m_arScrLines3d.GetAt(i);
|
|
pFiler->writeString((const TCHAR *)sLine);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbAssembleWell::dxfInFields(AcDbDxfFiler *pFiler)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbAssembleWell::dxfOutFields(AcDbDxfFiler *pFiler) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
int AecDbAssembleWell::GetSectionDraw(const AcGePoint3d &ptFr, const AcGePoint3d &ptTo, const AcGeVector3d &vtViewDir, const AcGeVector3d &vtTo, AcDbVoidPtrArray &arRegionPtrs) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
bool AecDbAssembleWell::IsPLSyntaxCheck(const TCHAR *pLine) const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool AecDbAssembleWell::NewAecEntity(AcDbVoidPtrArray &arEntPtrs, CString& sSml, int& nAddOrSub) const
|
|
{
|
|
//关键字WALL SLAB PIPE HOLE CON.
|
|
CMapString2Int mapClass2Type;
|
|
mapClass2Type.SetAt(_T("WALL"),1);
|
|
mapClass2Type.SetAt(_T("SLAB"),2);
|
|
mapClass2Type.SetAt(_T("PIPE"),3);
|
|
mapClass2Type.SetAt(_T("HOLE"),4);
|
|
mapClass2Type.SetAt(_T("CON"),5);
|
|
|
|
sSml.TrimLeft();
|
|
sSml.TrimRight();
|
|
|
|
int nPos = sSml.Find(_T(" "),0);
|
|
if (nPos == -1)
|
|
{
|
|
acutPrintf(_T("\n脚本语法错误!没有发现关键字!"));
|
|
return NULL;
|
|
}
|
|
|
|
CString sClass = sSml.Mid(0, nPos);
|
|
int nType = 0;
|
|
if (!mapClass2Type.Lookup(sClass, nType))
|
|
{
|
|
acutPrintf(_T("\n脚本语法错误!没有发现关键字类型!"));
|
|
return NULL;
|
|
}
|
|
|
|
CStringArray arInfo;
|
|
AecDbEntityBase::SplitStrintToArray(sSml, arInfo, _T(' '));
|
|
|
|
nAddOrSub = 1;
|
|
bool bFailed = false;
|
|
switch (nType)
|
|
{
|
|
case 1://WALL
|
|
{
|
|
bFailed = NewWall(arEntPtrs,arInfo);
|
|
break;
|
|
}
|
|
case 2://SLAB
|
|
{
|
|
bFailed = NewSlab(arEntPtrs, arInfo);
|
|
break;
|
|
}
|
|
case 3://PIPE
|
|
{
|
|
bFailed = NewPipe(arEntPtrs, arInfo);
|
|
break;
|
|
}
|
|
case 4://HOLE
|
|
{
|
|
bFailed = NewHole(arEntPtrs, arInfo);
|
|
nAddOrSub = 0;
|
|
break;
|
|
}
|
|
case 5://CON
|
|
{
|
|
bFailed = NewCon(arEntPtrs, arInfo);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
if (bFailed)
|
|
{
|
|
acutPrintf(_T("\n%s"), sSml);
|
|
}
|
|
return bFailed;
|
|
}
|
|
|
|
typedef struct RectWall
|
|
{
|
|
double dt;
|
|
double dH;
|
|
double dL;
|
|
double dW;
|
|
double dBomEl;
|
|
double dX, dY;
|
|
TCHAR szName[33];
|
|
int nColor;
|
|
}RECTWALL;
|
|
|
|
//t h D 标高 偏移(X,Y) 井筒 0
|
|
typedef struct CirWall
|
|
{
|
|
double dt;
|
|
double dH;
|
|
double dD;
|
|
double dBomEl;
|
|
double dX, dY;
|
|
TCHAR szName[33];
|
|
int nColor;
|
|
}CIRWALL;
|
|
|
|
typedef struct ArcWall
|
|
{
|
|
double dt;
|
|
double dH;
|
|
double dD;
|
|
double dStaAng;
|
|
double dEndAng;
|
|
double dBomEl;
|
|
double dX, dY;
|
|
TCHAR szName[33];
|
|
int nColor;
|
|
}ARCWALL;
|
|
|
|
typedef struct PWall
|
|
{
|
|
double dt;
|
|
double dH;
|
|
|
|
ads_point pt[65];//默认最多64个点
|
|
|
|
double dBomEl;
|
|
TCHAR szName[33];
|
|
int nColor;
|
|
}PWALL;
|
|
|
|
BOOL AecDbAssembleWell::CalValue(const CString &sExp,double& dRes) const
|
|
{
|
|
//公式计算器
|
|
KTExpressCalc cal;
|
|
AecDbObjXDataMap *pMap = (AecDbObjXDataMap *)&m_mapSpecXData;
|
|
AecDbObjXDataMap::It it = pMap->Begin();
|
|
AecDbObjXDataMap::It end = pMap->End();
|
|
|
|
AecXData cVal;
|
|
memset(&cVal, 0, sizeof(AecXData));
|
|
|
|
CString sKey,sVal;
|
|
for (; it != end; )
|
|
{
|
|
if (!pMap->GetNext(it, sKey, cVal))
|
|
break;
|
|
|
|
//替换
|
|
if (cVal.nVt == VT_I4)
|
|
{
|
|
cal.SetVariableData(sKey, 1.0 * cVal.nVal);
|
|
}
|
|
|
|
if (cVal.nVt == VT_R8)
|
|
{
|
|
cal.SetVariableData(sKey, cVal.dVal[0]);
|
|
}
|
|
}
|
|
|
|
dRes = 0;
|
|
if (!cal.Calculate(sExp, dRes))
|
|
{
|
|
CString sEr;
|
|
KTExpressCalc::EErrorCode eE = cal.GetErrorCode();
|
|
switch (eE)
|
|
{
|
|
case KTExpressCalc::eVarialbeNotFind:
|
|
sEr = _T("变量没有找到");
|
|
break;
|
|
case KTExpressCalc::eNullExpress:
|
|
sEr = _T("表达式为空");
|
|
break;
|
|
case KTExpressCalc::eMissLeftPthis:
|
|
sEr = _T("缺少左括号");
|
|
break;
|
|
case KTExpressCalc::eMissVariable:
|
|
sEr = _T("缺少操作数");
|
|
break;
|
|
case KTExpressCalc::eMissOperator:
|
|
sEr = _T("缺少操作符");
|
|
break;
|
|
case KTExpressCalc::eMissIf:
|
|
sEr = _T("缺少if");
|
|
break;
|
|
case KTExpressCalc::eMissThen:
|
|
sEr = _T("缺少then");
|
|
break;
|
|
case KTExpressCalc::eMissElse:
|
|
sEr = _T("缺少else");
|
|
break;
|
|
case KTExpressCalc::eInvalidOperator:
|
|
sEr = _T("错误的操作符");
|
|
break;
|
|
case KTExpressCalc::eInvalidVariable:
|
|
sEr = _T("错误的操作数");
|
|
break;
|
|
case KTExpressCalc::eOutOfBound:
|
|
sEr = _T("计算值溢出");
|
|
break;
|
|
}
|
|
acutPrintf(_T("\n表达式:%s错误:%s"),sExp,sEr);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbAssembleWell::CalXYOffset(CString& sXYOff, double& dX, double &dY) const
|
|
{
|
|
sXYOff.TrimLeft(_T('('));
|
|
sXYOff.TrimRight(_T(')'));
|
|
|
|
int nPos = sXYOff.Find(_T(','));
|
|
if (nPos == -1)
|
|
{
|
|
acutPrintf(_T("\n偏移数据位缺失!"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (!CalValue(sXYOff.Left(nPos), dX))
|
|
return FALSE;
|
|
if (!CalValue(sXYOff.Mid(nPos + 1),dY))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecDbAssembleWell::CalPoint2d(CString &sPt, ads_point &pt) const
|
|
{
|
|
return CalXYOffset(sPt,pt[X], pt[Y]);
|
|
}
|
|
|
|
bool AecDbAssembleWell::NewWall(AcDbVoidPtrArray &arEntPtrs ,CStringArray &arInfo) const
|
|
{
|
|
//R / C / A / P / L
|
|
CMapString2Int map2Type;
|
|
map2Type.SetAt(_T("R"), 0);
|
|
map2Type.SetAt(_T("C"), 1);
|
|
map2Type.SetAt(_T("A"), 2);
|
|
map2Type.SetAt(_T("P"), 3);
|
|
map2Type.SetAt(_T("L"), 4);
|
|
|
|
CString sType = arInfo.GetAt(1);
|
|
sType.TrimLeft();
|
|
sType.TrimRight();
|
|
|
|
int nType = 0, nPos = -1;
|
|
map2Type.Lookup(sType, nType);
|
|
AecDbXWall *pWall = NULL;
|
|
|
|
AcGePoint3d ptGe[5],ptS,ptE;
|
|
CString sXYOff;
|
|
AcGeMatrix3d xM;
|
|
AcGeVector3d vM;
|
|
switch (nType)
|
|
{
|
|
case 0://R
|
|
{
|
|
//WALL R b H A B 0 (0 ,0) 井筒 0
|
|
if (arInfo.GetSize() < 10)
|
|
{
|
|
acutPrintf(_T("\n矩形墙体数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
RectWall rW;
|
|
memset(&rW, 0, sizeof(RectWall));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), rW.dt))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), rW.dH))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(4), rW.dL))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(5), rW.dW))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(6), rW.dBomEl))
|
|
return false;
|
|
|
|
sXYOff = arInfo.GetAt(7);
|
|
CalXYOffset(sXYOff, rW.dX, rW.dY);
|
|
|
|
vM.set(rW.dX, rW.dY,0);
|
|
xM.setToTranslation(vM);
|
|
|
|
_tcscpy(rW.szName, arInfo.GetAt(8));
|
|
rW.nColor = _ttoi(arInfo.GetAt(9));
|
|
|
|
ptGe[0].set(0, 0, 0);
|
|
ptGe[0].x -= 0.5 * rW.dL;
|
|
ptGe[0].y += 0.5 * rW.dW;
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1].x += rW.dL;
|
|
ptGe[2] = ptGe[1];
|
|
ptGe[2].y -= rW.dW;
|
|
ptGe[3] = ptGe[0];
|
|
ptGe[3].y -= rW.dW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbLine ln[4];
|
|
|
|
ptS = ptGe[0]; ptS.x -= 0.5 *rW.dt;
|
|
ptE = ptGe[1]; ptE.x += 0.5 * rW.dt;
|
|
ln[0].setStartPoint(ptS);
|
|
ln[0].setEndPoint(ptE);
|
|
|
|
ptS = ptGe[1]; ptS.y += 0.5 * rW.dt;
|
|
ptE = ptGe[2]; ptE.y -= 0.5 * rW.dt;
|
|
ln[1].setStartPoint(ptS);
|
|
ln[1].setEndPoint(ptE);
|
|
|
|
ptS = ptGe[2]; ptS.x += 0.5 * rW.dt;
|
|
ptE = ptGe[3]; ptE.x -= 0.5 * rW.dt;
|
|
ln[2].setStartPoint(ptS);
|
|
ln[2].setEndPoint(ptE);
|
|
|
|
ptS = ptGe[3]; ptS.y -= 0.5 * rW.dt;
|
|
ptE = ptGe[4]; ptE.y += 0.5 * rW.dt;
|
|
ln[3].setStartPoint(ptS);
|
|
ln[3].setEndPoint(ptE);
|
|
|
|
for (int j = 0;j < 4;j++)
|
|
{
|
|
ln[j].setNormal(AcGeVector3d::kZAxis);
|
|
ln[j].transformBy(xM);
|
|
|
|
pWall = new AecDbXWall;
|
|
pWall->SetWallData(rW.dt, rW.dH, rW.dBomEl, kMid);
|
|
pWall->SetBaseCurve(&ln[j]);//clone
|
|
pWall->setColorIndex(rW.nColor);
|
|
pWall->GetSpecialtyData()->SetAt(KEY_NAME, rW.szName);
|
|
pWall->GetSpecialtyData()->SetAt(_T("COLOR"), rW.nColor);
|
|
arEntPtrs.append(pWall);
|
|
}
|
|
break;
|
|
}
|
|
case 1://C
|
|
{
|
|
//WALL C t h D 标高 偏移(X,Y) 井筒 0
|
|
if (arInfo.GetSize() < 9)
|
|
{
|
|
acutPrintf(_T("\n圆形墙体数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
CirWall cW;
|
|
memset(&cW, 0, sizeof(CirWall));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), cW.dt))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), cW.dH))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(4), cW.dD))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(5), cW.dBomEl))
|
|
return false;
|
|
|
|
sXYOff = arInfo.GetAt(6);
|
|
CalXYOffset(sXYOff, cW.dX,cW.dY);
|
|
|
|
vM.set(cW.dX, cW.dY, 0);
|
|
xM.setToTranslation(vM);
|
|
|
|
_tcscpy(cW.szName, arInfo.GetAt(7));
|
|
cW.nColor = _ttoi(arInfo.GetAt(8));
|
|
|
|
AcDbCircle cir;
|
|
cir.setCenter(AcGePoint3d::kOrigin);
|
|
cir.setRadius(0.5 * cW.dD);
|
|
cir.setNormal(AcGeVector3d::kZAxis);
|
|
cir.transformBy(xM);
|
|
|
|
pWall = new AecDbXWall;
|
|
pWall->SetWallData(cW.dt, cW.dH, cW.dBomEl, kMid);
|
|
pWall->SetBaseCurve(&cir);//clone
|
|
pWall->setColorIndex(cW.nColor);
|
|
pWall->GetSpecialtyData()->SetAt(_T("COLOR"), cW.nColor);
|
|
pWall->GetSpecialtyData()->SetAt(KEY_NAME, cW.szName);
|
|
arEntPtrs.append(pWall);
|
|
break;
|
|
}
|
|
case 2://A
|
|
{
|
|
//WALL A t h D 90 270 0 (0,0) 井筒 0
|
|
if (arInfo.GetSize() < 11)
|
|
{
|
|
acutPrintf(_T("\n弧墙体数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
ArcWall aW;
|
|
memset(&aW, 0, sizeof(ArcWall));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), aW.dt))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), aW.dH))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(4), aW.dD))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(5), aW.dStaAng))
|
|
return false;
|
|
aW.dStaAng *= PI / 180.0;
|
|
if (!CalValue(arInfo.GetAt(6), aW.dEndAng))
|
|
return false;
|
|
aW.dEndAng *= PI / 180.0;
|
|
|
|
if (!CalValue(arInfo.GetAt(7), aW.dBomEl))
|
|
return false;
|
|
|
|
sXYOff = arInfo.GetAt(8);
|
|
CalXYOffset(sXYOff, aW.dX, aW.dY);
|
|
|
|
_tcscpy(aW.szName, arInfo.GetAt(9));
|
|
aW.nColor = _ttoi(arInfo.GetAt(10));
|
|
|
|
vM.set(aW.dX, aW.dY, 0);
|
|
xM.setToTranslation(vM);
|
|
|
|
AcDbArc arc;
|
|
arc.setCenter(AcGePoint3d::kOrigin);
|
|
arc.setRadius(0.5 * aW.dD);
|
|
arc.setNormal(AcGeVector3d::kZAxis);
|
|
arc.setStartAngle(aW.dStaAng);
|
|
arc.setEndAngle(aW.dEndAng);
|
|
arc.transformBy(xM);
|
|
|
|
pWall = new AecDbXWall;
|
|
pWall->SetWallData(aW.dt, aW.dH, aW.dBomEl, kMid);
|
|
pWall->SetBaseCurve(&arc);//clone
|
|
pWall->setColorIndex(aW.nColor);
|
|
pWall->GetSpecialtyData()->SetAt(_T("COLOR"), aW.nColor);
|
|
pWall->GetSpecialtyData()->SetAt(KEY_NAME, aW.szName);
|
|
arEntPtrs.append(pWall);
|
|
break;
|
|
}
|
|
case 3://P
|
|
{
|
|
//WALL P t H 点 点 点 标高 井筒 颜色
|
|
if (arInfo.GetSize() < 10)//至少3点
|
|
{
|
|
acutPrintf(_T("\n区域墙体数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
PWall pW;
|
|
memset(&pW, 0, sizeof(PWall));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), pW.dt))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), pW.dH))
|
|
return false;
|
|
|
|
int nTo = arInfo.GetSize() - 3;//标高 井筒 颜色
|
|
int nFr = 4;
|
|
|
|
AcDbPolyline pl;
|
|
for (int j = nFr;j < nTo;j++)
|
|
{
|
|
sXYOff = arInfo.GetAt(j);
|
|
CalPoint2d(sXYOff,pW.pt[j - nFr]);
|
|
pl.addVertexAt(j - nFr, asPnt2d(pW.pt[j-nFr]));
|
|
}
|
|
|
|
if (!CalValue(arInfo.GetAt(nTo), pW.dBomEl))
|
|
return false;
|
|
|
|
_tcscpy(pW.szName, arInfo.GetAt(nTo+1));
|
|
pW.nColor = _ttoi(arInfo.GetAt(nTo+2));
|
|
|
|
AcDbVoidPtrArray arCurPtrs;
|
|
pl.explode(arCurPtrs);
|
|
|
|
AcDbCurve *pCur = NULL;
|
|
for (int i = 0; i < arCurPtrs.length(); i++)
|
|
{
|
|
pCur = (AcDbCurve*)arCurPtrs.at(i);
|
|
pWall = new AecDbXWall;
|
|
pWall->SetWallData(pW.dt, pW.dH, pW.dBomEl, kMid);
|
|
pWall->SetBaseCurve(pCur);//clone
|
|
pWall->setColorIndex(pW.nColor);
|
|
pWall->GetSpecialtyData()->SetAt(_T("COLOR"), pW.nColor);
|
|
pWall->GetSpecialtyData()->SetAt(KEY_NAME, pW.szName);
|
|
delete pCur;
|
|
arEntPtrs.append(pWall);
|
|
}
|
|
break;
|
|
}
|
|
case 4://L
|
|
{
|
|
//WALL L t H 点 点 标高 井筒 颜色
|
|
if (arInfo.GetSize() < 8)//至少3点
|
|
{
|
|
acutPrintf(_T("\n直墙体数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
PWall pW;
|
|
memset(&pW, 0, sizeof(PWall));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), pW.dt))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), pW.dH))
|
|
return false;
|
|
|
|
sXYOff = arInfo.GetAt(4);
|
|
CalPoint2d(sXYOff, pW.pt[0]);
|
|
|
|
sXYOff = arInfo.GetAt(5);
|
|
CalPoint2d(sXYOff, pW.pt[1]);
|
|
|
|
if (!CalValue(arInfo.GetAt(6), pW.dBomEl))
|
|
return false;
|
|
|
|
_tcscpy(pW.szName, arInfo.GetAt(7));
|
|
pW.nColor = _ttoi(arInfo.GetAt(8));
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(asPnt3d(pW.pt[0]));
|
|
ln.setEndPoint(asPnt3d(pW.pt[1]));
|
|
ln.setNormal(AcGeVector3d::kZAxis);
|
|
|
|
pWall = new AecDbXWall;
|
|
pWall->SetWallData(pW.dt, pW.dH, pW.dBomEl, kMid);
|
|
pWall->SetBaseCurve(&ln);//clone
|
|
pWall->setColorIndex(pW.nColor);
|
|
pWall->GetSpecialtyData()->SetAt(_T("COLOR"), pW.nColor);
|
|
pWall->GetSpecialtyData()->SetAt(KEY_NAME, pW.szName);
|
|
arEntPtrs.append(pWall);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
typedef struct RSlab
|
|
{
|
|
double dt;
|
|
double dL;
|
|
double dW;
|
|
double dBomEl;
|
|
double dX;
|
|
double dY;
|
|
TCHAR szName[33];
|
|
int nColor;
|
|
}RSLAB;
|
|
|
|
typedef struct CirSlab
|
|
{
|
|
double dt;
|
|
double dD;
|
|
double dBomEl;
|
|
double dX;
|
|
double dY;
|
|
TCHAR szName[33];
|
|
int nColor;
|
|
}CIRSLAB;
|
|
|
|
typedef struct ArcSlab
|
|
{
|
|
double dt;
|
|
double dD;
|
|
double dStaAng;
|
|
double dEndAng;
|
|
double dBomEl;
|
|
double dX;
|
|
double dY;
|
|
TCHAR szName[33];
|
|
int nColor;
|
|
}ARCSLAB;
|
|
|
|
typedef struct PSlab
|
|
{
|
|
double dt;
|
|
ads_point pt[65];//默认最多64个点
|
|
|
|
double dBomEl;
|
|
TCHAR szName[33];
|
|
int nColor;
|
|
}PSLAB;
|
|
|
|
bool AecDbAssembleWell::NewSlab(AcDbVoidPtrArray &arEntPtrs, CStringArray &arInfo) const
|
|
{
|
|
//SLAB R / A / C / P DATA E 偏移[名称]板 颜色
|
|
CMapString2Int map2Type;
|
|
map2Type.SetAt(_T("R"), 0);
|
|
map2Type.SetAt(_T("C"), 1);
|
|
map2Type.SetAt(_T("A"), 2);
|
|
map2Type.SetAt(_T("P"), 3);
|
|
|
|
CString sType = arInfo.GetAt(1);
|
|
sType.TrimLeft();
|
|
sType.TrimRight();
|
|
|
|
int nType = 0, nPos = -1;
|
|
map2Type.Lookup(sType, nType);
|
|
AecDbXSlab *pSlab = NULL;
|
|
|
|
AcGePoint3d ptGe[5], ptS, ptE;
|
|
CString sXYOff;
|
|
AcGeMatrix3d xM;
|
|
AcGeVector3d vM;
|
|
|
|
switch (nType)
|
|
{
|
|
case 0://R
|
|
{
|
|
//SLAB R t L W E (X, Y) [名称] 1
|
|
//SLAB R t L W 1200 (100,300) 底板 1
|
|
if (arInfo.GetSize() < 9)
|
|
{
|
|
acutPrintf(_T("\n矩形板数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
RSlab rS;
|
|
memset(&rS, 0, sizeof(RSlab));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), rS.dt))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), rS.dL))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(4), rS.dW))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(5), rS.dBomEl))
|
|
return false;
|
|
sXYOff = arInfo.GetAt(6);
|
|
CalXYOffset(sXYOff, rS.dX, rS.dY);
|
|
|
|
vM.set(rS.dX, rS.dY, 0);
|
|
xM.setToTranslation(vM);
|
|
|
|
_tcscpy(rS.szName, arInfo.GetAt(7));
|
|
rS.nColor = _ttoi(arInfo.GetAt(8));
|
|
|
|
AcGePoint3d ptCen(0,0,0);
|
|
ptCen.transformBy(xM);
|
|
|
|
pSlab = new AecDbXSlab;
|
|
pSlab->SetRectSlab(rS.dL, rS.dW, rS.dt, rS.dBomEl,ptCen);
|
|
pSlab->setColorIndex(rS.nColor);
|
|
pSlab->GetSpecialtyData()->SetAt(KEY_NAME, rS.szName);
|
|
pSlab->GetSpecialtyData()->SetAt(_T("COLOR"), rS.nColor);
|
|
arEntPtrs.append(pSlab);
|
|
break;
|
|
}
|
|
case 1://C
|
|
{
|
|
//SLAB C t D 0 (0,0) 盖板 1
|
|
if (arInfo.GetSize() < 8)
|
|
{
|
|
acutPrintf(_T("\n圆形底板数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
CirSlab cS;
|
|
memset(&cS, 0, sizeof(CirSlab));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), cS.dt))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), cS.dD))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(4), cS.dBomEl))
|
|
return false;
|
|
|
|
sXYOff = arInfo.GetAt(5);
|
|
CalXYOffset(sXYOff, cS.dX, cS.dY);
|
|
|
|
vM.set(cS.dX, cS.dY, 0);
|
|
xM.setToTranslation(vM);
|
|
|
|
_tcscpy(cS.szName, arInfo.GetAt(6));
|
|
cS.nColor = _ttoi(arInfo.GetAt(7));
|
|
|
|
AcGePoint3d ptCen(0, 0, 0);
|
|
ptCen.transformBy(xM);
|
|
|
|
pSlab = new AecDbXSlab;
|
|
pSlab->SetCircleSlab(0.5 * cS.dD, cS.dt, cS.dBomEl,ptCen);
|
|
pSlab->setColorIndex(cS.nColor);
|
|
pSlab->GetSpecialtyData()->SetAt(KEY_NAME, cS.szName);
|
|
pSlab->GetSpecialtyData()->SetAt(_T("COLOR"), cS.nColor);
|
|
arEntPtrs.append(pSlab);
|
|
break;
|
|
}
|
|
case 2://A
|
|
{
|
|
//SLAB A t D 90 270 0 (0,0) 盖板 1
|
|
if (arInfo.GetSize() < 10)
|
|
{
|
|
acutPrintf(_T("\n扇形底板数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
ArcSlab aS;
|
|
memset(&aS, 0, sizeof(ArcSlab));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), aS.dt))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), aS.dD))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(4), aS.dStaAng))
|
|
return false;
|
|
aS.dStaAng *= PI / 180.0;
|
|
if (!CalValue(arInfo.GetAt(5), aS.dEndAng))
|
|
return false;
|
|
aS.dEndAng *= PI / 180.0;
|
|
|
|
if (!CalValue(arInfo.GetAt(6), aS.dBomEl))
|
|
return false;
|
|
|
|
sXYOff = arInfo.GetAt(7);
|
|
CalXYOffset(sXYOff, aS.dX, aS.dY);
|
|
|
|
vM.set(aS.dX, aS.dY, 0);
|
|
xM.setToTranslation(vM);
|
|
|
|
_tcscpy(aS.szName, arInfo.GetAt(8));
|
|
aS.nColor = _ttoi(arInfo.GetAt(9));
|
|
|
|
AcGePoint3d ptCen(0, 0, 0);
|
|
ptCen.transformBy(xM);
|
|
|
|
pSlab = new AecDbXSlab;
|
|
pSlab->SetSectorSlab(0.5 * aS.dD, aS.dt, aS.dBomEl,aS.dStaAng,aS.dEndAng, ptCen);
|
|
pSlab->setColorIndex(aS.nColor);
|
|
pSlab->GetSpecialtyData()->SetAt(KEY_NAME, aS.szName);
|
|
pSlab->GetSpecialtyData()->SetAt(_T("COLOR"), aS.nColor);
|
|
arEntPtrs.append(pSlab);
|
|
|
|
break;
|
|
}
|
|
case 3://P
|
|
{
|
|
//SLAB P t 点 点 … 底标高 名称 颜色
|
|
if (arInfo.GetSize() < 9)//至少3点
|
|
{
|
|
acutPrintf(_T("\n区域板数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
PSlab pS;
|
|
memset(&pS, 0, sizeof(PSlab));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), pS.dt))
|
|
return false;
|
|
|
|
int nTo = arInfo.GetSize() - 3;//标高 名称 颜色
|
|
int nFr = 4;
|
|
|
|
AcGePoint2dArray arPts;
|
|
AcDbExtents ext;
|
|
for (int j = nFr; j < nTo; j++)
|
|
{
|
|
sXYOff = arInfo.GetAt(j);
|
|
CalPoint2d(sXYOff, pS.pt[j - nFr]);
|
|
arPts.append(asPnt2d(pS.pt[j - nFr]));
|
|
ext.addPoint(asPnt3d(pS.pt[j - nFr]));
|
|
}
|
|
|
|
if (!CalValue(arInfo.GetAt(nTo), pS.dBomEl))
|
|
return false;
|
|
|
|
_tcscpy(pS.szName, arInfo.GetAt(nTo + 1));
|
|
pS.nColor = _ttoi(arInfo.GetAt(nTo + 2));
|
|
|
|
AcGePoint3d ptCen;
|
|
ptCen = MidPoint(ext.minPoint(), ext.maxPoint());
|
|
pSlab = new AecDbXSlab;
|
|
pSlab->SetRegionSlab(arPts, pS.dt, pS.dBomEl, ptCen);
|
|
pSlab->setColorIndex(pS.nColor);
|
|
pSlab->GetSpecialtyData()->SetAt(KEY_NAME, pS.szName);
|
|
pSlab->GetSpecialtyData()->SetAt(_T("COLOR"), pS.nColor);
|
|
arEntPtrs.append(pSlab);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
typedef struct XPipe
|
|
{
|
|
double dt;
|
|
double dS[2];
|
|
ads_point pt;
|
|
double dLen;
|
|
double dAng;
|
|
double dBomEl;
|
|
TCHAR szName[33];
|
|
int nColor;
|
|
}XPIPE;
|
|
|
|
bool AecDbAssembleWell::NewPipe(AcDbVoidPtrArray &arEntPtrs, CStringArray &arInfo) const
|
|
{
|
|
//PIPE R / C DATA E 管 颜色
|
|
CMapString2Int map2Type;
|
|
map2Type.SetAt(_T("R"), 0);
|
|
map2Type.SetAt(_T("C"), 1);
|
|
|
|
CString sPt;
|
|
CString sType = arInfo.GetAt(1);
|
|
sType.TrimLeft();
|
|
sType.TrimRight();
|
|
|
|
int nType = 0, nPos = -1;
|
|
map2Type.Lookup(sType, nType);
|
|
|
|
AecDbEwPipeBase *pPipe = NULL;
|
|
switch (nType)
|
|
{
|
|
case 0://R
|
|
{
|
|
//PIPE R t L W (0,0) D 0.5*D 45 套管 1
|
|
if (arInfo.GetSize() < 11)
|
|
{
|
|
acutPrintf(_T("\n矩形管数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
XPipe xp;
|
|
memset(&xp, 0, sizeof(XPipe));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), xp.dt))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), xp.dS[0]))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(4), xp.dS[1]))
|
|
return false;
|
|
|
|
sPt = arInfo.GetAt(5);
|
|
CalXYOffset(sPt, xp.pt[X],xp.pt[Y]);
|
|
|
|
if (!CalValue(arInfo.GetAt(6), xp.dLen))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(7), xp.dBomEl))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(8), xp.dAng))
|
|
return false;
|
|
xp.dAng *= PI / 180.0;
|
|
|
|
_tcscpy(xp.szName, arInfo.GetAt(9));
|
|
xp.nColor = _ttoi(arInfo.GetAt(10));
|
|
|
|
AcGePoint3d pt2;
|
|
AcGeVector3d vt(1,0,0);
|
|
vt.rotateBy(xp.dAng, AcGeVector3d::kZAxis);
|
|
vt.normalize();
|
|
vt *= xp.dLen;
|
|
pt2 = asPnt3d(xp.pt) + vt;
|
|
pt2.z = xp.dBomEl;
|
|
xp.pt[Z] = xp.dBomEl;
|
|
AcDbLine ln;
|
|
ln.setStartPoint(asPnt3d(xp.pt));
|
|
ln.setEndPoint(pt2);
|
|
pPipe = new AecDbEwPipeBase;
|
|
pPipe->SetSection(xp.dS[0], xp.dS[1], xp.dt);
|
|
pPipe->SetBaseCurve(&ln);
|
|
pPipe->setColorIndex(xp.nColor);
|
|
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 1);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_SECSHAPE, eRect);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_DN, xp.dS[0]);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_OD, xp.dS[0]);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_EL, xp.dBomEl);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_DRAWDIR, WPipe::eOD);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_NAME, xp.szName);
|
|
pPipe->GetSpecialtyData()->SetAt(_T("COLOR"), xp.nColor);
|
|
arEntPtrs.append(pPipe);
|
|
break;
|
|
}
|
|
case 1://C
|
|
{
|
|
//PIPE C t D (0,0) L 0.5*D 60 套管 2
|
|
if (arInfo.GetSize() < 10)
|
|
{
|
|
acutPrintf(_T("\n圆管数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
XPipe xp;
|
|
memset(&xp, 0, sizeof(XPipe));
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), xp.dt))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), xp.dS[0]))
|
|
return false;
|
|
sPt = arInfo.GetAt(4);
|
|
CalXYOffset(sPt, xp.pt[X], xp.pt[Y]);
|
|
|
|
if (!CalValue(arInfo.GetAt(5), xp.dLen))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(6), xp.dBomEl))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(7), xp.dAng))
|
|
return false;
|
|
xp.dAng *= PI / 180.0;
|
|
|
|
_tcscpy(xp.szName, arInfo.GetAt(8));
|
|
xp.nColor = _ttoi(arInfo.GetAt(9));
|
|
|
|
AcGePoint3d pt2;
|
|
AcGeVector3d vt(1, 0, 0);
|
|
vt.rotateBy(xp.dAng, AcGeVector3d::kZAxis);
|
|
vt.normalize();
|
|
vt *= xp.dLen;
|
|
pt2 = asPnt3d(xp.pt) + vt;
|
|
pt2.z = xp.dBomEl;
|
|
xp.pt[Z] = xp.dBomEl;
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(asPnt3d(xp.pt));
|
|
ln.setEndPoint(pt2);
|
|
|
|
pPipe = new AecDbEwPipeBase;
|
|
pPipe->SetSection(xp.dS[0], xp.dt);
|
|
pPipe->SetBaseCurve(&ln);
|
|
pPipe->setColorIndex(xp.nColor);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 1);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_SECSHAPE, eCircle);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_DN, xp.dS[0]);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_OD, xp.dS[0]);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_EL, xp.dBomEl);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_DRAWDIR, WPipe::eOD);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_NAME, xp.szName);
|
|
pPipe->GetSpecialtyData()->SetAt(_T("COLOR"), xp.nColor);
|
|
arEntPtrs.append(pPipe);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
typedef struct XHole
|
|
{
|
|
double dS[2];
|
|
ads_point pt;
|
|
double dBomEl;
|
|
double dDeep;
|
|
double dAng;
|
|
TCHAR szName[33];
|
|
int nColor;
|
|
}XHOLE;
|
|
|
|
bool AecDbAssembleWell::NewHole(AcDbVoidPtrArray &arEntPtrs, CStringArray &arInfo) const
|
|
{
|
|
//HOLE R/C DATA E 洞
|
|
CMapString2Int map2Type;
|
|
map2Type.SetAt(_T("R"), 0);
|
|
map2Type.SetAt(_T("C"), 1);
|
|
|
|
CString sPt;
|
|
CString sType = arInfo.GetAt(1);
|
|
sType.TrimLeft();
|
|
sType.TrimRight();
|
|
|
|
int nType = 0, nPos = -1;
|
|
map2Type.Lookup(sType, nType);
|
|
|
|
XHole xh;
|
|
memset(&xh, 0, sizeof(XHole));
|
|
AecDbEwPipeBase *pPipe = NULL;
|
|
switch(nType)
|
|
{
|
|
case 0://R
|
|
{
|
|
//HOLE R L W (0,0) 0.5*W 0.5*B 45 出水口
|
|
if (arInfo.GetSize() < 9)
|
|
{
|
|
acutPrintf(_T("\n矩形洞口数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), xh.dS[0]))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(3), xh.dS[1]))
|
|
return false;
|
|
sPt = arInfo.GetAt(4);
|
|
CalXYOffset(sPt, xh.pt[X], xh.pt[Y]);
|
|
|
|
if (!CalValue(arInfo.GetAt(5), xh.dDeep))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(6), xh.dBomEl))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(7), xh.dAng))
|
|
return false;
|
|
xh.dAng *= PI / 180.0;
|
|
_tcscpy(xh.szName, arInfo.GetAt(8));
|
|
|
|
AcGePoint3d pt2;
|
|
AcGeVector3d vt(1, 0, 0);
|
|
vt.rotateBy(xh.dAng, AcGeVector3d::kZAxis);
|
|
vt.normalize();
|
|
vt *= xh.dDeep;
|
|
pt2 = asPnt3d(xh.pt) + vt;
|
|
pt2.z = xh.dBomEl;
|
|
xh.pt[Z] = xh.dBomEl;
|
|
AcDbLine ln;
|
|
ln.setStartPoint(asPnt3d(xh.pt));
|
|
ln.setEndPoint(pt2);
|
|
pPipe = new AecDbEwPipeBase;
|
|
pPipe->SetSection(xh.dS[0], xh.dS[1],0);
|
|
pPipe->SetBaseCurve(&ln);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 1);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_SECSHAPE, eRect);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_DN, xh.dS[0]);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_OD, xh.dS[0]);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_EL, xh.dBomEl);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_DRAWDIR, WPipe::eOD);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_NAME, xh.szName);
|
|
arEntPtrs.append(pPipe);
|
|
break;
|
|
}
|
|
case 1://C
|
|
{
|
|
//HOLE C D pt DEEP E DIR NAME
|
|
if (arInfo.GetSize() < 7)
|
|
{
|
|
acutPrintf(_T("\n圆形洞口数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
//计算表达式
|
|
if (!CalValue(arInfo.GetAt(2), xh.dS[0]))
|
|
return false;
|
|
|
|
sPt = arInfo.GetAt(3);
|
|
CalXYOffset(sPt, xh.pt[X], xh.pt[Y]);
|
|
|
|
if (!CalValue(arInfo.GetAt(4), xh.dDeep))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(5), xh.dBomEl))
|
|
return false;
|
|
if (!CalValue(arInfo.GetAt(6), xh.dAng))
|
|
return false;
|
|
|
|
xh.dAng *= PI / 180.0;
|
|
_tcscpy(xh.szName, arInfo.GetAt(7));
|
|
|
|
AcGePoint3d pt2;
|
|
AcGeVector3d vt(1, 0, 0);
|
|
vt.rotateBy(xh.dAng, AcGeVector3d::kZAxis);
|
|
vt.normalize();
|
|
vt *= xh.dDeep;
|
|
pt2 = asPnt3d(xh.pt) + vt;
|
|
pt2.z = xh.dBomEl;
|
|
xh.pt[Z] = xh.dBomEl;
|
|
AcDbLine ln;
|
|
ln.setStartPoint(asPnt3d(xh.pt));
|
|
ln.setEndPoint(pt2);
|
|
pPipe = new AecDbEwPipeBase;
|
|
pPipe->SetSection(xh.dS[0], 0);
|
|
pPipe->SetBaseCurve(&ln);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 1);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_SECSHAPE, eRect);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_DN, xh.dS[0]);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_OD, xh.dS[0]);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_EL, xh.dBomEl);
|
|
pPipe->GetSpecialtyData()->SetAt(PIPE_DRAWDIR, WPipe::eOD);
|
|
pPipe->GetSpecialtyData()->SetAt(KEY_NAME, xh.szName);
|
|
arEntPtrs.append(pPipe);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AecDbAssembleWell::NewCon(AcDbVoidPtrArray &arEntPtrs, CStringArray &arInfo) const
|
|
{
|
|
//CON R/C/P/A DATA E 偏移(X,Y) P DIR 素砼 颜
|
|
|
|
//1.先创建板.
|
|
//2.然后切割板
|
|
|
|
//SLAB R / A / C / P DATA E 偏移[名称]板 颜色
|
|
CMapString2Int map2Type;
|
|
map2Type.SetAt(_T("R"), 0);
|
|
map2Type.SetAt(_T("C"), 1);
|
|
map2Type.SetAt(_T("A"), 2);
|
|
map2Type.SetAt(_T("P"), 3);
|
|
|
|
if (arInfo.GetSize() < 5)
|
|
{
|
|
acutPrintf(_T("\n素砼数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
//确认倒数第5为是偏移数据
|
|
CString sXYOff = arInfo.GetAt(arInfo.GetSize() - 5);
|
|
if (sXYOff.Find(_T('(')) == -1)
|
|
{
|
|
acutPrintf(_T("\n素砼偏移数据位缺失!"));
|
|
return false;
|
|
}
|
|
|
|
int nEnd = arInfo.GetSize() - 1;
|
|
CString sDir = arInfo.GetAt(nEnd - 2);
|
|
ads_point ptDir;
|
|
if (!CalPoint2d(sDir, ptDir))
|
|
return false;
|
|
|
|
double dGrade = 0;
|
|
CString sP = arInfo.GetAt(nEnd - 3);
|
|
if (!CalValue(sP, dGrade) )
|
|
return false;
|
|
|
|
CString sType = arInfo.GetAt(1);
|
|
sType.TrimLeft();
|
|
sType.TrimRight();
|
|
|
|
int nType = 0, nPos = -1;
|
|
map2Type.Lookup(sType, nType);
|
|
|
|
CStringArray arInf2;
|
|
arInf2.Add(_T("SLAB"));
|
|
|
|
for (int i = 1;i < arInfo.GetSize() - 4;i++)
|
|
{
|
|
arInf2.Add(arInfo.GetAt(i));
|
|
}
|
|
arInf2.Add(_T("板"));
|
|
arInf2.Add(_T("1"));
|
|
|
|
AcDbVoidPtrArray arSlab;
|
|
NewSlab(arSlab, arInf2);
|
|
|
|
if (arSlab.length() == 1)
|
|
{
|
|
AecDbXSlab *pSlab = AecDbXSlab::cast((AcDbEntity*)arSlab.first());
|
|
if (pSlab != NULL)
|
|
{
|
|
AcDb3dSolid* pSolid = pSlab->GetDraw3dSolid(false, 0, false);
|
|
if (pSolid != NULL)
|
|
{
|
|
//从最高位置沿着坡度方向切割
|
|
AcDbExtents ext;
|
|
pSolid->getGeomExtents(ext);
|
|
|
|
//坡度转角度
|
|
AcGeVector3d vtP(ptDir[X], ptDir[Y], 0.0);
|
|
AcGeVector3d vtZ(0, 0, 1);
|
|
AcGeVector3d vtV = vtZ.crossProduct(vtP);
|
|
vtP.z = vtP.length() * dGrade;
|
|
vtP.normalize();
|
|
|
|
AcGePlane plan;
|
|
plan.set(ext.minPoint(), vtP, vtV);
|
|
AcGeVector3d vtN = plan.normal();
|
|
|
|
AcGeVector3d vtM(0,0,pSlab->GetThick());
|
|
AcGeMatrix3d xM;
|
|
xM.setToTranslation(vtM);
|
|
plan.transformBy(xM);
|
|
|
|
AcGePoint3d ptOrg;
|
|
AcGeVector3d vt1, vt2;
|
|
plan.getCoordSystem(ptOrg, vt1, vt2);
|
|
vt1.normalize(); vt2.normalize();
|
|
|
|
AcGePoint3d ptGe[5];
|
|
ptGe[0] = ptOrg;
|
|
ptGe[0] -= 1000 * vt1;
|
|
ptGe[0] += 1000 * vt2;
|
|
|
|
ptGe[1] = ptGe[0] + 2000 * vt1;
|
|
ptGe[2] = ptGe[1] - 2000 * vt2;
|
|
ptGe[3] = ptGe[0] - 2000 * vt2;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbRegion *pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pReg != NULL)
|
|
{
|
|
pReg->setColorIndex(2);
|
|
arEntPtrs.append(pReg);
|
|
}
|
|
|
|
AcDb3dSolid *pNegHalfSolid = NULL;
|
|
if (Acad::eOk == pSolid->getSlice(plan, Adesk::kFalse, pNegHalfSolid))
|
|
{
|
|
arEntPtrs.append(pSolid);
|
|
}
|
|
}
|
|
delete pSlab;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|