1589 lines
40 KiB
C++
1589 lines
40 KiB
C++
#include "stdafx.h"
|
||
#include "TDbColumn.h"
|
||
#include "slab_xdata_key.h"
|
||
|
||
|
||
/////////////////////////////////////////////////////////////
|
||
// 屋顶对象类
|
||
/////////////////////////////////////////////////////////////
|
||
|
||
// ver：1－TArch5； 2－TArch6
|
||
const Adesk::UInt8 TDbSlab::g_nVersion = 2;
|
||
|
||
|
||
ACRX_DXF_DEFINE_MEMBERS(ATSSlab, ATSEntity, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
||
1, ATS_SLAB, "ATS_SLAB图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
||
|
||
IMPLEMENT_TENTBASE(TDbSlab);
|
||
|
||
TDbSlab::TDbSlab()
|
||
:m_polyOutline(1), m_nInvisibleEdge(0), m_vtNormal(0,0,1)
|
||
{
|
||
m_nThickness=0;
|
||
|
||
}
|
||
|
||
|
||
TDbSlab::~TDbSlab()
|
||
{
|
||
}
|
||
|
||
BOOL TDbSlab::IsValid() const
|
||
{
|
||
BOOL bRet=TDbEntity::IsValid();
|
||
if(!bRet)
|
||
return bRet;
|
||
bRet=(m_polyOutline.Length()>1 && m_polyOutline.IsClosed());
|
||
return bRet;
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbSlab::subGetClassID(CLSID* pClsid) const
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
// 提供对格式刷的支持
|
||
void TDbSlab::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
||
{
|
||
assertWriteEnabled();
|
||
TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
||
TDbSlab *pSrc=TDbSlab::cast(pSrcEntity);
|
||
if(pSrc) {
|
||
m_nThickness=pSrc->m_nThickness; //<0, 则基准面在顶部
|
||
}
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbSlab::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet, BOOL *bErase)
|
||
{
|
||
if(g_nSaveTArchVer==5)
|
||
{
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
if(m_vtNormal.AsAcGeVector3d()!=AcGeVector3d(0,0,1))
|
||
{
|
||
assertWriteEnabled();
|
||
_SetNormal(m_vtNormal);
|
||
}
|
||
}
|
||
|
||
return TDbEntity::DownGradeSave(nDrawMode,entSet,bErase);
|
||
}
|
||
Acad::ErrorStatus
|
||
TDbSlab::GetPathPoly(XPoly2D&poly,AcGeVector3d&normal)const
|
||
{
|
||
assertReadEnabled();
|
||
poly=m_polyOutline;
|
||
normal=m_vtNormal.AsAcGeVector3d();
|
||
return Acad::eOk;
|
||
}
|
||
Acad::ErrorStatus
|
||
TDbSlab::SetPathPoly(const XPoly2D&poly,const AcGeVector3d&normal)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
m_polyOutline=poly;
|
||
if(m_polyOutline.PathArea()>0)
|
||
m_polyOutline.Reverse();
|
||
m_vtNormal=normal;
|
||
return Acad::eOk;
|
||
}
|
||
|
||
// 从DWG读入数据:
|
||
Acad::ErrorStatus TDbSlab::dwgInFields (AcDbDwgFiler* pFiler)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
Acad::ErrorStatus es = TDbEntity::dwgInFields(pFiler);
|
||
if(es != Acad::eOk) return es;
|
||
Adesk::UInt8 nVer;
|
||
pFiler->readItem(&nVer);
|
||
if(nVer>g_nVersion) {// Version is too new
|
||
return Acad::eMakeMeProxy;
|
||
}
|
||
|
||
pFiler->readItem(&m_nThickness);
|
||
pFiler->readItem(&m_nInvisibleEdge);
|
||
|
||
double nElev=0.0;
|
||
pFiler->readItem(&nElev);
|
||
m_polyOutline.Reset();
|
||
ReadPoly2D(pFiler, m_polyOutline);
|
||
m_polyOutline.SetElevation(nElev);
|
||
|
||
m_lstHoles.Reset();
|
||
Adesk::UInt16 nHole=0;
|
||
pFiler->readItem(&nHole);
|
||
for(Adesk::UInt16 i=0; i<nHole; i++) {
|
||
XPoly2D *pHole=new XPoly2D(1);
|
||
ReadPoly2D(pFiler, *pHole);
|
||
pHole->SetElevation(nElev);
|
||
m_lstHoles.Append(pHole);
|
||
}
|
||
if(nVer>1) {
|
||
pFiler->readItem((AcGeVector3d *)&m_vtNormal);
|
||
} else {
|
||
m_vtNormal = _GetNormal();
|
||
}
|
||
|
||
// pFiler->readItem(&m_idLayerHatch2d);
|
||
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
Acad::ErrorStatus TDbSlab::dwgOutFields(AcDbDwgFiler* pFiler) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es = TDbEntity::dwgOutFields(pFiler);
|
||
if(es != Acad::eOk) return es;
|
||
|
||
if(g_nSaveTArchVer==5)
|
||
pFiler->writeItem((Adesk::UInt8)1);
|
||
else
|
||
pFiler->writeItem(g_nVersion);
|
||
pFiler->writeItem(m_nThickness);
|
||
pFiler->writeItem(m_nInvisibleEdge);
|
||
|
||
double nElev=0.0;
|
||
if(!!m_polyOutline)
|
||
nElev=m_polyOutline[0].z;
|
||
pFiler->writeItem(nElev);
|
||
WritePoly2D(pFiler, m_polyOutline);
|
||
|
||
Adesk::UInt16 num=m_lstHoles.Length();
|
||
pFiler->writeItem(num);
|
||
for(Adesk::UInt16 i=0; i<num; i++) {
|
||
WritePoly2D(pFiler, m_lstHoles[i]);
|
||
}
|
||
if(g_nSaveTArchVer!=5)
|
||
pFiler->writeItem((const AcGeVector3d &)m_vtNormal);
|
||
|
||
//pFiler->writeItem(m_idLayerHatch2d);
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
Acad::ErrorStatus TDbSlab::dxfInFields (AcDbDxfFiler* pFiler)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
Acad::ErrorStatus es = TDbEntity::dxfInFields(pFiler);
|
||
if(es!=Acad::eOk)
|
||
return es;
|
||
|
||
if (!pFiler->atSubclassData(_T("TDbSlab"))) {
|
||
return Acad::eBadDxfSequence;
|
||
}
|
||
int fieldsFlags=0;
|
||
resbuf rb;
|
||
int n1;
|
||
double r1=0.0, r2=0.0;
|
||
DList<XPoint> pts;
|
||
DList<double> bulges;
|
||
while ((es == Acad::eOk)
|
||
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
||
switch (rb.restype) {
|
||
case 148:
|
||
r1=rb.resval.rreal;
|
||
fieldsFlags |= 0x01;
|
||
break;
|
||
case 149:
|
||
r2=rb.resval.rreal;
|
||
fieldsFlags |= 0x02;
|
||
break;
|
||
case AcDb::kDxfInt32:
|
||
n1=rb.resval.rlong;
|
||
fieldsFlags |= 0x04;
|
||
break;
|
||
case AcDb::kDxfXCoord:
|
||
pts.Append(new XPoint(rb.resval.rpoint));
|
||
break;
|
||
case AcDb::kDxfAngle:
|
||
bulges.Append(new double(rb.resval.rreal));
|
||
break;
|
||
case 210:
|
||
m_vtNormal=rb.resval.rpoint;
|
||
break;
|
||
//fall through intentional
|
||
default:
|
||
// An unrecognized group. Push it back so that
|
||
// the subclass can read it again.
|
||
pFiler->pushBackItem();
|
||
es = Acad::eEndOfFile;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// At this point the es variable must contain eEndOfFile
|
||
// - either from readResBuf() or from pushback. If not,
|
||
// it indicates that an error happened and we should
|
||
// return immediately.
|
||
//
|
||
if (es != Acad::eEndOfFile)
|
||
return Acad::eInvalidResBuf;
|
||
if(pts.Length()<2 || pts.Length()!=bulges.Length()) {
|
||
pFiler->setError(_T("\nError DXF group code: 10, 50"));
|
||
return Acad::eMissingDxfField;
|
||
}
|
||
|
||
|
||
m_nThickness=r2;
|
||
if(fieldsFlags&0x04)
|
||
m_nInvisibleEdge=n1;
|
||
|
||
m_polyOutline.Reset();
|
||
for(int i=0; i<pts.Length(); i++) {
|
||
m_polyOutline.AppendNode(*pts[i], *bulges[i]);
|
||
}
|
||
m_polyOutline.SetFlag(1);
|
||
if(fieldsFlags&0x01)
|
||
m_polyOutline.SetElevation(r1);
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
Acad::ErrorStatus TDbSlab::dxfOutFields(AcDbDxfFiler* pFiler) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es;
|
||
|
||
es = TDbEntity::dxfOutFields(pFiler);
|
||
assert(es == Acad::eOk);
|
||
|
||
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbSlab"));
|
||
assert(es == Acad::eOk);
|
||
|
||
pFiler->writeDouble(148, GetElevation());
|
||
pFiler->writeDouble(149, m_nThickness);
|
||
pFiler->writeInt32(AcDb::kDxfInt32, m_nInvisibleEdge);
|
||
for(int i=0; i<m_polyOutline.Length(); i++) {
|
||
pFiler->writePoint2d(AcDb::kDxfXCoord, m_polyOutline[i]);
|
||
pFiler->writeDouble(AcDb::kDxfAngle, m_polyOutline.GetBulge(i));
|
||
}
|
||
pFiler->writeVector3d(210, m_vtNormal);
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
|
||
// -----------------------------------------------------------------------
|
||
// Overriden functions for edit
|
||
// to do:
|
||
// 允许通过夹点改变边界
|
||
Acad::ErrorStatus TDbSlab::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
||
AcDbIntArray& osnapModes,
|
||
AcDbIntArray& geomIds) const
|
||
{
|
||
int nEdgeNum=GetEdgeNum();
|
||
XVector3D vtNormal=GetNormal();
|
||
for(int i=0; i<nEdgeNum; i++) {
|
||
XPoint pt=Ecs2Wcs(m_polyOutline[i], vtNormal);
|
||
gripPoints.append(pt);
|
||
}
|
||
|
||
//边上的夹点
|
||
for(i=0; i<nEdgeNum; i++) {
|
||
XCurveSegment edge;
|
||
m_polyOutline.Nth(i, edge);
|
||
XPoint ptMid=Ecs2Wcs(edge.MidPoint(), vtNormal);
|
||
gripPoints.append(ptMid);
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
// stretch points is diffrent from grep points, with no midpoint included
|
||
Acad::ErrorStatus TDbSlab::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
|
||
{
|
||
for(int i=0; i<m_polyOutline.Length(); i++) {
|
||
XPoint pt=m_polyOutline[i];
|
||
stretchPoints.append(pt);
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
|
||
|
||
// Active when being rotated, scaled, moved, etc.
|
||
Acad::ErrorStatus TDbSlab::subTransformBy(const AcGeMatrix3d& xform)
|
||
{
|
||
assertWriteEnabled();
|
||
TDbEntity::subTransformBy(xform);
|
||
XVector3D vtNormal=GetNormal();
|
||
//((AcGeVector3d &)vtNormal).transformBy(xform);
|
||
double nElev=0.0;
|
||
//ads_matrix mat;
|
||
AcGeMatrix2d xform2d(xform.convertToLocal(vtNormal,nElev));
|
||
ads_matrix mat={{xform2d(0,0), xform2d(0,1), 0, xform2d(0,2)},
|
||
{xform2d(1,0), xform2d(1,1), 0, xform2d(1,2)},
|
||
{0,0,1, nElev},
|
||
{0,0,0,1}};
|
||
//memcpy(mat, mat0, sizeof(ads_matrix));
|
||
AcGeMatrix3d mat3d=AsAcGeMatrix3d(mat);
|
||
m_polyOutline.TransformBy(mat3d);
|
||
//m_polyOutline.SetElevation(nElev);
|
||
BOOL bMirror=IsMirrorMatrix(mat);
|
||
if(bMirror && m_polyOutline.PathArea()>0) {
|
||
m_polyOutline.Reverse();
|
||
int nEdgeNum=GetEdgeNum();
|
||
DList<int> lstEdgeFlag;
|
||
for(int n=0; n<nEdgeNum; n++)
|
||
lstEdgeFlag.Append(new int(GetVisibilityAt(n)));
|
||
lstEdgeFlag.Reverse();
|
||
for(n=0; n<nEdgeNum; n++)
|
||
SetVisibilityAt(n, *lstEdgeFlag[n]);
|
||
}
|
||
for(int j=0; j<m_lstHoles.Length(); j++) {
|
||
XPoly2D &rHole=*m_lstHoles[j];
|
||
rHole.TransformBy(mat3d);
|
||
//rHole.SetElevation(nElev);
|
||
if(bMirror && rHole.PathArea()>0)
|
||
rHole.Reverse();
|
||
}
|
||
SetNormal(vtNormal);
|
||
|
||
/*
|
||
ads_matrix mat;
|
||
memcpy(mat, &xform, sizeof(ads_matrix));
|
||
BOOL bMirror=IsMirrorMatrix(mat);
|
||
double nElev=0.0;
|
||
for(int i=0; i<m_polyOutline.Length(); i++) {
|
||
XPoint *pt=m_polyOutline[i];
|
||
pt->TransformBy(mat);
|
||
//以第一个顶点的z坐标为基准
|
||
if(i==0) {
|
||
nElev = pt->z;
|
||
} else {
|
||
pt->z = nElev;
|
||
}
|
||
}
|
||
if(bMirror && m_polyOutline.PathArea()>0) {
|
||
m_polyOutline.Reverse();
|
||
int nEdgeNum=GetEdgeNum();
|
||
DList<int> lstEdgeFlag;
|
||
for(int n=0; n<nEdgeNum; n++)
|
||
lstEdgeFlag.Append(new int(GetVisibilityAt(n)));
|
||
lstEdgeFlag.Reverse();
|
||
for(n=0; n<nEdgeNum; n++)
|
||
SetVisibilityAt(n, *lstEdgeFlag[n]);
|
||
}
|
||
|
||
|
||
for(int j=0; j<m_lstHoles.Length(); j++) {
|
||
XPoly2D &rHole=*m_lstHoles[j];
|
||
for(int i=0; i<rHole.Length(); i++) {
|
||
XPoint *pt=rHole[i];
|
||
pt->TransformBy(mat);
|
||
//以第一个顶点的z坐标为基准
|
||
pt->z = nElev;
|
||
}
|
||
if(bMirror && rHole.PathArea()>0)
|
||
rHole.Reverse();
|
||
}
|
||
*/
|
||
|
||
return Acad::eOk;
|
||
}
|
||
void TDbSlab::UnionScale(double nScale)
|
||
{
|
||
assertWriteEnabled();
|
||
double nOldElev=GetElevation();
|
||
TDbEntity::UnionScale(nScale);
|
||
SetElevation(nOldElev*nScale);
|
||
m_nThickness*=nScale;
|
||
}
|
||
// 功能: 夹点操作
|
||
Acad::ErrorStatus TDbSlab::subMoveGripPointsAt(
|
||
const AcDbIntArray& indices,
|
||
const AcGeVector3d& offset)
|
||
{
|
||
assertWriteEnabled();
|
||
XPoly2D polyBack(m_polyOutline);
|
||
|
||
//XPoint vtOffset=*(XPoint *)&offset;
|
||
XVector3D vtNormal=GetNormal();
|
||
XPoint vtOffset=Wcs2Ecs(*(XPoint *)&offset, vtNormal);
|
||
//vtOffset.z=0;
|
||
int nTotalEdge=GetEdgeNum();
|
||
for (int i = 0; i < indices.length(); i++) {
|
||
int idx = indices[i];
|
||
ASSERT(idx<2*nTotalEdge);
|
||
if(idx<nTotalEdge) {
|
||
*m_polyOutline[idx] += vtOffset;
|
||
} else {
|
||
int nEdgeIndex=idx-nTotalEdge;
|
||
ASSERT(nEdgeIndex<nTotalEdge);
|
||
|
||
XDirectionCurve cv;
|
||
m_polyOutline.Nth(nEdgeIndex, cv);
|
||
ASSERT(!!cv);
|
||
if(cv.Is(CURVE_LINE)) { // Move
|
||
XLine ln=cv.GetLine();
|
||
ln.StartPoint() += vtOffset;
|
||
ln.EndPoint() += vtOffset;
|
||
ln.SetLineFlag(LS_INFINITE);
|
||
XDirectionCurve prevSeg, nextSeg;
|
||
int nPrev=nEdgeIndex-1, nNext=nEdgeIndex+1;
|
||
nPrev=DePeriod(nTotalEdge, nPrev);
|
||
nNext=DePeriod(nTotalEdge, nNext);
|
||
|
||
XPoint ptStart, ptEnd;
|
||
BOOL bUpdateIt=TRUE;
|
||
//更新起点
|
||
if(nPrev>=0 && nPrev<nTotalEdge) {
|
||
m_polyOutline.Nth(nPrev, prevSeg);
|
||
prevSeg.SetLineFlag(LS_INFINITE);
|
||
XPoint ptInt[2];
|
||
int nIntNum=prevSeg.Intersection(ln, ptInt[0], ptInt[1]);
|
||
if(nIntNum==1) ptStart=ptInt[0];
|
||
else if(nIntNum==2) {
|
||
ptStart=XLine(ptInt[0], ptInt[1]).NearPoint(ln.StartPoint());
|
||
} else bUpdateIt=FALSE;
|
||
} else {
|
||
ptStart = *m_polyOutline[nEdgeIndex] + vtOffset;
|
||
}
|
||
|
||
// 更新下一点
|
||
if(nNext>=0 && nNext<nTotalEdge) {
|
||
m_polyOutline.Nth(nNext, nextSeg);
|
||
nextSeg.SetLineFlag(LS_INFINITE);
|
||
XPoint ptInt[2];
|
||
int nIntNum=nextSeg.Intersection(ln, ptInt[0], ptInt[1]);
|
||
if(nIntNum==1) ptEnd=ptInt[0];
|
||
else if(nIntNum==2) {
|
||
ptEnd=XLine(ptInt[0], ptInt[1]).NearPoint(ln.EndPoint());
|
||
} else bUpdateIt=FALSE;
|
||
} else {
|
||
ptEnd = *m_polyOutline[nEdgeIndex+1] + vtOffset;
|
||
}
|
||
|
||
if(bUpdateIt) {
|
||
double nPrevBulge=0.0, nNextBulge=0.0;
|
||
if(fabs(prevSeg.GetBulge())>1.0E-5) {
|
||
XArc prevArc=prevSeg.GetArc();
|
||
double nAngBeg=ads_angle(prevArc.GetCenterPt(), prevSeg.StartPoint());
|
||
double nAngEnd=ads_angle(prevArc.GetCenterPt(), ptStart);
|
||
if(prevSeg.IsMinusArc()) {
|
||
nPrevBulge=-CT_std_angle(nAngBeg-nAngEnd);
|
||
} else {
|
||
nPrevBulge=CT_std_angle(nAngEnd-nAngBeg);
|
||
}
|
||
}
|
||
if(fabs(nextSeg.GetBulge())>1.0E-5) {
|
||
XArc nextArc=nextSeg.GetArc();
|
||
double nAngBeg=ads_angle(nextArc.GetCenterPt(), ptEnd);
|
||
double nAngEnd=ads_angle(nextArc.GetCenterPt(), nextSeg.EndPoint());
|
||
if(nextSeg.IsMinusArc()) {
|
||
nNextBulge=-CT_std_angle(nAngBeg-nAngEnd);
|
||
} else {
|
||
nNextBulge=CT_std_angle(nAngEnd-nAngBeg);
|
||
}
|
||
}
|
||
|
||
*m_polyOutline[nEdgeIndex] = ptStart;
|
||
if(nNext>=0 && nNext<m_polyOutline.Length()) {
|
||
*m_polyOutline[nNext] = ptEnd;
|
||
m_polyOutline.SetBulge(nNext, nNextBulge);
|
||
}
|
||
if(nPrev>=0 && nPrev<m_polyOutline.Length())
|
||
m_polyOutline.SetBulge(nPrev, nPrevBulge);
|
||
|
||
}
|
||
|
||
} else { // Change Arc Segment--bulge
|
||
XPoint ptMid=cv.MidPoint();
|
||
XPoint ptMidNew= ptMid + vtOffset;
|
||
XArc arNew(cv.StartPoint(), ptMidNew, cv.EndPoint());
|
||
if(!!arNew) { //新的弧有效
|
||
XCurveSegment cvLine(cv.StartPoint(), cv.EndPoint(), 0.0);
|
||
int nSideOld=cvLine.OnWhichSide(ptMid);
|
||
int nSideNew=cvLine.OnWhichSide(ptMidNew);
|
||
double nSignal=cv.GetBulge()/fabs(cv.GetBulge());
|
||
if(nSideOld==nSideNew) {
|
||
m_polyOutline.SetBulge(nEdgeIndex, nSignal*arNew.Bulge());
|
||
} else {
|
||
m_polyOutline.SetBulge(nEdgeIndex, -nSignal*arNew.Bulge());
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
Acad::ErrorStatus es = Acad::eOk;
|
||
if(m_polyOutline.IsSelfIntersect()) {
|
||
m_polyOutline=polyBack;
|
||
es = Acad::eInvalidInput;
|
||
}
|
||
return es;
|
||
}
|
||
|
||
// 取得夹点说明
|
||
Acad::ErrorStatus TDbSlab::GetGripText(int i, CString &cs) const
|
||
{
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
XString sInfo;
|
||
if(i<GetEdgeNum()) {
|
||
sInfo << _T("移动第") << (i+1) << _T("个顶点");
|
||
} else {
|
||
sInfo << _T("移动第") << (i-GetEdgeNum()+1) << _T("条边");
|
||
}
|
||
cs = sInfo;
|
||
return es;
|
||
}
|
||
#if ADS>15
|
||
void TDbSlab::CreateGrip()
|
||
{
|
||
TDbEntity::CreateGrip();
|
||
::CreateGrip(this,m_polyOutline,0);
|
||
}
|
||
Acad::ErrorStatus TDbSlab::EntityToDim(long iGrip,long iDim,const AcDbEntity*pEnt)
|
||
{
|
||
TEntityBase *pCurve=TDbSlab::cast(pEnt);
|
||
if(pCurve==NULL)
|
||
pCurve=this;
|
||
XPoly2D polyPath;
|
||
AcGeVector3d normal;
|
||
pCurve->GetPathPoly(polyPath,normal);
|
||
return ::EntityToDim(this,polyPath,iGrip,iDim,0);
|
||
}
|
||
|
||
Acad::ErrorStatus TDbSlab::DimToEntity(long iGrip,long iDim,double newValue,const AcGeVector3d& offset)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
TDbSlab curve;
|
||
curve.CopyPropertiesFrom(this,0);
|
||
|
||
Acad::ErrorStatus es=::DimToEntity(this,m_polyOutline,iGrip,iDim,newValue,offset,0);
|
||
if(es==Acad::eOk&&!IsValid())
|
||
{
|
||
CopyPropertiesFrom(&curve,0);
|
||
return Acad::eInvalidInput;
|
||
}
|
||
|
||
return es;
|
||
}
|
||
#endif
|
||
// 功能: 夹点操作
|
||
// 状态: 有待完成修改相关墙体门窗的操作
|
||
Acad::ErrorStatus TDbSlab::subMoveStretchPointsAt(
|
||
const AcDbIntArray& indices,
|
||
const AcGeVector3d& offset)
|
||
{
|
||
int nCount=indices.length();
|
||
return subMoveGripPointsAt(indices, offset);
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbSlab::GetExtents2d(XPoint &ptLow, XPoint &ptUp) const
|
||
{
|
||
AcGeVector3d vtStd(0,0,1);
|
||
AcGeVector3d vtNorm;
|
||
vtNorm=(AcGeVector3d &)GetNormal();
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
if(vtNorm==vtStd) {
|
||
XPoly2D poly(m_polyOutline);
|
||
poly.SetElevation(0.0);
|
||
poly.GetExtend(ptLow, ptUp);
|
||
ptLow.z=ptUp.z=0.0;
|
||
} else {
|
||
es=TDbEntity::GetExtents2d(ptLow, ptUp);
|
||
}
|
||
return es;
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbSlab::GetExtents(XPoint &ptLow, XPoint &ptUp) const
|
||
{
|
||
AcGeVector3d vtStd(0,0,1);
|
||
AcGeVector3d vtNorm;
|
||
vtNorm=(AcGeVector3d &)GetNormal();
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
if(vtNorm==vtStd) {
|
||
XPoly2D poly(m_polyOutline);
|
||
poly.SetElevation(0.0);
|
||
poly.GetExtend(ptLow, ptUp);
|
||
double nThick=GetThickness();
|
||
double nElev=GetElevation();
|
||
double nElev1=nElev+nThick;
|
||
ptLow.z=min(nElev, nElev1);
|
||
ptUp.z=max(nElev, nElev1);
|
||
} else {
|
||
es=TDbEntity::GetExtents(ptLow, ptUp);
|
||
}
|
||
return es;
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbSlab::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
||
{
|
||
assertReadEnabled();
|
||
//TPushProperty vProp(this, dc);
|
||
|
||
XVector3D vtNormal=GetNormal();
|
||
if(((AcGeVector3d &)vtNormal)!=AcGeVector3d(0,0,1)) {
|
||
XPoly2D polyOutline(1);
|
||
m_polyOutline.Disperse1(polyOutline, _AS_SYS_UNIT(g_nCirDeviation));
|
||
for(int i=0; i<polyOutline.Length(); i++) {
|
||
*polyOutline[i]=Ecs2Wcs(*polyOutline[i], vtNormal);
|
||
}
|
||
DList<XPoly2D> lstHoles;
|
||
for(i=0; i<m_lstHoles.Length(); i++) {
|
||
XPoly2D *pHole=new XPoly2D(1);
|
||
XPoly2D &hole=*pHole;
|
||
m_lstHoles[i].Disperse1(hole, _AS_SYS_UNIT(g_nCirDeviation));
|
||
for(int j=0; j<hole.Length(); j++) {
|
||
*hole[j]=Ecs2Wcs(*hole[j], vtNormal);
|
||
}
|
||
lstHoles.Append(pHole);
|
||
}
|
||
|
||
XVector3D vt(0,0,m_nThickness);
|
||
vt=Ecs2Wcs(vt, vtNormal, TRUE);
|
||
|
||
if(fabs(m_nThickness)>_DIST_SNAP)
|
||
dc.DrawBody(polyOutline, lstHoles, vt);
|
||
else
|
||
dc.DrawShell(polyOutline, lstHoles);
|
||
/*
|
||
dc.DrawShell(polyOutline, lstHoles);
|
||
if(fabs(m_nThickness)>_DIST_SNAP) {
|
||
XPoly2D polyUp(polyOutline);
|
||
for(i=0; i<polyUp.Length(); i++) {
|
||
*polyUp[i] += vt;
|
||
}
|
||
DList<XPoly2D> lstHoleUp;
|
||
for(int n=0; n<lstHoles.Length(); n++) {
|
||
XPoly2D *pHole=new XPoly2D(*lstHoles[n]);
|
||
for(int j=0; j<pHole->Length(); j++) {
|
||
*(*pHole)[j] += vt;
|
||
}
|
||
lstHoleUp.Append(pHole);
|
||
}
|
||
dc.DrawShell(polyUp, lstHoleUp);
|
||
|
||
|
||
dc.DrawMesh(polyOutline, vt);
|
||
for(i=0; i<lstHoles.Length(); i++)
|
||
dc.DrawMesh(*lstHoles[i], vt);
|
||
}*/
|
||
} else {
|
||
XVector3D vt(0,0,m_nThickness);
|
||
|
||
if(fabs(m_nThickness)>_DIST_SNAP)
|
||
dc.DrawBody(m_polyOutline, m_lstHoles, vt);
|
||
else
|
||
dc.DrawShell(m_polyOutline, m_lstHoles);
|
||
/*
|
||
dc.DrawShell(m_polyOutline, m_lstHoles);
|
||
if(fabs(m_nThickness)>_DIST_SNAP) {
|
||
XPoly2D polyUp(m_polyOutline);
|
||
double nElev = GetElevation()+m_nThickness;
|
||
polyUp.SetElevation(nElev);
|
||
DList<XPoly2D> lstHoleUp;
|
||
for(int n=0; n<m_lstHoles.Length(); n++) {
|
||
XPoly2D *pHole=new XPoly2D(m_lstHoles[n]);
|
||
pHole->SetElevation(nElev);
|
||
lstHoleUp.Append(pHole);
|
||
}
|
||
dc.DrawShell(polyUp, lstHoleUp);
|
||
|
||
dc.DrawMesh(m_polyOutline, vt);
|
||
for(int i=0; i<m_lstHoles.Length(); i++)
|
||
dc.DrawMesh(m_lstHoles[i], vt);
|
||
}*/
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
|
||
bool TDbSlab::IsClipMe(const TEntityBase* pEnt)const
|
||
{
|
||
if(TDbEntity::IsClipMe(pEnt))
|
||
return true;
|
||
|
||
if(pEnt->GetMe()->isKindOf(TDbColumn::desc()))
|
||
return true;
|
||
|
||
return false;
|
||
}
|
||
Acad::ErrorStatus
|
||
TDbSlab::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
||
{
|
||
//TPushProperty vProp(this, dc);
|
||
|
||
XVector3D vt=GetNormal();
|
||
if(((AcGeVector3d &)vt)!=AcGeVector3d(0,0,1))
|
||
return ExplodeOrDraw3d(dc);//解决平板出现无二维的情况，按三维绘制，add by whl on 041108
|
||
|
||
int nVisEdge=0;
|
||
if (_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor()) == 0 && !ownerId())
|
||
{
|
||
XPoly2D poly1(m_polyOutline);
|
||
poly1.SetElevation(0.0);
|
||
for(int i=0; i<poly1.TotalSegments(); i++)
|
||
{
|
||
if(GetVisibilityAt(i))
|
||
{
|
||
XCurveSegment seg;
|
||
poly1.Nth(i, seg);
|
||
dc << seg;
|
||
nVisEdge++;
|
||
}
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
nVisEdge=0;
|
||
XCurveStream dcSrc;
|
||
XPoly2D poly(m_polyOutline);
|
||
poly.SetElevation(0.0);
|
||
for(int i=0; i<poly.TotalSegments(); i++) {
|
||
if(GetVisibilityAt(i)) {
|
||
XCurveSegment seg;
|
||
poly.Nth(i, seg);
|
||
dcSrc << seg;
|
||
nVisEdge++;
|
||
}
|
||
}
|
||
if(!nVisEdge)
|
||
return Acad::eOk;
|
||
|
||
for(i=0; i<m_lstHoles.Length(); i++)
|
||
((XDcStream &)dcSrc) << m_lstHoles[i];
|
||
|
||
// 扶手裁剪
|
||
if(!m_tempRailArray.isEmpty()) {
|
||
int num=m_tempRailArray.length();
|
||
for(int n=0; n<num; n++) {
|
||
TDbHandRail *pRail=(TDbHandRail *)m_tempRailArray[n];
|
||
pRail->ClipCurveByTrace(dcSrc.m_lstCurves);
|
||
}
|
||
} else {
|
||
XPoly2D polyOutline(m_polyOutline);
|
||
polyOutline.SetElevation(0.0);
|
||
AcDbObjectId idOwner=ownerId();
|
||
AcDbObjectIdArray railArray;
|
||
if(!!polyOutline && !!idOwner && TDbHandRail::GetRailsByCP(polyOutline, idOwner, railArray)) {
|
||
int nCount=railArray.length();
|
||
for(int cnt=0; cnt<nCount; cnt++) {
|
||
AcDbObjectId idRail=railArray[cnt];
|
||
OPENOBJ_BEGIN(idRail, AcDb::kForRead, TDbHandRail, pRail);
|
||
if(pRail)
|
||
pRail->ClipCurveByTrace(dcSrc.m_lstCurves);
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
}
|
||
dcSrc.CopyTo(dc);
|
||
|
||
if (!g_bOsnapExpl)
|
||
{ //板新增填充功能
|
||
int nisFill = 0;
|
||
m_XDataMap.GetAt(bKEY_SLAB_FILL, nisFill);
|
||
if (nisFill > 0)
|
||
{
|
||
double dscale(100.0);
|
||
int ncolor(256);
|
||
CString sPatname = _T("ANSI31");
|
||
m_XDataMap.GetAt(sKEY_PAT_PATPICNAME, sPatname);
|
||
m_XDataMap.GetAt(dKEY_PAT_DENSITY, dscale);
|
||
m_XDataMap.GetAt(dwKEY_PAT_COLOR, ncolor);
|
||
|
||
AcGeDoubleArray bulges;
|
||
AcGePoint2dArray vertices;
|
||
int nVert = poly.Length();
|
||
AcDbHatch pHatch;
|
||
pHatch.setAssociative(Adesk::kFalse);
|
||
pHatch.setPatternScale(dscale);
|
||
pHatch.setHatchStyle(AcDbHatch::kNormal);
|
||
pHatch.setPattern(AcDbHatch::kPreDefined, sPatname);
|
||
|
||
bulges.setPhysicalLength(0).setLogicalLength(nVert+1);
|
||
vertices.setPhysicalLength(0).setLogicalLength(nVert+1);
|
||
|
||
for (i = 0; i < nVert; i++)
|
||
{
|
||
vertices[i] = *poly[i];
|
||
bulges[i] = tan(poly.GetBulge(i)/4);
|
||
}
|
||
vertices[i] = vertices[0];
|
||
bulges[i] = bulges[0];
|
||
Acad::ErrorStatus es = pHatch.appendLoop(AcDbHatch::kSelfIntersecting, vertices, bulges);
|
||
|
||
for(i = 0; i < m_lstHoles.Length(); i++)
|
||
{
|
||
poly = m_lstHoles[i];
|
||
nVert = poly.Length();
|
||
bulges.setPhysicalLength(0).setLogicalLength(nVert+1);
|
||
vertices.setPhysicalLength(0).setLogicalLength(nVert+1);
|
||
|
||
for (int j = 0; j < nVert; j++)
|
||
{
|
||
vertices[j] = *poly[j];
|
||
bulges[j] = tan(poly.GetBulge(j)/4);
|
||
}
|
||
vertices[j] = vertices[0];
|
||
bulges[j] = bulges[0];
|
||
|
||
es = pHatch.insertLoopAt(i+1,AcDbHatch::kSelfIntersecting , vertices, bulges);
|
||
}
|
||
|
||
|
||
pHatch.evaluateHatch();
|
||
AcDbObjectId idlay;
|
||
m_XDataMap.GetAt(idKEY_PAT_LAYER, idlay);
|
||
if (idlay.isValid())
|
||
{
|
||
pHatch.setLayer(idlay);
|
||
pHatch.setColorIndex(ncolor);
|
||
}
|
||
dc.DrawEntity(pHatch);
|
||
}
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
|
||
const TCHAR *TDbSlab::GetDefaultLayer() const
|
||
{
|
||
return LAY_SLAB;
|
||
}
|
||
|
||
|
||
|
||
/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
|
||
void TDbSlab::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
||
{
|
||
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("平板")));
|
||
lstInfo.Append(new TObjInfoUnit(_T("平板厚度"), Dist2Str(GetThickness())));
|
||
lstInfo.Append(new TObjInfoUnit(_T("底标高"), Dist2Str(GetElevation())));
|
||
|
||
if(!m_lstHoles) {
|
||
lstInfo.Append(new TObjInfoUnit(_T("周长"), Dist2Str(GetPerimeter0())));
|
||
lstInfo.Append(new TObjInfoUnit(_T("底面积"),
|
||
XString(_T("%.2f"), _AS_SQMETER(GetBottomArea0()))));
|
||
lstInfo.Append(new TObjInfoUnit(_T("侧面积"),
|
||
XString(_T("%.2f"), _AS_SQMETER(GetSideArea0()))));
|
||
lstInfo.Append(new TObjInfoUnit(_T("体积"),
|
||
XString(_T("%.3f"), _AS_CUMETER(GetVolume0()))));
|
||
} else {
|
||
lstInfo.Append(new TObjInfoUnit(_T("周长(不含洞)"), Dist2Str(GetPerimeter0())));
|
||
lstInfo.Append(new TObjInfoUnit(_T("周长(含洞)"), Dist2Str(GetPerimeter())));
|
||
|
||
lstInfo.Append(new TObjInfoUnit(_T("底面积(不扣洞)"),
|
||
XString(_T("%.2f"), _AS_SQMETER(GetBottomArea0()))));
|
||
lstInfo.Append(new TObjInfoUnit(_T("底面积(扣洞)"),
|
||
XString(_T("%.2f"), _AS_SQMETER(GetBottomArea()))));
|
||
|
||
lstInfo.Append(new TObjInfoUnit(_T("侧面积(不含洞)"),
|
||
XString(_T("%.2f"), _AS_SQMETER(GetSideArea0()))));
|
||
lstInfo.Append(new TObjInfoUnit(_T("侧面积(含洞)"),
|
||
XString(_T("%.2f"), _AS_SQMETER(GetSideArea()))));
|
||
|
||
lstInfo.Append(new TObjInfoUnit(_T("体积(不扣洞)"),
|
||
XString(_T("%.3f"), _AS_CUMETER(GetVolume0()))));
|
||
lstInfo.Append(new TObjInfoUnit(_T("体积(扣洞)"),
|
||
XString(_T("%.3f"), _AS_CUMETER(GetVolume()))));
|
||
|
||
}
|
||
|
||
}
|
||
|
||
void
|
||
TDbSlab::AddTempRail(TDbHandRail *pRail)
|
||
{
|
||
m_tempRailArray.append(pRail);
|
||
}
|
||
|
||
int
|
||
TDbSlab::GetEdgeNum() const
|
||
{
|
||
return m_polyOutline.TotalSegments();
|
||
}
|
||
|
||
BOOL
|
||
TDbSlab::GetVisibilityAt(int idx) const
|
||
{
|
||
ASSERT(idx<GetEdgeNum());
|
||
int nTestBit=0x01;
|
||
nTestBit <<= idx;
|
||
return ((m_nInvisibleEdge&nTestBit)==0);
|
||
}
|
||
|
||
|
||
|
||
double
|
||
TDbSlab::GetThickness() const
|
||
{
|
||
return m_nThickness;
|
||
}
|
||
|
||
|
||
|
||
const XPoly2D &
|
||
TDbSlab::GetOutline() const
|
||
{
|
||
return m_polyOutline;
|
||
}
|
||
|
||
|
||
|
||
void
|
||
TDbSlab::SetThickness(double h)
|
||
{
|
||
assertWriteEnabled();
|
||
m_nThickness=h;
|
||
}
|
||
|
||
// 没有判断是否在边界范围内
|
||
BOOL
|
||
TDbSlab::AddHole(const XPoly2D &polyHole)
|
||
{
|
||
assertWriteEnabled();
|
||
XPoly2D *pHole=new XPoly2D(polyHole);
|
||
pHole->SetElevation(GetElevation());
|
||
m_lstHoles.Append(pHole);
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL
|
||
TDbSlab::RemoveHole(int idx)
|
||
{
|
||
assertWriteEnabled();
|
||
if(idx<m_lstHoles.Length()) {
|
||
m_lstHoles.Remove(idx);
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void
|
||
TDbSlab::SetOutline(const XPoly2D &poly)
|
||
{
|
||
assertWriteEnabled();
|
||
ASSERT(poly.PathArea()<0.0 && poly.GetFlag()==1);
|
||
m_polyOutline = poly;
|
||
}
|
||
|
||
void
|
||
TDbSlab::SetVisibilityAt(int idx, BOOL bTrue)
|
||
{
|
||
assertWriteEnabled();
|
||
ASSERT(idx<GetEdgeNum());
|
||
int nTestBit=0x01;
|
||
nTestBit <<= idx;
|
||
if(!bTrue)
|
||
m_nInvisibleEdge |= nTestBit;
|
||
else
|
||
m_nInvisibleEdge &= ~nTestBit;
|
||
}
|
||
|
||
void TDbSlab::SetVisibilityAll(BOOL bTrue)
|
||
{
|
||
assertWriteEnabled();
|
||
if(bTrue)
|
||
m_nInvisibleEdge=0;
|
||
else {
|
||
int nEdgeNum=GetEdgeNum();
|
||
for(int idx=0; idx<nEdgeNum; idx++) {
|
||
int nTestBit=0x01;
|
||
nTestBit <<= idx;
|
||
m_nInvisibleEdge |= nTestBit;
|
||
}
|
||
}
|
||
}
|
||
|
||
double
|
||
TDbSlab::GetElevation() const
|
||
{
|
||
double nElev=0;
|
||
if(!!m_polyOutline)
|
||
nElev=m_polyOutline[0].z;
|
||
return nElev;
|
||
}
|
||
|
||
void
|
||
TDbSlab::SetElevation(double nElev)
|
||
{
|
||
assertWriteEnabled();
|
||
m_polyOutline.SetElevation(nElev);
|
||
for(int i=0; i<m_lstHoles.Length(); i++)
|
||
m_lstHoles[i]->SetElevation(nElev);
|
||
}
|
||
|
||
XVector3D TDbSlab::GetNormal() const
|
||
{
|
||
return m_vtNormal;
|
||
}
|
||
|
||
// Upgrade from TArch5 to TArch6 only
|
||
XVector3D TDbSlab::_GetNormal() const
|
||
{
|
||
int nFlag=0;
|
||
resbuf *xd=xData(TCHXD);
|
||
BOOL bRet=FALSE;
|
||
XVector3D vt(0,0,1);
|
||
if(xd) {
|
||
resbuf *rb=xd->rbnext;
|
||
if(rb->restype==1010) {
|
||
vt = rb->resval.rpoint;
|
||
vt /= vt.Length(); // normalize
|
||
}
|
||
ads_relrb(xd);
|
||
}
|
||
return vt;
|
||
}
|
||
|
||
|
||
void TDbSlab::_SetNormal(XVector3D vt)
|
||
{
|
||
assertWriteEnabled();
|
||
if(!XSymbolTable(_T("APPID"), TCHXD) && database()==acdbCurDwg())
|
||
ads_regapp(TCHXD);
|
||
vt /= vt.Length();
|
||
int nFlag=0;
|
||
resbuf *xd=ads_buildlist(1001, TCHXD, 1010, &vt, NULL);
|
||
setXData(xd);
|
||
ads_relrb(xd);
|
||
}
|
||
|
||
void TDbSlab::SetNormal(XVector3D vt)
|
||
{
|
||
assertWriteEnabled();
|
||
vt.Normalize();
|
||
m_vtNormal=vt;
|
||
}
|
||
|
||
|
||
// 扣除洞口
|
||
double TDbSlab::GetPerimeter() const
|
||
{
|
||
double nHoleVal=0.0;
|
||
for(int i=0; i<m_lstHoles.Length(); i++)
|
||
nHoleVal += m_lstHoles[i].Distance2d();
|
||
return (GetPerimeter0()+nHoleVal);
|
||
}
|
||
|
||
double TDbSlab::GetBottomArea() const
|
||
{
|
||
double nHoleVal=0.0;
|
||
for(int i=0; i<m_lstHoles.Length(); i++)
|
||
nHoleVal += m_lstHoles[i].Area();
|
||
return (GetBottomArea0()-nHoleVal);
|
||
}
|
||
|
||
double TDbSlab::GetSideArea() const
|
||
{
|
||
double nHoleVal=0.0;
|
||
for(int i=0; i<m_lstHoles.Length(); i++)
|
||
nHoleVal += m_lstHoles[i].Distance2d()*m_nThickness;
|
||
return (GetSideArea0()+nHoleVal);
|
||
}
|
||
|
||
double TDbSlab::GetVolume() const
|
||
{
|
||
double nHoleVal=0.0;
|
||
for(int i=0; i<m_lstHoles.Length(); i++)
|
||
nHoleVal += m_lstHoles[i].Area()*m_nThickness;
|
||
return (GetVolume0()-nHoleVal);
|
||
}
|
||
|
||
const DList<XPoly2D> &
|
||
TDbSlab::GetHoles() const
|
||
{
|
||
return m_lstHoles;
|
||
}
|
||
|
||
// 高16--洞序号, 低16--边号
|
||
BOOL TDbSlab::HitTestOnHole(const XPoint &ptTest,Adesk::UInt32 *bHitFlag) const
|
||
{
|
||
XPoint pt=ptTest;
|
||
pt.z = GetElevation();
|
||
for(int i=0; i<m_lstHoles.Length(); i++) {
|
||
const XPoly2D &rHole=m_lstHoles[i];
|
||
for(int j=0; j<rHole.TotalSegments(); j++) {
|
||
XCurveSegment seg;
|
||
rHole.Nth(j, seg);
|
||
seg.SetElevation(pt.z);
|
||
int nFlag=(pt&seg);
|
||
if(nFlag==PR_ONPT1 || nFlag==PR_ONPT2 || nFlag==PR_INSIDE) {
|
||
Adesk::UInt32 nRet=i;
|
||
nRet <<= 16;
|
||
nRet += j;
|
||
if(bHitFlag) *bHitFlag=nRet;
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
int
|
||
TDbSlab::HitTestOnOutline(const XPoint &ptTest) const
|
||
{
|
||
XPoint pt=ptTest;
|
||
pt.z = GetElevation();
|
||
const XPoly2D &rHole=m_polyOutline;
|
||
for(int j=0; j<rHole.TotalSegments(); j++) {
|
||
XCurveSegment seg;
|
||
rHole.Nth(j, seg);
|
||
seg.SetElevation(pt.z);
|
||
int nFlag=(pt&seg);
|
||
if(nFlag==PR_ONPT1 || nFlag==PR_ONPT2 || nFlag==PR_INSIDE) {
|
||
return j;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
// 0--没有命中; 1--任意穿越; 2--任意包含; 3--重边穿越; 4--重边包含
|
||
// segHit--重边穿越或包含时的纠正位置
|
||
int
|
||
TDbSlab::HitTest(const XCurveSegment &seg, double nTol, XCurveSegment &segHit) const
|
||
{
|
||
XPoly2D polyMe(m_polyOutline);
|
||
polyMe.SetElevation(0.0);
|
||
PointList ptInts(seg.StartPoint(), seg.EndPoint(), seg.GetBulge());
|
||
|
||
XCurveSegment seg0=seg;
|
||
seg0.SetElevation(0.0);
|
||
seg0.SetLineFlag(LS_FINITE);
|
||
|
||
int nIntNum=Intersect(seg0, polyMe, ptInts);
|
||
XPoint ptMid=seg0.MidPoint();
|
||
if(!nIntNum && (ptMid&polyMe)==PR_OUTSIDE)
|
||
return 0;
|
||
|
||
for(int n=0; n<GetEdgeNum(); n++) {
|
||
if(!GetVisibilityAt(n))
|
||
continue;
|
||
XCurveSegment seg1;
|
||
polyMe.Nth(n, seg1);
|
||
if(!seg1)
|
||
continue;
|
||
if(seg0.Is(CURVE_LINE)!=seg1.Is(CURVE_LINE))
|
||
continue;
|
||
if(seg0.Is(CURVE_LINE)) {
|
||
if(CT_IsSameDrt(seg0.IDirection(0), seg1.IDirection(0), _angSnap)) {
|
||
if(seg0.StartPoint().Distance(&seg1)<nTol) { //重合
|
||
XLine lnRail=seg1.GetLine().Offset(-nTol/2.0);
|
||
lnRail.SetLineFlag(LS_INFINITE);
|
||
XPoint(seg0.StartPoint()).Project(&lnRail, seg0.StartPoint());
|
||
XPoint(seg0.EndPoint()).Project(&lnRail, seg0.EndPoint());
|
||
segHit=seg0;
|
||
return (nIntNum? 3:4);
|
||
}
|
||
}
|
||
} else {
|
||
ASSERT(seg0.Is(CURVE_ARC) && seg1.Is(CURVE_ARC));
|
||
XArc ar0=seg0.GetArc();
|
||
XArc ar1=seg1.GetArc();
|
||
XPoint ptOn;
|
||
if(ar0.GetCenterPt().Distance(ar1.GetCenterPt())<_DIST_SNAP &&
|
||
fabs(ar0.GetRadius()-ar1.GetRadius())<nTol && seg0.MidPoint().Project(&ar1, ptOn)==RTNORM &&
|
||
(ptOn&seg1)==PR_INSIDE) {
|
||
double nOffDist=polyMe.GetBulge(n)>0? -nTol/2.0 : nTol/2.0;
|
||
XCurveSegment segRail=seg1.Offset(OFFSET_RIGHT, nOffDist, LS_INFINITE);
|
||
|
||
XPoint pt1, pt2, ptMid;
|
||
seg0.StartPoint().Project(&ar1, pt1);
|
||
seg0.EndPoint().Project(&ar1, pt2);
|
||
seg0.MidPoint().Project(&ar1, ptMid);
|
||
|
||
segHit=XArc(pt1, ptMid, pt2);
|
||
segHit.SetLineFlag(LS_FINITE);
|
||
return (nIntNum? 3:4);
|
||
}
|
||
}
|
||
}
|
||
|
||
return (nIntNum? 1 : 2);
|
||
}
|
||
|
||
// cet 2012.11.12 add支持导出XML
|
||
CString TDbSlab::GetXml(const AcGeMatrix3d& mat) const
|
||
{
|
||
TXmlTree xmlTree;
|
||
POSITION posRoot = xmlTree.Insert(_T("ATS_SLAB"), NULL, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posRoot, _T("name"), _T("平板"));
|
||
xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
|
||
}
|
||
|
||
CString strText;
|
||
POSITION posItemThick = xmlTree.Insert(_T("Flr_thick"), posRoot, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posItemThick, _T("name"), _T("板厚"));
|
||
xmlTree.SetAttribute(posItemThick, _T("comment"), _T("板厚"));
|
||
strText.Format(_T("%f"), m_nThickness);
|
||
xmlTree.SetItemText(posItemThick, strText);
|
||
}
|
||
|
||
POSITION posItemNormal = xmlTree.Insert(_T("VtNormal"), posRoot, posItemThick);
|
||
{
|
||
xmlTree.SetAttribute(posItemNormal, _T("name"), _T("方向"));
|
||
XVector3D vtNormal=GetNormal();
|
||
vtNormal.TransformBy(mat);
|
||
strText.Format(_T("%f,%f,%f"), vtNormal.x, vtNormal.y, vtNormal.z);
|
||
xmlTree.SetItemText(posItemNormal, strText);
|
||
}
|
||
|
||
POSITION posItemOutLine = xmlTree.Insert(_T("Baseline"), posRoot, posItemNormal);
|
||
{
|
||
xmlTree.SetAttribute(posItemOutLine, _T("name"), _T("截面参数"));
|
||
POSITION posItem = NULL;
|
||
TADSGePoint3d ptNode;
|
||
int iLen = m_polyOutline.Length();
|
||
for (int i = 0; i < iLen; i++)
|
||
{
|
||
ptNode = m_polyOutline[i];
|
||
// 对点进行坐标变换
|
||
ptNode.TransformBy(mat);
|
||
|
||
strText.Format(_T("Point_%d"), i + 1);
|
||
posItem = xmlTree.Insert(strText, posItemOutLine, posItem);
|
||
{
|
||
strText.Format(_T("第%d点"), i + 1);
|
||
xmlTree.SetAttribute(posItem, _T("name"), strText);
|
||
strText.Format(_T("%f,%f,%f"), ptNode.x, ptNode.y, ptNode.z);
|
||
xmlTree.SetItemText(posItem, strText);
|
||
}
|
||
|
||
strText.Format(_T("Ang_%d"), i + 1);
|
||
posItem = xmlTree.Insert(strText, posItemOutLine, posItem);
|
||
{
|
||
strText.Format(_T("圆心角%d"), i + 1);
|
||
xmlTree.SetAttribute(posItem, _T("name"), strText);
|
||
strText.Format(_T("%f"), m_polyOutline.GetBulge(i));
|
||
xmlTree.SetItemText(posItem, strText);
|
||
}
|
||
|
||
int nSign = -1;
|
||
if (GetVisibilityAt(i))
|
||
nSign = 1;
|
||
else
|
||
nSign = 0;
|
||
strText.Format(_T("Show_%d"), i + 1);
|
||
posItem = xmlTree.Insert(strText, posItemOutLine, posItem);
|
||
{
|
||
strText.Format(_T("点%d是否显示"), i + 1);
|
||
xmlTree.SetAttribute(posItem, _T("name"), strText);
|
||
strText.Format(_T("%d"), nSign);
|
||
xmlTree.SetItemText(posItem, strText);
|
||
}
|
||
}
|
||
}
|
||
|
||
POSITION posItemHole = posItemOutLine;
|
||
int nHoles = m_lstHoles.Length();
|
||
if(nHoles > 0)
|
||
{
|
||
posItemHole = xmlTree.Insert(_T("Holes"), posRoot, posItemOutLine);
|
||
xmlTree.SetAttribute(posItemHole, _T("name"), _T("板洞参数"));
|
||
XPoly2D poly;
|
||
CString sHoleNum;
|
||
POSITION posItemHoleNum = NULL;
|
||
for(int i = 0; i < nHoles; i++)
|
||
{
|
||
sHoleNum.Format(_T("第%d个洞"), i + 1);
|
||
posItemHoleNum = xmlTree.Insert(sHoleNum, posItemHole, posItemHoleNum);
|
||
poly = m_lstHoles[i];
|
||
int nTotal = poly.Length();
|
||
POSITION posItem = NULL;
|
||
TADSGePoint3d ptNode;
|
||
for (int i = 0; i < nTotal; i++)
|
||
{
|
||
ptNode = *poly[i];
|
||
// 对点进行坐标变换
|
||
ptNode.TransformBy(mat);
|
||
|
||
strText.Format(_T("Point_%d"), i + 1);
|
||
posItem = xmlTree.Insert(strText, posItemHoleNum, posItem);
|
||
{
|
||
strText.Format(_T("第%d点"), i + 1);
|
||
xmlTree.SetAttribute(posItem, _T("name"), strText);
|
||
strText.Format(_T("%f,%f,%f"), ptNode.x, ptNode.y, ptNode.z);
|
||
xmlTree.SetItemText(posItem, strText);
|
||
}
|
||
|
||
strText.Format(_T("Ang_%d"), i + 1);
|
||
posItem = xmlTree.Insert(strText, posItemHoleNum, posItem);
|
||
{
|
||
strText.Format(_T("圆心角%d"), i + 1);
|
||
xmlTree.SetAttribute(posItem, _T("name"), strText);
|
||
strText.Format(_T("%f"), m_polyOutline.GetBulge(i));
|
||
xmlTree.SetItemText(posItem, strText);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
POSITION posItemId = xmlTree.Insert(_T("Object_ID"), posRoot, posItemHole);
|
||
{
|
||
xmlTree.SetAttribute(posItemId, _T("name"), _T("ID"));
|
||
xmlTree.SetAttribute(posItemId, _T("comment"), _T("平板ID"));
|
||
strText.Format(_T("%ld"), objectId().asOldId());
|
||
xmlTree.SetItemText(posItemId, strText);
|
||
}
|
||
|
||
CString strBase = TDbEntity::GetXml(mat);
|
||
CString strXml = xmlTree.GetXml();
|
||
int nIndex = strXml.Find(_T("<Object_ID"));
|
||
if (nIndex != -1)
|
||
{
|
||
strXml.Insert(nIndex, strBase);
|
||
}
|
||
return strXml;
|
||
}
|
||
|
||
//填充图层id存到xdata中，必须在deep时写出，注意id必须是hard类型
|
||
Acad::ErrorStatus TDbSlab::subDeepClone(AcDbObject* pOwnerObject,
|
||
AcDbObject*& pClonedObject,
|
||
AcDbIdMapping& idMap,
|
||
Adesk::Boolean isPrimary) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es = TDbEntity::subDeepClone(pOwnerObject, pClonedObject, idMap, isPrimary);
|
||
if (pClonedObject != NULL)
|
||
{
|
||
TDbEntity* pBase = TDbEntity::cast(pClonedObject);
|
||
if (pBase != NULL)
|
||
{
|
||
TDbXDataMap* pMapClone = pBase->GetSpecialtyData();
|
||
if ( pMapClone != NULL)
|
||
{
|
||
m_XDataMap.BeginCloneXlation(pMapClone,idMap);
|
||
}
|
||
}
|
||
}
|
||
return es;
|
||
}
|
||
|
||
Acad::ErrorStatus TDbSlab::subWblockClone( AcRxObject* pOwnerObject,
|
||
AcDbObject*& pClonedObject,
|
||
AcDbIdMapping& idMap,
|
||
Adesk::Boolean isPrimary) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es = TDbEntity::subWblockClone(pOwnerObject, pClonedObject, idMap, isPrimary);
|
||
if (pClonedObject != NULL)
|
||
{
|
||
TDbEntity* pBase = TDbEntity::cast(pClonedObject);
|
||
if (pBase != NULL)
|
||
{
|
||
TDbXDataMap* pMapClone = pBase->GetSpecialtyData();
|
||
if ( pMapClone != NULL)
|
||
{
|
||
m_XDataMap.BeginCloneXlation(pMapClone,idMap);
|
||
}
|
||
}
|
||
}
|
||
return es;
|
||
}
|
||
|
||
int EditSlab0(AcDbObjectId id);
|
||
|
||
void InitDbSlab(BOOL bTrue)
|
||
{
|
||
AecObjectEditMethod pOldEdit=NULL;
|
||
if(bTrue) {
|
||
TDbSlab::rxInit();
|
||
pOldEdit=TDbSlab::SetEditMethod(EditSlab0);
|
||
acrxBuildClassHierarchy();
|
||
TDbSlab::InitMatchProtocol(TRUE);
|
||
} else {
|
||
TDbSlab::InitMatchProtocol(FALSE);
|
||
TDbSlab::SetEditMethod(pOldEdit);
|
||
deleteAcRxClass(TDbSlab::desc());
|
||
}
|
||
}
|
||
|
||
// Command:编辑平板
|
||
int EditSlab0(AcDbObjectId id)
|
||
{
|
||
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSlab, pStep);
|
||
if(!pStep)
|
||
return RTERROR;
|
||
//判断是不是上海城建叠合板实体
|
||
CString strCmdName(_T(""));
|
||
TDbXDataMap map;
|
||
map.Read(pStep, _T("TGZZCL"));
|
||
map.GetAt(_T("cmdName"), strCmdName);
|
||
if (strCmdName == _T("TGZZCLBD"))
|
||
{
|
||
struct resbuf rbUr;
|
||
rbUr.restype = RTSTR;
|
||
rbUr.resval.rstring = _tcsdup(_T("EditObj"));
|
||
rbUr.rbnext = NULL;
|
||
acedSetVar(_T("USERS3"), &rbUr);
|
||
acedPostCommand(strCmdName);
|
||
acedPostCommand(_T("\n"));
|
||
return RTNORM;
|
||
}
|
||
else
|
||
{
|
||
while(1) {
|
||
const TCHAR *szPrompt1=_T("\n选择 [加洞(A)/减洞(D)/加边界(P)/减边界(M)/边可见性(E)/板厚(H)/标高(T)/参数列表(L)]<退出>:");
|
||
XString sKeyword;
|
||
int nRet=0;
|
||
INITGET_BEG(0, _T("A D P M E H T L"));
|
||
nRet=ads_getkword(szPrompt1, sKeyword);
|
||
INITGET_END();
|
||
|
||
if(nRet!=RTNORM)
|
||
break;
|
||
if(sKeyword[0]==_T('H')) {
|
||
double nRailHeight=pStep->GetThickness();
|
||
nRet=GetReal(_T("\n板厚"), nRailHeight);
|
||
if(nRet==RTCAN)
|
||
break;
|
||
if(nRet==RTNORM) {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
pStep->SetThickness(nRailHeight);
|
||
pStep->downgradeOpen();
|
||
}
|
||
} else if(sKeyword[0]==_T('T')) {
|
||
double nElev=pStep->GetElevation();
|
||
nRet=GetReal(_T("\n标高"), nElev);
|
||
if(nRet==RTCAN)
|
||
break;
|
||
if(nRet==RTNORM) {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
pStep->SetElevation(nElev);
|
||
pStep->downgradeOpen();
|
||
}
|
||
} else if(sKeyword[0]==_T('L')) {
|
||
pStep->list();
|
||
} else if(sKeyword[0]==_T('A')) {
|
||
RBList mask=GetClosedCurveMask();
|
||
PickSet ss(SS_FREE);
|
||
const TCHAR *szPrompt[2]={_T("选择封闭的多段线或圆:"), _T("移除已选的多段线或圆")};
|
||
int nRet=ss.Get(_T(":$"), szPrompt, NULL,mask);
|
||
if(nRet==RTCAN)
|
||
return nRet;
|
||
else if(nRet==RTNORM) {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
XVector3D vtNorm=pStep->GetNormal();
|
||
long len=ss.Length();
|
||
for(long i=0L; i<len; i++) {
|
||
Entity ent=ss[i];
|
||
XVector3D vt(0,0,1);
|
||
ent.GetData(210,&vt);
|
||
if(vt.AsAcGeVector3d()!=vtNorm.AsAcGeVector3d())
|
||
continue;
|
||
XPoly2D polyHole(ent);
|
||
if(!polyHole) {
|
||
continue;
|
||
}
|
||
pStep->AddHole(polyHole);
|
||
}
|
||
pStep->downgradeOpen();
|
||
int bDelObj;
|
||
VERIFY(xg_getvar(_T("DELOBJ"), &bDelObj)==RTNORM);
|
||
if(bDelObj) {
|
||
ss.Delete();
|
||
}
|
||
}
|
||
} else if(sKeyword[0]==_T('D')) {
|
||
XPushVar<int> tVar(_T("OSMODE"), OS_NEA);
|
||
XPoint ptEdge;
|
||
int nRet=ads_getpoint(NULL, _T("\n请要移除的洞:"), ptEdge);
|
||
if(nRet==RTCAN)
|
||
return nRet;
|
||
else if(nRet==RTNORM) {
|
||
Adesk::UInt32 nTestCode=0;
|
||
if(!pStep->HitTestOnHole(Ucs2Ecs(ptEdge, pStep->GetNormal()), &nTestCode)) {
|
||
adsout << _T("\n请正确点取!");
|
||
} else {
|
||
nTestCode >>= 16;
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
pStep->RemoveHole(nTestCode);
|
||
pStep->downgradeOpen();
|
||
}
|
||
}
|
||
|
||
} else if(sKeyword[0]==_T('E')) {
|
||
XPushVar<int> tVar(_T("OSMODE"), OS_NEA);
|
||
XPoint ptEdge;
|
||
int nRet=RTNORM;
|
||
INITGET_BEG(0, _T("Y N"));
|
||
nRet=ads_getpoint(NULL, _T("\n点取不可见的边或 [全可见(Y)/全不可见(N)]<退出>:"), ptEdge);
|
||
INITGET_END();
|
||
if(nRet==RTCAN)
|
||
return nRet;
|
||
else if(nRet==RTNORM) {
|
||
Adesk::UInt16 nTestCode=pStep->HitTestOnOutline(ptEdge);
|
||
if(nTestCode<0) {
|
||
adsout << _T("\n请正确点取!");
|
||
} else {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
BOOL bVis=pStep->GetVisibilityAt(nTestCode);
|
||
pStep->SetVisibilityAt(nTestCode, !bVis);
|
||
pStep->downgradeOpen();
|
||
}
|
||
} else if(nRet==RTKWORD) {
|
||
XString sInput;
|
||
ads_getinput(sInput);
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
int nEdgeNum=pStep->GetEdgeNum();
|
||
for(int n=0; n<nEdgeNum; n++)
|
||
pStep->SetVisibilityAt(n, sInput[0]==_T('Y'));
|
||
pStep->downgradeOpen();
|
||
}
|
||
} else if(sKeyword[0]==_T('P') || sKeyword[0]==_T('M')) {
|
||
const TCHAR *szPrompts[2]={
|
||
_T("\n选择一封闭的多段线(或圆)并入当前的边界:"),
|
||
_T("\n选择一封闭的多段线(或圆)以便从当前边界中减去:")
|
||
};
|
||
int nSel=(sKeyword[0]==_T('P')? 0 : 1);
|
||
Entity ent;
|
||
RBList mask=GetClosedCurveMask();
|
||
if(SelectEntity(szPrompts[nSel], ent, mask)==RTNORM) {
|
||
XVector3D vtNorm=pStep->GetNormal();
|
||
XVector3D vt(0,0,1);
|
||
ent.GetData(210,&vt);
|
||
XPoly2D poly2d(ent);
|
||
if(vt.AsAcGeVector3d()==vtNorm.AsAcGeVector3d() && !!poly2d) {
|
||
XPoly2D polySrc(1);
|
||
DList<XPoly2D> lstDest;
|
||
polySrc=pStep->GetOutline();
|
||
polySrc.SetElevation(0.0);
|
||
poly2d.SetElevation(0.0);
|
||
if(PolyBoolOper(polySrc, poly2d, lstDest, nSel? AcDb::kBoolSubtract: AcDb::kBoolUnite) && lstDest.Length()==1) {
|
||
if(pStep->upgradeOpen()==Acad::eOk) {
|
||
lstDest[0]->Compress();
|
||
if(lstDest[0]->PathArea()>0.0)
|
||
lstDest[0]->Reverse();
|
||
double nElev=pStep->GetElevation();
|
||
pStep->SetOutline(*lstDest[0]);
|
||
pStep->SetElevation(nElev);
|
||
pStep->SetVisibilityAll(TRUE);
|
||
pStep->downgradeOpen();
|
||
ent.Delete();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
|