1299 lines
36 KiB
C++
1299 lines
36 KiB
C++
#include "stdafx.h"
|
|
#include "KTCurveCreator.h"
|
|
#include "KT3DModel.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[]=__FILE__;
|
|
#define new DEBUG_NEW
|
|
#endif
|
|
|
|
namespace
|
|
{
|
|
BOOL GetArcParam(const AcGePoint3d& ptStart, const AcGePoint3d& ptEnd, double dBulge, const AcGeVector3d& vtNormal,
|
|
AcGePoint3d& ptCenter, double& dRadius, double& dStartAngle, double& dEndAngle)
|
|
{
|
|
ASSERT(!_IsZero_(dBulge));
|
|
ASSERT(ptStart != ptEnd);
|
|
|
|
// 调整顺序
|
|
const AcGePoint3d* pt1;
|
|
const AcGePoint3d* pt2;
|
|
if (dBulge < 0.0)
|
|
{
|
|
pt1 = &ptEnd;
|
|
pt2 = &ptStart;
|
|
dBulge = -dBulge;
|
|
}
|
|
else
|
|
{
|
|
pt1 = &ptStart;
|
|
pt2 = &ptEnd;
|
|
}
|
|
|
|
// 直角三角形对边与斜边关系R = L/sin(A/2)
|
|
// 代入万能公式 sin(A)=2*tg(A/2)/(1+tg(A/2)*tg(A/2))
|
|
// 得到 R = L*(1+B*B) / (2B) -->L:(p1->p2)/2 B:bulge
|
|
double dL = pt1->distanceTo(*pt2) / 2.0;
|
|
dRadius = dL * (1 + dBulge * dBulge) / (2.0 * dBulge);
|
|
|
|
double dA = PI / 2.0 - atan(dBulge) * 2.0;
|
|
AcGeVector3d vt(*pt2 - *pt1);
|
|
vt.rotateBy(dA, vtNormal);
|
|
vt.normalize();
|
|
ptCenter = *pt1 + vt * dRadius;
|
|
|
|
acdbWcs2Ecs(asDblArray(AcGeVector3d::kXAxis), asDblArray(vt), asDblArray(vtNormal), true);
|
|
dStartAngle = vt.angleTo(*pt1 - ptCenter, vtNormal);
|
|
dEndAngle = vt.angleTo(*pt2 - ptCenter, vtNormal);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
namespace KTAcadUtl {
|
|
|
|
#define BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation) \
|
|
DWORD dwBit, dwFlag = 0; \
|
|
do \
|
|
{ \
|
|
if (RTSTR == pRb->restype) \
|
|
{ \
|
|
dwBit = 0; \
|
|
if (FALSE) ; \
|
|
ON_RESBUF_CHAR_NA(pRb, _T("Layer"), sLayer); \
|
|
ON_RESBUF_CHAR_NA(pRb, _T("XData"), sXData); \
|
|
ON_RESBUF_POINT_NA(pRb, _T("Position"), ptPosition); \
|
|
ON_RESBUF_POINT_NA(pRb, _T("Rotation"), ptRotation) \
|
|
|
|
#define ON_RESBUF_BOOL ON_RESBUF_INT
|
|
#define ON_RESBUF_BOOL_NA ON_RESBUF_INT_NA
|
|
#define ON_RESBUF_INT(pRb, pszParam, lValue) \
|
|
else if ((++dwBit) && _tcsicmp(pRb->resval.rstring, pszParam) == 0 \
|
|
&& NULL != (pRb = pRb->rbnext) && RTLONG == pRb->restype && (dwFlag |= (1<<dwBit))) \
|
|
lValue = pRb->resval.rlong \
|
|
|
|
#define ON_RESBUF_INT_NA(pRb, pszParam, lValue) \
|
|
else if (_tcsicmp(pRb->resval.rstring, pszParam) == 0 \
|
|
&& NULL != (pRb = pRb->rbnext) && RTLONG == pRb->restype) \
|
|
lValue = pRb->resval.rlong \
|
|
|
|
#define ON_RESBUF_REAL(pRb, pszParam, dValue) \
|
|
else if ((++dwBit) && _tcsicmp(pRb->resval.rstring, pszParam) == 0 \
|
|
&& NULL != (pRb = pRb->rbnext) && RTREAL == pRb->restype && (dwFlag |= (1<<dwBit))) \
|
|
dValue = pRb->resval.rreal \
|
|
|
|
#define ON_RESBUF_REAL_NA(pRb, pszParam, dValue) \
|
|
else if (_tcsicmp(pRb->resval.rstring, pszParam) == 0 \
|
|
&& NULL != (pRb = pRb->rbnext) && RTREAL == pRb->restype) \
|
|
dValue = pRb->resval.rreal \
|
|
|
|
#define ON_RESBUF_CHAR(pRb, pszParam, sValue) \
|
|
else if ((++dwBit) && _tcsicmp(pRb->resval.rstring, pszParam) == 0 \
|
|
&& NULL != (pRb = pRb->rbnext) && RTSTR == pRb->restype && (dwFlag |= (1<<dwBit))) \
|
|
sValue = pRb->resval.rstring \
|
|
|
|
#define ON_RESBUF_CHAR_NA(pRb, pszParam, sValue) \
|
|
else if (_tcsicmp(pRb->resval.rstring, pszParam) == 0 \
|
|
&& NULL != (pRb = pRb->rbnext) && RTSTR == pRb->restype) \
|
|
sValue = pRb->resval.rstring \
|
|
|
|
#define ON_RESBUF_POINT(pRb, pszParam, ptValue) \
|
|
else if ((++dwBit) && _tcsicmp(pRb->resval.rstring, pszParam) == 0 \
|
|
&& NULL != (pRb = pRb->rbnext) && RT3DPOINT == pRb->restype && (dwFlag |= (1<<dwBit))) \
|
|
ptValue = asPnt3d(pRb->resval.rpoint) \
|
|
|
|
#define ON_RESBUF_POINT_NA(pRb, pszParam, ptValue) \
|
|
else if (_tcsicmp(pRb->resval.rstring, pszParam) == 0 \
|
|
&& NULL != (pRb = pRb->rbnext) && RT3DPOINT == pRb->restype) \
|
|
ptValue = asPnt3d(pRb->resval.rpoint) \
|
|
|
|
#define END_RESBUF_VALUE(pRb, nVars) \
|
|
else \
|
|
{ \
|
|
pRb = pRb->rbnext; \
|
|
} \
|
|
} \
|
|
pRb = (NULL == pRb ? NULL : pRb->rbnext); \
|
|
} while (NULL != pRb); \
|
|
dwBit = nVars; \
|
|
for (; dwBit > 0; dwBit--) \
|
|
if ((dwFlag & (1<<dwBit)) == 0) \
|
|
return \
|
|
|
|
void AttachAttr(AcDbEntity* pEnt, LPCTSTR pszLayer)
|
|
{
|
|
if (NULL == pEnt || NULL == pszLayer || _tcslen(pszLayer) <= 0)
|
|
return;
|
|
|
|
AcDbObjectId idLayer = KTSetting::InitLayer(pszLayer);
|
|
pEnt->setLayer(idLayer);
|
|
}
|
|
|
|
void AttachXData(AcDbEntity* pEnt, LPCTSTR pszXData)
|
|
{
|
|
if (NULL == pEnt || NULL == pszXData || _tcslen(pszXData) <= 0)
|
|
return;
|
|
|
|
resbuf rbHead, *pRb;
|
|
pRb = &rbHead;
|
|
|
|
int i;
|
|
CString sSub;
|
|
BOOL bStr = FALSE;
|
|
while (_T('\0') != pszXData[0])
|
|
{
|
|
i = _tcsinc(pszXData) - pszXData;
|
|
if (1 == i)
|
|
{
|
|
switch (pszXData[0])
|
|
{
|
|
case _T('\"'):
|
|
if (bStr)
|
|
bStr = FALSE;
|
|
else
|
|
bStr = TRUE;
|
|
break;
|
|
case _T(','):
|
|
if (bStr)
|
|
sSub += _T(',');
|
|
else
|
|
{
|
|
pRb->rbnext = acutNewRb(AcDb::kDxfXdAsciiString);
|
|
if (NULL != pRb->rbnext)
|
|
{
|
|
pRb = pRb->rbnext;
|
|
acutNewString(sSub, pRb->resval.rstring);
|
|
}
|
|
sSub.Empty();
|
|
}
|
|
break;
|
|
case _T('\\'):
|
|
if (_T('\"') == pszXData[1] || _T('\\') == pszXData[1]
|
|
|| _T(',') == pszXData[1] || _T(' ') == pszXData[1])
|
|
{
|
|
sSub += pszXData[1];
|
|
pszXData++;
|
|
}
|
|
else
|
|
{
|
|
sSub += _T('\\');
|
|
}
|
|
break;
|
|
case _T(' '):
|
|
if (bStr || !sSub.IsEmpty())
|
|
sSub += _T(' ');
|
|
break;
|
|
default:
|
|
sSub += pszXData[0];
|
|
break;
|
|
}
|
|
pszXData++;
|
|
}
|
|
else
|
|
{
|
|
for (; i > 0; i--, pszXData++)
|
|
sSub += pszXData[0];
|
|
}
|
|
}
|
|
|
|
pRb->rbnext = acutNewRb(AcDb::kDxfXdAsciiString);
|
|
if (NULL != pRb->rbnext)
|
|
{
|
|
pRb = pRb->rbnext;
|
|
acutNewString(sSub, pRb->resval.rstring);
|
|
}
|
|
|
|
if (NULL == rbHead.rbnext)
|
|
return;
|
|
|
|
rbHead.restype = AcDb::kDxfRegAppName;
|
|
rbHead.resval.rstring = _tcsdup(_T("KTParamPart"));
|
|
acdbRegApp(rbHead.resval.rstring);
|
|
|
|
pEnt->setXData(&rbHead);
|
|
|
|
acutRelRb(rbHead.rbnext);
|
|
}
|
|
|
|
void CreateLineDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
double dWidth;
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
|
|
ON_RESBUF_POINT(pRb, _T("EndPoint"), ptEnd);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
if (_IsZero_(dWidth))
|
|
{
|
|
AcDbLine* pLine = new AcDbLine(ptStart, ptEnd);
|
|
ASSERT(NULL != pLine);
|
|
|
|
AttachAttr(pLine, sLayer);
|
|
AttachXData(pLine, sXData);
|
|
|
|
pLine->setDatabaseDefaults();
|
|
arpEnts.append(pLine);
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline* pPLine = new AcDbPolyline(2);
|
|
ASSERT(NULL != pPLine);
|
|
AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
|
|
pPLine->setNormal(AcGeVector3d::kZAxis);
|
|
pPLine->addVertexAt(0, ptStart.convert2d(plane));
|
|
pPLine->addVertexAt(1, ptEnd.convert2d(plane));
|
|
pPLine->setConstantWidth(dWidth);
|
|
|
|
AttachAttr(pPLine, sLayer);
|
|
AttachXData(pPLine, sXData);
|
|
|
|
pPLine->setDatabaseDefaults();
|
|
arpEnts.append(pPLine);
|
|
}
|
|
}
|
|
|
|
void CreateLinePtAngLen(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dAngle, dLength, dWidth;
|
|
AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
|
|
ON_RESBUF_REAL(pRb, _T("Angle"), dAngle);
|
|
ON_RESBUF_REAL(pRb, _T("Length"), dLength);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
END_RESBUF_VALUE(pRb, 4);
|
|
|
|
AcGeVector3d vtDir(AcGeVector3d::kXAxis);
|
|
vtDir.rotateBy(dAngle, AcGeVector3d::kZAxis);
|
|
ptEnd = ptStart + vtDir * dLength;
|
|
|
|
if (_IsZero_(dWidth))
|
|
{
|
|
AcDbLine* pLine = new AcDbLine(ptStart, ptEnd);
|
|
ASSERT(NULL != pLine);
|
|
|
|
AttachAttr(pLine, sLayer);
|
|
AttachXData(pLine, sXData);
|
|
|
|
pLine->setDatabaseDefaults();
|
|
arpEnts.append(pLine);
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline* pPLine = new AcDbPolyline(2);
|
|
ASSERT(NULL != pPLine);
|
|
AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
|
|
pPLine->setNormal(AcGeVector3d::kZAxis);
|
|
pPLine->addVertexAt(0, ptStart.convert2d(plane));
|
|
pPLine->addVertexAt(1, ptEnd.convert2d(plane));
|
|
pPLine->setConstantWidth(dWidth);
|
|
|
|
AttachAttr(pPLine, sLayer);
|
|
AttachXData(pPLine, sXData);
|
|
|
|
pPLine->setDatabaseDefaults();
|
|
arpEnts.append(pPLine);
|
|
}
|
|
}
|
|
|
|
void CreateArcDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation, ptCenter;
|
|
double dRadius, dStartAngle, dEndAngle, dWidth;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("Center"), ptCenter);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("StartAngle"), dStartAngle);
|
|
ON_RESBUF_REAL(pRb, _T("EndAngle"), dEndAngle);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
END_RESBUF_VALUE(pRb, 5);
|
|
|
|
if (_IsZero_(dWidth))
|
|
{
|
|
AcDbArc* pArc = new AcDbArc(ptCenter, dRadius, dStartAngle, dEndAngle);
|
|
ASSERT(NULL != pArc);
|
|
|
|
AttachAttr(pArc, sLayer);
|
|
AttachXData(pArc, sXData);
|
|
|
|
pArc->setDatabaseDefaults();
|
|
arpEnts.append(pArc);
|
|
}
|
|
else
|
|
{
|
|
AcGePoint3d ptStart, ptEnd;
|
|
acutPolar(asDblArray(ptCenter), dStartAngle, dRadius, asDblArray(ptStart));
|
|
acutPolar(asDblArray(ptCenter), dEndAngle, dRadius, asDblArray(ptEnd));
|
|
double dAngle = dEndAngle - dStartAngle;
|
|
if (dAngle < 0.0) dAngle += PI * 2.0;
|
|
double dBulge = tan(dAngle / 4.0);
|
|
|
|
AcDbPolyline* pPLine = new AcDbPolyline(2);
|
|
ASSERT(NULL != pPLine);
|
|
AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
|
|
pPLine->setNormal(AcGeVector3d::kZAxis);
|
|
pPLine->addVertexAt(0, ptStart.convert2d(plane), dBulge);
|
|
pPLine->addVertexAt(1, ptEnd.convert2d(plane));
|
|
pPLine->setConstantWidth(dWidth);
|
|
|
|
AttachAttr(pPLine, sLayer);
|
|
AttachXData(pPLine, sXData);
|
|
|
|
pPLine->setDatabaseDefaults();
|
|
arpEnts.append(pPLine);
|
|
}
|
|
}
|
|
|
|
void CreateArcPtPtPt(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
double dWidth;
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd, ptOn;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
|
|
ON_RESBUF_POINT(pRb, _T("EndPoint"), ptEnd);
|
|
ON_RESBUF_POINT(pRb, _T("Point"), ptOn);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
END_RESBUF_VALUE(pRb, 4);
|
|
|
|
AcGePoint3d ptCenter;
|
|
double dRadius, dStartAngle, dEndAngle, dAngle;
|
|
AcGeCircArc3d geArc(ptStart, ptOn, ptEnd);
|
|
dAngle = AcGeVector3d::kXAxis.angleTo(geArc.refVec(), AcGeVector3d::kZAxis);
|
|
ptCenter = geArc.center();
|
|
dRadius = geArc.radius();
|
|
dStartAngle = fmod(dAngle + geArc.startAng(), PI * 2.0);
|
|
dEndAngle = fmod(dAngle + geArc.endAng(), PI * 2.0);
|
|
|
|
if (_IsZero_(dWidth))
|
|
{
|
|
AcDbArc* pArc = new AcDbArc(ptCenter, dRadius, dStartAngle, dEndAngle);
|
|
ASSERT(NULL != pArc);
|
|
|
|
AttachAttr(pArc, sLayer);
|
|
AttachXData(pArc, sXData);
|
|
|
|
pArc->setDatabaseDefaults();
|
|
arpEnts.append(pArc);
|
|
}
|
|
else
|
|
{
|
|
double dAngle = dEndAngle - dStartAngle;
|
|
if (dAngle < 0.0) dAngle += PI * 2.0;
|
|
double dBulge = tan(dAngle / 4.0);
|
|
|
|
AcDbPolyline* pPLine = new AcDbPolyline(2);
|
|
ASSERT(NULL != pPLine);
|
|
AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
|
|
pPLine->setNormal(AcGeVector3d::kZAxis);
|
|
pPLine->addVertexAt(0, ptStart.convert2d(plane), dBulge);
|
|
pPLine->addVertexAt(1, ptEnd.convert2d(plane));
|
|
pPLine->setConstantWidth(dWidth);
|
|
|
|
AttachAttr(pPLine, sLayer);
|
|
AttachXData(pPLine, sXData);
|
|
|
|
pPLine->setDatabaseDefaults();
|
|
arpEnts.append(pPLine);
|
|
}
|
|
}
|
|
|
|
void CreateArcPtPtBulge(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
double dBulge, dWidth;
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
|
|
ON_RESBUF_POINT(pRb, _T("EndPoint"), ptEnd);
|
|
ON_RESBUF_REAL(pRb, _T("Bulge"), dBulge);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
END_RESBUF_VALUE(pRb, 4);
|
|
|
|
if (_IsZero_(dWidth))
|
|
{
|
|
AcGePoint3d ptCenter;
|
|
double dRadius, dStartAngle, dEndAngle;
|
|
if (!GetArcParam(ptStart, ptEnd, dBulge, AcGeVector3d::kZAxis, ptCenter, dRadius, dStartAngle, dEndAngle))
|
|
return;
|
|
|
|
AcDbArc* pArc = new AcDbArc(ptCenter, dRadius, dStartAngle, dEndAngle);
|
|
ASSERT(NULL != pArc);
|
|
|
|
AttachAttr(pArc, sLayer);
|
|
AttachXData(pArc, sXData);
|
|
|
|
pArc->setDatabaseDefaults();
|
|
arpEnts.append(pArc);
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline* pPLine = new AcDbPolyline(2);
|
|
ASSERT(NULL != pPLine);
|
|
AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
|
|
pPLine->setNormal(AcGeVector3d::kZAxis);
|
|
pPLine->addVertexAt(0, ptStart.convert2d(plane), dBulge);
|
|
pPLine->addVertexAt(1, ptEnd.convert2d(plane));
|
|
pPLine->setConstantWidth(dWidth);
|
|
|
|
AttachAttr(pPLine, sLayer);
|
|
AttachXData(pPLine, sXData);
|
|
|
|
pPLine->setDatabaseDefaults();
|
|
arpEnts.append(pPLine);
|
|
}
|
|
}
|
|
|
|
void CreateCircleDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRadius, dWidth;
|
|
AcGePoint3d ptPosition, ptRotation, ptCenter;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("Center"), ptCenter);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
if (_IsZero_(dWidth))
|
|
{
|
|
AcDbCircle* pCircle = new AcDbCircle(ptCenter, AcGeVector3d::kZAxis, dRadius);
|
|
ASSERT(NULL != pCircle);
|
|
|
|
AttachAttr(pCircle, sLayer);
|
|
AttachXData(pCircle, sXData);
|
|
|
|
pCircle->setDatabaseDefaults();
|
|
arpEnts.append(pCircle);
|
|
}
|
|
else
|
|
{
|
|
AcGePoint3d ptStart(ptCenter + AcGeVector3d::kXAxis * dRadius);
|
|
AcGePoint3d ptEnd(ptCenter - AcGeVector3d::kXAxis * dRadius);
|
|
|
|
AcDbPolyline* pPLine = new AcDbPolyline(2);
|
|
ASSERT(NULL != pPLine);
|
|
AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
|
|
pPLine->setNormal(AcGeVector3d::kZAxis);
|
|
pPLine->addVertexAt(0, ptStart.convert2d(plane), 1);
|
|
pPLine->addVertexAt(1, ptEnd.convert2d(plane), 1);
|
|
pPLine->setConstantWidth(dWidth);
|
|
pPLine->setClosed(TRUE);
|
|
|
|
AttachAttr(pPLine, sLayer);
|
|
AttachXData(pPLine, sXData);
|
|
|
|
pPLine->setDatabaseDefaults();
|
|
arpEnts.append(pPLine);
|
|
}
|
|
}
|
|
|
|
void CreateCirclePtPtPt(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
double dWidth;
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation, pt1, pt2, pt3;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("Point1"), pt1);
|
|
ON_RESBUF_POINT(pRb, _T("Point2"), pt2);
|
|
ON_RESBUF_POINT(pRb, _T("Point3"), pt3);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
END_RESBUF_VALUE(pRb, 4);
|
|
|
|
double dRadius;
|
|
AcGePoint3d ptCenter;
|
|
AcGeCircArc3d geArc(pt1, pt2, pt3);
|
|
ptCenter = geArc.center();
|
|
dRadius = geArc.radius();
|
|
|
|
if (_IsZero_(dWidth))
|
|
{
|
|
AcDbCircle* pCircle = new AcDbCircle(ptCenter, AcGeVector3d::kZAxis, dRadius);
|
|
ASSERT(NULL != pCircle);
|
|
|
|
AttachAttr(pCircle, sLayer);
|
|
AttachXData(pCircle, sXData);
|
|
|
|
pCircle->setDatabaseDefaults();
|
|
arpEnts.append(pCircle);
|
|
}
|
|
else
|
|
{
|
|
AcGePoint3d ptStart(ptCenter + AcGeVector3d::kXAxis * dRadius);
|
|
AcGePoint3d ptEnd(ptCenter - AcGeVector3d::kXAxis * dRadius);
|
|
|
|
AcDbPolyline* pPLine = new AcDbPolyline(2);
|
|
ASSERT(NULL != pPLine);
|
|
AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
|
|
pPLine->setNormal(AcGeVector3d::kZAxis);
|
|
pPLine->addVertexAt(0, ptStart.convert2d(plane), 1);
|
|
pPLine->addVertexAt(1, ptEnd.convert2d(plane), 1);
|
|
pPLine->setConstantWidth(dWidth);
|
|
pPLine->setClosed(TRUE);
|
|
|
|
AttachAttr(pPLine, sLayer);
|
|
AttachXData(pPLine, sXData);
|
|
|
|
pPLine->setDatabaseDefaults();
|
|
arpEnts.append(pPLine);
|
|
}
|
|
}
|
|
|
|
void CreateCircleDiameter(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
double dWidth;
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
|
|
ON_RESBUF_POINT(pRb, _T("EndPoint"), ptEnd);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
AcGePoint3d ptCenter((ptStart.x + ptEnd.x) / 2.0, (ptStart.y + ptEnd.y) / 2.0, (ptStart.z + ptEnd.z) / 2.0);
|
|
double dRadius = ptStart.distanceTo(ptCenter);
|
|
|
|
if (_IsZero_(dWidth))
|
|
{
|
|
AcDbCircle* pCircle = new AcDbCircle(ptCenter, AcGeVector3d::kZAxis, dRadius);
|
|
ASSERT(NULL != pCircle);
|
|
|
|
AttachAttr(pCircle, sLayer);
|
|
AttachXData(pCircle, sXData);
|
|
|
|
pCircle->setDatabaseDefaults();
|
|
arpEnts.append(pCircle);
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline* pPLine = new AcDbPolyline(2);
|
|
ASSERT(NULL != pPLine);
|
|
AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
|
|
pPLine->setNormal(AcGeVector3d::kZAxis);
|
|
pPLine->addVertexAt(0, ptStart.convert2d(plane), 1);
|
|
pPLine->addVertexAt(1, ptEnd.convert2d(plane), 1);
|
|
pPLine->setConstantWidth(dWidth);
|
|
pPLine->setClosed(TRUE);
|
|
|
|
AttachAttr(pPLine, sLayer);
|
|
AttachXData(pPLine, sXData);
|
|
|
|
pPLine->setDatabaseDefaults();
|
|
arpEnts.append(pPLine);
|
|
}
|
|
}
|
|
|
|
void CreateEllipseDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation, ptCenter;
|
|
double dMajor, dMinor, dDirAngle, dStartAngle, dEndAngle;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("Center"), ptCenter);
|
|
ON_RESBUF_REAL(pRb, _T("MajorAxis"), dMajor);
|
|
ON_RESBUF_REAL(pRb, _T("MinorAxis"), dMinor);
|
|
ON_RESBUF_REAL(pRb, _T("DirectAngle"), dDirAngle);
|
|
ON_RESBUF_REAL(pRb, _T("StartAngle"), dStartAngle);
|
|
ON_RESBUF_REAL(pRb, _T("EndAngle"), dEndAngle);
|
|
END_RESBUF_VALUE(pRb, 6);
|
|
|
|
if (_IsZero_(dMajor))
|
|
return;
|
|
|
|
AcGeVector3d vtMajor(AcGeVector3d::kXAxis);
|
|
vtMajor.rotateBy(dDirAngle, AcGeVector3d::kZAxis);
|
|
|
|
AcDbEllipse* pEllipse = new AcDbEllipse(ptCenter, AcGeVector3d::kZAxis, vtMajor * dMajor / 2.0,
|
|
dMinor / dMajor, dStartAngle, dEndAngle);
|
|
ASSERT(NULL != pEllipse);
|
|
|
|
AttachAttr(pEllipse, sLayer);
|
|
AttachXData(pEllipse, sXData);
|
|
|
|
pEllipse->setDatabaseDefaults();
|
|
arpEnts.append(pEllipse);
|
|
}
|
|
|
|
void CreateEllipsePtPtRatio(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRatio, dStartAngle, dEndAngle;
|
|
AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
|
|
ON_RESBUF_POINT(pRb, _T("EndPoint"), ptEnd);
|
|
ON_RESBUF_REAL(pRb, _T("Ratio"), dRatio);
|
|
ON_RESBUF_REAL(pRb, _T("StartAngle"), dStartAngle);
|
|
ON_RESBUF_REAL(pRb, _T("EndAngle"), dEndAngle);
|
|
END_RESBUF_VALUE(pRb, 5);
|
|
|
|
AcGePoint3d ptCenter((ptStart.x + ptEnd.x) / 2.0, (ptStart.y + ptEnd.y) / 2.0, (ptStart.z + ptEnd.z) / 2.0);
|
|
AcGeVector3d vtMajor(ptStart - ptCenter);
|
|
|
|
AcDbEllipse* pEllipse = new AcDbEllipse(ptCenter, AcGeVector3d::kZAxis, vtMajor,
|
|
dRatio, dStartAngle, dEndAngle);
|
|
ASSERT(NULL != pEllipse);
|
|
|
|
AttachAttr(pEllipse, sLayer);
|
|
AttachXData(pEllipse, sXData);
|
|
|
|
pEllipse->setDatabaseDefaults();
|
|
arpEnts.append(pEllipse);
|
|
}
|
|
|
|
void CreateTextDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sContent;
|
|
double dHeight, dAngle;
|
|
CString sLayer, sXData, sStyle, sAlignment;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_CHAR_NA(pRb, _T("Style"), sStyle);
|
|
ON_RESBUF_CHAR_NA(pRb, _T("Alignment"), sAlignment);
|
|
ON_RESBUF_CHAR(pRb, _T("Content"), sContent);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
ON_RESBUF_REAL(pRb, _T("Angle"), dAngle);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
|
|
AcDbObjectId idStyle = KTSetting::InitTextStyle(sStyle);
|
|
if (idStyle.isNull()) idStyle = pDb->textstyle();
|
|
|
|
AcDbText* pText = new AcDbText(ptPosition, sContent, idStyle, dHeight, dAngle);
|
|
ASSERT(NULL != pText);
|
|
|
|
int iLen = sAlignment.GetLength();
|
|
for (int i = 0; i < iLen && !_istdigit(sAlignment[i]); i++) ;
|
|
int iAlign = ((i < iLen && sAlignment[i] <= _T('5')) ? sAlignment[i] - _T('0') : 0);
|
|
pText->setHorizontalMode((AcDb::TextHorzMode)iAlign);
|
|
//
|
|
for (i++; i < iLen && !_istdigit(sAlignment[i]); i++) ;
|
|
iAlign = ((i < iLen && sAlignment[i] <= _T('3')) ? sAlignment[i] - _T('0') : 0);
|
|
pText->setVerticalMode((AcDb::TextVertMode)iAlign);
|
|
//
|
|
pText->setAlignmentPoint(ptPosition);
|
|
pText->adjustAlignment(pDb);
|
|
|
|
AttachAttr(pText, sLayer);
|
|
AttachXData(pText, sXData);
|
|
|
|
pText->setDatabaseDefaults();
|
|
arpEnts.append(pText);
|
|
}
|
|
|
|
void CreatePointDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
END_RESBUF_VALUE(pRb, 0);
|
|
|
|
AcDbPoint* pPoint = new AcDbPoint(ptPosition);
|
|
ASSERT(NULL != pPoint);
|
|
|
|
AttachAttr(pPoint, sLayer);
|
|
AttachXData(pPoint, sXData);
|
|
|
|
pPoint->setDatabaseDefaults();
|
|
arpEnts.append(pPoint);
|
|
}
|
|
|
|
void CreateSolidDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation, pt1, pt2, pt3, pt4;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("First"), pt1);
|
|
ON_RESBUF_POINT(pRb, _T("Second"), pt2);
|
|
ON_RESBUF_POINT(pRb, _T("Third"), pt3);
|
|
ON_RESBUF_POINT(pRb, _T("Fourth"), pt4);
|
|
END_RESBUF_VALUE(pRb, 4);
|
|
|
|
AcDbSolid* pSolid = new AcDbSolid(pt1, pt2, pt3, pt4);
|
|
ASSERT(NULL != pSolid);
|
|
|
|
AttachAttr(pSolid, sLayer);
|
|
AttachXData(pSolid, sXData);
|
|
|
|
pSolid->setDatabaseDefaults();
|
|
arpEnts.append(pSolid);
|
|
}
|
|
|
|
void CreateSolidPtPtPt(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation, pt1, pt2, pt3;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_POINT(pRb, _T("First"), pt1);
|
|
ON_RESBUF_POINT(pRb, _T("Second"), pt2);
|
|
ON_RESBUF_POINT(pRb, _T("Third"), pt3);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
AcDbSolid* pSolid = new AcDbSolid(pt1, pt2, pt3);
|
|
ASSERT(NULL != pSolid);
|
|
|
|
AttachAttr(pSolid, sLayer);
|
|
AttachXData(pSolid, sXData);
|
|
|
|
pSolid->setDatabaseDefaults();
|
|
arpEnts.append(pSolid);
|
|
}
|
|
|
|
void CreateCubeDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dLength, dWidth, dHeight;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Length"), dLength);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::Cube(ptPosition, AcGeVector3d::kXAxis * dLength, AcGeVector3d::kYAxis * dWidth, AcGeVector3d::kZAxis * dHeight, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreateCylinderDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRadius, dHeight;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
END_RESBUF_VALUE(pRb, 2);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::Cylinder(ptPosition, dRadius, AcGeVector3d::kZAxis * dHeight, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreateConeDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRadius, dHeight;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
END_RESBUF_VALUE(pRb, 2);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::Cone(ptPosition, dRadius, AcGeVector3d::kZAxis * dHeight, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreateTorusDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRadius, dRadius1, dAngle;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Radius1"), dRadius1);
|
|
ON_RESBUF_REAL(pRb, _T("Angle"), dAngle);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
dAngle = AsRadian(dAngle);
|
|
|
|
AcGeVector3d vt(AcGeVector3d::kXAxis * dRadius);
|
|
AcGePoint3d ptCenter(ptPosition - vt);
|
|
vt.rotateBy(dAngle / 2.0, AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt1(ptCenter + vt);
|
|
vt.rotateBy(dAngle / 2.0, AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt2(ptCenter + vt);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::Elbow(ptPosition, pt1, pt2, dRadius1, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreatePipeDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRadius, dHeight;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
END_RESBUF_VALUE(pRb, 2);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::Pipe(ptPosition, dRadius, AcGeVector3d::kZAxis * dHeight, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreateDuctDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dLength, dWidth, dHeight;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Length"), dLength);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::Duct(ptPosition, AcGeVector3d::kXAxis * dLength, AcGeVector3d::kYAxis * dWidth, AcGeVector3d::kZAxis * dHeight, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreateEccPipeRedDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
double dRadius, dRadius1, dHeight, dOffsetX, dOffsetY;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Radius1"), dRadius1);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
ON_RESBUF_REAL(pRb, _T("OffsetX"), dOffsetX);
|
|
ON_RESBUF_REAL(pRb, _T("OffsetY"), dOffsetY);
|
|
END_RESBUF_VALUE(pRb, 5);
|
|
|
|
AcGeVector3d vtOffset(dOffsetX, dOffsetY, 0);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::PipeEccRed(ptPosition, dRadius, ptPosition + AcGeVector3d(dOffsetX, dOffsetY, dHeight),
|
|
dRadius1, vtOffset, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreatePipeRedDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRadius, dRadius1, dHeight;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Radius1"), dRadius1);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::PipeRed(ptPosition, dRadius, ptPosition + AcGeVector3d::kZAxis * dHeight, dRadius1, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreateTrConeDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRadius, dRadius1, dHeight;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Radius1"), dRadius1);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::ConeRed(ptPosition, dRadius, ptPosition + AcGeVector3d::kZAxis * dHeight, dRadius1, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreateDuctRedDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
double dLength, dWidth, dLength1, dWidth1, dHeight;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Length"), dLength);
|
|
ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
|
|
ON_RESBUF_REAL(pRb, _T("Length1"), dLength1);
|
|
ON_RESBUF_REAL(pRb, _T("Width1"), dWidth1);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
END_RESBUF_VALUE(pRb, 5);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::PyRam(ptPosition, AcGeVector3d::kXAxis * dLength, AcGeVector3d::kYAxis * dWidth,
|
|
ptPosition + AcGeVector3d::kZAxis * dHeight, dLength1, dWidth1, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreateHemiSphDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRadius, dHeight;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
END_RESBUF_VALUE(pRb, 2);
|
|
|
|
AcGeVector3d vtNormal(AcGeVector3d::kZAxis);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::HemiSph(ptPosition, dRadius, dHeight, vtNormal, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreateCapDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRadius, dHeight, dHeight1;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
ON_RESBUF_REAL(pRb, _T("Height1"), dHeight1);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::Cap(ptPosition, ptPosition + AcGeVector3d::kZAxis * dHeight, dRadius, dHeight1, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
void CreateTankDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
|
|
{
|
|
if (NULL == pRb)
|
|
return;
|
|
|
|
CString sLayer, sXData;
|
|
double dRadius, dHeight, dHeight1;
|
|
AcGePoint3d ptPosition, ptRotation;
|
|
BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
|
|
ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
|
|
ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
|
|
ON_RESBUF_REAL(pRb, _T("Height1"), dHeight1);
|
|
END_RESBUF_VALUE(pRb, 3);
|
|
|
|
AcDbVoidPtrArray arpFaces;
|
|
KT3DModel::Container(ptPosition, ptPosition + AcGeVector3d::kZAxis * dHeight, dRadius, dHeight1, arpFaces);
|
|
|
|
AcGeMatrix3d mat1, mat2, mat3;
|
|
mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
|
|
mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
|
|
mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
|
|
AcGeMatrix3d mat(mat3 * mat2 * mat1);
|
|
|
|
AcDbEntity* pEnt;
|
|
int iPos = arpFaces.length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pEnt = (AcDbEntity*)arpFaces[iPos];
|
|
pEnt->transformBy(mat);
|
|
|
|
AttachAttr(pEnt, sLayer);
|
|
AttachXData(pEnt, sXData);
|
|
|
|
pEnt->setDatabaseDefaults();
|
|
arpEnts.append(pEnt);
|
|
}
|
|
}
|
|
|
|
}; |