1172 lines
25 KiB
C++
1172 lines
25 KiB
C++
//-----------------------------------------------------------------------------+
|
|
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
|
|
// = FileName : TDbCurveEntity.cpp
|
|
// = Version : ver2.0
|
|
// = Author : xlc
|
|
// = CreateDate : 2002-09-09
|
|
// = Description: 上华曲线对象基类的定义
|
|
// = Maintainers:
|
|
//
|
|
//-----------------------------------------------------------------------------+
|
|
#include "StdAfx.h"
|
|
#include "TDbCurveEntity.h"
|
|
#include "TConfigBase.h"
|
|
#include "TchGlobalFunc.h"
|
|
#include "TchPrivateGlobalFunc.h"
|
|
|
|
ACRX_NO_CONS_DEFINE_MEMBERS(ATSCurveEntity, AcDbCurve);
|
|
TCH_IMPLEMENT_MEMBERS(TDbCurveEntity, AcDbCurve);
|
|
|
|
TDbCurveEntity::TDbCurveEntity()
|
|
{
|
|
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::SetBaseCurve(AcDbCurve*)
|
|
{
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
AcDbCurve* TDbCurveEntity::GetBaseCurve()const
|
|
{
|
|
return NULL; //临时对象，外部析构
|
|
}
|
|
|
|
void TDbCurveEntity::UnionScale(double nScale)
|
|
{
|
|
assertWriteEnabled();
|
|
AcGeMatrix3d mat;
|
|
mat.setToScaling(nScale);
|
|
subTransformBy(mat);
|
|
}
|
|
|
|
Adesk::UInt32 TDbCurveEntity::subViewportDrawLogicalFlags(AcGiViewportDraw * vd)
|
|
{
|
|
Adesk::UInt32 nRet = AcDbEntity::subViewportDrawLogicalFlags(vd);
|
|
nRet = TEntityBase::ViewportDrawLogicalFlags(vd, nRet);
|
|
|
|
return nRet;
|
|
}
|
|
|
|
Adesk::UInt32 TDbCurveEntity::subSetAttributes(AcGiDrawableTraits * traits)
|
|
{
|
|
Adesk::UInt32 nRet = AcDbEntity::subSetAttributes(traits);
|
|
nRet = TEntityBase::SetAttributes(traits, nRet);
|
|
|
|
return nRet;
|
|
}
|
|
|
|
//AcGeCurve3d 验证[lfy 2011-8-29]
|
|
Adesk::Boolean TDbCurveEntity::isOn(AcDbCurve* pCurve,const AcGePoint3d& pnt,const AcGeTol& tol) const
|
|
{
|
|
if ( pCurve != NULL)
|
|
{
|
|
AcDbLine* pLine = AcDbLine::cast(pCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
AcGeLine3d line3d(pLine->startPoint(),pLine->endPoint());
|
|
if (line3d.isOn(pnt,tol))
|
|
{
|
|
return Adesk::kTrue;
|
|
}
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(pCurve);
|
|
if (pArc != NULL)
|
|
{
|
|
AcGePoint3d ptSta,ptMid,ptEnd;
|
|
pArc->getStartPoint(ptSta);
|
|
pArc->getEndPoint(ptEnd);
|
|
|
|
double dSta = 0.0,dEnd = 0.0;
|
|
pArc->getStartParam(dSta);
|
|
pArc->getEndParam(dEnd);
|
|
pArc->getPointAtParam( (dSta + dEnd) / 2.0,ptMid);
|
|
|
|
AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
|
|
if (arc.isOn(pnt,tol))
|
|
{
|
|
return Adesk::kTrue;
|
|
}
|
|
}
|
|
|
|
//...
|
|
}
|
|
return Adesk::kFalse;
|
|
}
|
|
|
|
Adesk::Boolean TDbCurveEntity::isOn(AcDbCurve* pCurve,double param,const AcGeTol& tol) const
|
|
{
|
|
if ( pCurve != NULL)
|
|
{
|
|
AcDbLine* pLine = AcDbLine::cast(pCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
AcGeLine3d line3d(pLine->startPoint(),pLine->endPoint());
|
|
if (line3d.isOn(param,tol))
|
|
{
|
|
return Adesk::kTrue;
|
|
}
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(pCurve);
|
|
if (pArc != NULL)
|
|
{
|
|
AcGePoint3d ptSta,ptMid,ptEnd;
|
|
pArc->getStartPoint(ptSta);
|
|
pArc->getEndPoint(ptEnd);
|
|
|
|
double dSta = 0.0,dEnd = 0.0;
|
|
pArc->getStartParam(dSta);
|
|
pArc->getEndParam(dEnd);
|
|
pArc->getPointAtParam( (dSta + dEnd) / 2.0,ptMid);
|
|
|
|
AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
|
|
if (arc.isOn(param,tol))
|
|
{
|
|
return Adesk::kTrue;
|
|
}
|
|
}
|
|
}
|
|
return Adesk::kFalse;
|
|
}
|
|
|
|
Adesk::Boolean TDbCurveEntity::isClosed() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Adesk::Boolean bRet = pCurve->isClosed();
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::isClosed();
|
|
}
|
|
}
|
|
|
|
Adesk::Boolean TDbCurveEntity::isPeriodic() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Adesk::Boolean bRet = pCurve->isPeriodic();
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::isPeriodic();
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getStartParam(double&pa) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getStartParam(pa);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getStartParam(pa);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getEndParam (double&pa) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getEndParam(pa);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getEndParam(pa);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getStartPoint(AcGePoint3d&pt) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getStartPoint(pt);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getStartPoint(pt);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getEndPoint (AcGePoint3d&pt) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getEndPoint(pt);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getEndPoint(pt);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getPointAtParam(double pa, AcGePoint3d&pt) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getPointAtParam(pa,pt);
|
|
//lfy 2011-8-29 再确认验证一次
|
|
if (bRet != Acad::eOk)
|
|
{
|
|
if (isOn(pCurve, pa))
|
|
{
|
|
bRet = Acad::eOk;
|
|
}
|
|
}
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getPointAtParam(pa,pt);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getParamAtPoint(const AcGePoint3d& pt, double&pa)const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getParamAtPoint(pt,pa);
|
|
//lfy 2011-8-29 再确认验证一次
|
|
if (bRet != Acad::eOk)
|
|
{
|
|
if (isOn(pCurve, pa))
|
|
{
|
|
bRet = Acad::eOk;
|
|
}
|
|
}
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getParamAtPoint(pt,pa);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getDistAtParam (double param, double& dist) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getDistAtParam(param,dist);
|
|
//lfy 2011-8-29 再确认验证一次
|
|
if (bRet != Acad::eOk)
|
|
{
|
|
if (isOn(pCurve, param))
|
|
{
|
|
bRet = Acad::eOk;
|
|
}
|
|
}
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getDistAtParam(param,dist);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getParamAtDist (double dist, double& param) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getParamAtDist(dist,param);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getParamAtDist(dist,param);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getDistAtPoint (const AcGePoint3d& pt, double& dist)const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getDistAtPoint(pt,dist);
|
|
//lfy 2011-8-29 再确认验证一次
|
|
if (bRet != Acad::eOk)
|
|
{
|
|
if (isOn(pCurve, dist))
|
|
{
|
|
bRet = Acad::eOk;
|
|
}
|
|
}
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getDistAtPoint(pt,dist);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getPointAtDist (double dist, AcGePoint3d&pt) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getPointAtDist(dist,pt);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getPointAtDist(dist,pt);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getFirstDeriv (double param,AcGeVector3d& firstDeriv) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getFirstDeriv(param,firstDeriv);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getFirstDeriv(param,firstDeriv);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getFirstDeriv (const AcGePoint3d&pt,AcGeVector3d& firstDeriv) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getFirstDeriv(pt,firstDeriv);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getFirstDeriv(pt,firstDeriv);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getSecondDeriv (double param,AcGeVector3d& secDeriv) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getSecondDeriv(param,secDeriv);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getSecondDeriv(param,secDeriv);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getSecondDeriv (const AcGePoint3d&pt,AcGeVector3d& secDeriv) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getSecondDeriv(pt,secDeriv);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getSecondDeriv(pt,secDeriv);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getClosestPointTo(const AcGePoint3d& givenPnt,
|
|
AcGePoint3d& pointOnCurve,
|
|
Adesk::Boolean extend) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getClosestPointTo(givenPnt,pointOnCurve,extend);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getClosestPointTo(givenPnt,pointOnCurve,extend);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getClosestPointTo(const AcGePoint3d& givenPnt,
|
|
const AcGeVector3d& direction,
|
|
AcGePoint3d& pointOnCurve,
|
|
Adesk::Boolean extend) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getClosestPointTo(givenPnt,direction,pointOnCurve,extend);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getClosestPointTo(givenPnt,direction,pointOnCurve,extend);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getOrthoProjectedCurve(const AcGePlane& plane,
|
|
AcDbCurve*& projCrv) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
AcDbCurve* pCurve1 = NULL;
|
|
Acad::ErrorStatus bRet = pCurve->getOrthoProjectedCurve(plane,pCurve1);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
TDbCurveEntity* pCurveEnt = (TDbCurveEntity*)clone();
|
|
bRet = pCurveEnt->SetBaseCurve(pCurve1);
|
|
projCrv = pCurveEnt;
|
|
|
|
delete pCurve1;
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getOrthoProjectedCurve(plane,projCrv);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getProjectedCurve(const AcGePlane& plane,
|
|
const AcGeVector3d& projDir,
|
|
AcDbCurve*& projCrv) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
AcDbCurve* pCurve1 = NULL;
|
|
Acad::ErrorStatus bRet = pCurve->getProjectedCurve(plane,projDir,pCurve1);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
TDbCurveEntity* pCurveEnt = (TDbCurveEntity*)clone();
|
|
bRet = pCurveEnt->SetBaseCurve(pCurve1);
|
|
projCrv = pCurveEnt;
|
|
|
|
delete pCurve1;
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getProjectedCurve(plane,projDir,projCrv);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getOffsetCurves(double offsetDist,
|
|
AcDbVoidPtrArray& offsetCurves) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
AcDbVoidPtrArray offsetCurves0;
|
|
Acad::ErrorStatus bRet = pCurve->getOffsetCurves(offsetDist,offsetCurves0);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
for (long i = 0; i < offsetCurves0.length(); i++)
|
|
{
|
|
TDbCurveEntity*pCurveEnt = (TDbCurveEntity*)clone();
|
|
pCurveEnt->SetBaseCurve((AcDbCurve*)offsetCurves0[i]);
|
|
offsetCurves.append(pCurveEnt);
|
|
}
|
|
|
|
ReleaseEntSet(offsetCurves0);
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getOffsetCurves(offsetDist,offsetCurves);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getOffsetCurvesGivenPlaneNormal(
|
|
const AcGeVector3d& normal,
|
|
double offsetDist,
|
|
AcDbVoidPtrArray& offsetCurves) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
AcDbVoidPtrArray offsetCurves0;
|
|
Acad::ErrorStatus bRet = pCurve->getOffsetCurvesGivenPlaneNormal(normal,offsetDist,offsetCurves0);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
for (long i = 0; i < offsetCurves0.length(); i++)
|
|
{
|
|
TDbCurveEntity*pCurveEnt = (TDbCurveEntity*)clone();
|
|
pCurveEnt->SetBaseCurve((AcDbCurve*)offsetCurves0[i]);
|
|
offsetCurves.append(pCurveEnt);
|
|
}
|
|
|
|
ReleaseEntSet(offsetCurves0);
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
return AcDbCurve::getOffsetCurvesGivenPlaneNormal(normal,offsetDist,offsetCurves);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getSpline(AcDbSpline*& spline) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getSpline(spline);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getSpline(spline);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getSplitCurves (const AcGeDoubleArray& params,
|
|
AcDbVoidPtrArray& curveSegments) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
AcDbVoidPtrArray curveSegments0;
|
|
Acad::ErrorStatus bRet = pCurve->getSplitCurves(params,curveSegments0);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
for (long i = 0; i < curveSegments0.length(); i++)
|
|
{
|
|
TDbCurveEntity*pCurveEnt = (TDbCurveEntity*)clone();
|
|
pCurveEnt->SetBaseCurve((AcDbCurve*)curveSegments0[i]);
|
|
curveSegments.append(pCurveEnt);
|
|
}
|
|
|
|
ReleaseEntSet(curveSegments0);
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getSplitCurves(params,curveSegments);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getSplitCurves (const AcGePoint3dArray& points,
|
|
AcDbVoidPtrArray& curveSegments) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
AcDbVoidPtrArray curveSegments0;
|
|
Acad::ErrorStatus bRet = pCurve->getSplitCurves(points,curveSegments0);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
for (long i = 0; i < curveSegments0.length(); i++)
|
|
{
|
|
TDbCurveEntity*pCurveEnt = (TDbCurveEntity*)clone();
|
|
pCurveEnt->SetBaseCurve((AcDbCurve*)curveSegments0[i]);
|
|
curveSegments.append(pCurveEnt);
|
|
}
|
|
|
|
ReleaseEntSet(curveSegments0);
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getSplitCurves(points,curveSegments);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::extend(double newParam)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->extend(newParam);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
bRet = SetBaseCurve(pCurve);
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::extend(newParam);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::extend(Adesk::Boolean extendStart,
|
|
const AcGePoint3d& toPoint)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->extend(extendStart,toPoint);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
bRet = SetBaseCurve(pCurve);
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::extend(extendStart,toPoint);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getArea(double&area) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getArea(area);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getArea(area);
|
|
}
|
|
}
|
|
|
|
Adesk::Boolean TDbCurveEntity::isPlanar() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Adesk::Boolean bRet = pCurve->isPlanar();
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::isPlanar();
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::getPlane(AcGePlane&plane, AcDb::Planarity&pr) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getPlane(plane,pr);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::getPlane(plane,pr);
|
|
}
|
|
}
|
|
|
|
void TDbCurveEntity::getEcs(AcGeMatrix3d& retVal) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
pCurve->getEcs(retVal);
|
|
delete pCurve;
|
|
}
|
|
else
|
|
{
|
|
AcDbCurve::getEcs(retVal);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::GetOsnapPoints(
|
|
AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& pickPoint,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (TchGeLib::g_bSnapCurveBase)
|
|
{
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getOsnapPoints(osnapMode,gsSelectionMark, pickPoint,
|
|
lastPoint,viewXform,snapPoints,geomIds);
|
|
delete pCurve;
|
|
|
|
// add by xlc on 100818 墙体捕捉时允许捕捉墙线和保温线
|
|
if (_tcsicmp(isA()->name(),_T("TDbWall")) != 0)
|
|
|
|
{
|
|
return bRet;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TEntityBase::GetOsnapPoints(osnapMode,gsSelectionMark, pickPoint,
|
|
lastPoint,viewXform,snapPoints,geomIds);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::GetOsnapPoints(
|
|
AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& pickPoint,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds,
|
|
const AcGeMatrix3d& insertionMat) const
|
|
{
|
|
#if ADS<16
|
|
return Acad::eNotImplemented;
|
|
#else
|
|
assertReadEnabled();
|
|
|
|
if (g_bSnapCurveBase)
|
|
{
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getOsnapPoints(osnapMode,gsSelectionMark,pickPoint,
|
|
lastPoint,viewXform,snapPoints,geomIds,insertionMat);
|
|
|
|
delete pCurve;
|
|
|
|
// add by xlc on 100818 墙体捕捉时允许捕捉墙线和保温线
|
|
if (_tcsicmp(isA()->name(),_T("TDbWall")) != 0)
|
|
|
|
{
|
|
return bRet;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TEntityBase::GetOsnapPoints(osnapMode,gsSelectionMark, pickPoint,
|
|
lastPoint,viewXform,snapPoints,geomIds,insertionMat);
|
|
#endif
|
|
}
|
|
|
|
#if (ADS > 15 && ADS < 18)
|
|
Acad::ErrorStatus TDbCurveEntity::subGetOsnapPoints(
|
|
AcDb::OsnapMode osnapMode,
|
|
int gsSelectionMark,
|
|
const AcGePoint3d& pickPoint,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeFastTransform& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getOsnapPoints(osnapMode,gsSelectionMark,
|
|
pickPoint,lastPoint,viewXform,snapPoints,geomIds);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::subGetOsnapPoints(osnapMode,gsSelectionMark,
|
|
pickPoint,lastPoint,viewXform,snapPoints,geomIds);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::subGetOsnapPoints(
|
|
AcDb::OsnapMode osnapMode,
|
|
int gsSelectionMark,
|
|
const AcGePoint3d& pickPoint,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeFastTransform& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds,
|
|
const AcGeMatrix3d& insertionMat) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getOsnapPoints(osnapMode,gsSelectionMark, pickPoint,
|
|
lastPoint,viewXform,snapPoints,geomIds,insertionMat);
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::subGetOsnapPoints(osnapMode,gsSelectionMark, pickPoint,
|
|
lastPoint,viewXform,snapPoints,geomIds,insertionMat);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::subTransformBy(const AcGeFastTransform& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->transformBy(xform);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
SetBaseCurve(pCurve);
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::subTransformBy(xform);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds)const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getGripPoints(gripPoints,osnapModes,geomIds);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::subGetGripPoints(gripPoints,osnapModes,geomIds);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::subMoveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->moveGripPointsAt(indices,offset);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
SetBaseCurve(pCurve);
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::subMoveGripPointsAt(indices,offset);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::subGetStretchPoints(
|
|
AcGePoint3dArray& stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->getStretchPoints(stretchPoints);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::subGetStretchPoints(stretchPoints);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::subMoveStretchPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->moveStretchPointsAt(indices,offset);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
SetBaseCurve(pCurve);
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::subMoveStretchPointsAt(indices,offset);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::IntersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker ,
|
|
INT_PTR otherGsMarker ) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->intersectWith(pEnt,intType,points,thisGsMarker,otherGsMarker);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::subIntersectWith(pEnt,intType,points,thisGsMarker,otherGsMarker);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::IntersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
const AcGePlane& projPlane,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->intersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker);
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::subIntersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::TransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
TDbCurveEntity::subTransformBy(xform);
|
|
|
|
AcDbCurve* pCurve = GetBaseCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
Acad::ErrorStatus bRet = pCurve->transformBy(xform);
|
|
if (bRet == Acad::eOk)
|
|
{
|
|
SetBaseCurve(pCurve);
|
|
}
|
|
|
|
delete pCurve;
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return AcDbCurve::subTransformBy(xform);
|
|
}
|
|
}
|
|
|
|
#if ADS > 15
|
|
|
|
void TDbCurveEntity::subGripStatus(const AcDb::GripStat status)
|
|
{
|
|
assertReadEnabled();
|
|
TEntityBase::GripStatus(status);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::subGetGripPoints(AcDbGripDataPtrArray& grips,
|
|
const double curViewUnitSize,
|
|
const int gripSize,
|
|
const AcGeVector3d& curViewDir,
|
|
const int bitflags) const
|
|
{
|
|
assertReadEnabled();
|
|
return TEntityBase::GetGripPoints(grips,curViewUnitSize,gripSize,curViewDir,bitflags);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveEntity::subMoveGripPointsAt(const AcDbVoidPtrArray& appData,
|
|
const AcGeVector3d& offset,
|
|
const int bitflags)
|
|
{
|
|
assertWriteEnabled();
|
|
return TEntityBase::MoveGripPointsAt(appData,offset,bitflags);
|
|
}
|
|
|
|
#endif
|
|
|
|
AcDbObjectId TDbCurveEntity::InitLayer(LPCTSTR pszLayer, BOOL bApplyChange )
|
|
{
|
|
AcDbObjectId idLay;
|
|
TConfigBase* pBase = GetGlobalConfigBase();
|
|
|
|
if (pBase != NULL)
|
|
{
|
|
idLay = pBase->InitLayer(pszLayer,bApplyChange);
|
|
}
|
|
|
|
return idLay;
|
|
}
|
|
//t20
|
|
TDbXDataMap* TDbCurveEntity::GetSpecialtyData()
|
|
{
|
|
if (isWriteEnabled())
|
|
{
|
|
assertWriteEnabled();
|
|
}
|
|
else
|
|
{
|
|
assertReadEnabled();
|
|
}
|
|
return &m_XDataMap;
|
|
}
|
|
|
|
TDbXDataMap* TDbCurveEntity::GetSpecialtyDataReadOnly() const
|
|
{
|
|
assertReadEnabled();
|
|
return (TDbXDataMap*)&m_XDataMap;
|
|
}
|
|
|
|
BOOL TDbCurveEntity::SetAt(LPCTSTR pszKey,TXData& XData)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbXDataMap* pXMap = GetSpecialtyData();
|
|
if (pXMap != NULL)
|
|
{
|
|
pXMap->SetAt(pszKey,XData);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TDbCurveEntity::GetAt(LPCTSTR pszKey,TXData& XData) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
TDbXDataMap* pXMap = GetSpecialtyDataReadOnly();
|
|
if (pXMap != NULL)
|
|
{
|
|
return pXMap->GetAt(pszKey,XData);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|