411 lines
8.9 KiB
C++
411 lines
8.9 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbTerrain.h"
|
|
#include "_cgal.h"
|
|
|
|
namespace
|
|
{
|
|
double calcAverageZ(const Geometry::GePoint3dArray &pts)
|
|
{
|
|
double dElev(.0);
|
|
for (size_t i(0); i < pts.size(); ++i)
|
|
dElev += pts[i].z;
|
|
dElev /= pts.size();
|
|
return dElev;
|
|
}
|
|
}
|
|
|
|
Adesk::UInt32 AecDbTerrain::kCurrentVersionNumber = 1;
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS (AecDbTerrain, AecDbEntityBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_DBTERRAIN,
|
|
"AecDbTerrain"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
|
|
AecDbTerrain::AecDbTerrain(void): m_iSmoothLevel(0)
|
|
, m_points(0)
|
|
, m_outer(0)
|
|
, m_holes(0)
|
|
{
|
|
m_mapSpecXData.SetAt(KEY_NAME, _T("上华地形"));
|
|
}
|
|
|
|
AecDbTerrain::~AecDbTerrain(void)
|
|
{
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::dwgInFields(AcDbDwgFiler* pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = AecDbEntityBase::dwgInFields(pFiler);
|
|
if (es != Acad::eOk) return (es);
|
|
|
|
//----- Object version number needs to be read first
|
|
Adesk::UInt32 version(0);
|
|
if ((es = pFiler->readUInt32(&version)) != Acad::eOk) return (es);
|
|
|
|
if (version > AecDbTerrain::kCurrentVersionNumber) return Acad::eMakeMeProxy;
|
|
|
|
AcGePoint3d pt(AcGePoint3d::kOrigin);
|
|
Adesk::UInt64 count(0), subCount(0);
|
|
pFiler->readUInt64(&count);
|
|
m_points.clear();
|
|
for (Adesk::UInt64 i(0); i < count; ++i)
|
|
{
|
|
if (pFiler->readPoint3d(&pt) == Acad::eOk)
|
|
m_points.push_back(pt);
|
|
}
|
|
|
|
Geometry::GePoint3dArray ar;
|
|
count = 0;
|
|
pFiler->readUInt64(&count);
|
|
m_holes.clear();
|
|
for (Adesk::UInt64 i(0); i < count; ++i)
|
|
{
|
|
ar.clear();
|
|
pFiler->readUInt64(&subCount);
|
|
for (Adesk::UInt64 j(0); j < subCount; ++j)
|
|
{
|
|
if (pFiler->readPoint3d(&pt) == Acad::eOk)
|
|
ar.push_back(pt);
|
|
}
|
|
if (!ar.empty())
|
|
m_holes.push_back(ar);
|
|
}
|
|
|
|
count = 0;
|
|
m_outer.clear();
|
|
pFiler->readUInt64(&count);
|
|
for (Adesk::UInt64 i(0); i < count; ++i)
|
|
{
|
|
if (pFiler->readPoint3d(&pt) == Acad::eOk)
|
|
m_outer.push_back(pt);
|
|
}
|
|
|
|
Adesk::Int32 iSm;
|
|
pFiler->readInt32(&iSm);
|
|
m_iSmoothLevel = iSm;
|
|
|
|
m_dElev = calcAverageZ(m_points);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = AecDbEntityBase::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return (es);
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ((es = pFiler->writeUInt32(AecDbTerrain::kCurrentVersionNumber)) != Acad::eOk)
|
|
return (es);
|
|
|
|
pFiler->writeUInt64(m_points.size());
|
|
for (size_t i(0); i < m_points.size(); ++i)
|
|
{
|
|
pFiler->writePoint3d(m_points[i]);
|
|
}
|
|
|
|
pFiler->writeUInt64(m_holes.size());
|
|
for (size_t i(0); i < m_holes.size(); ++i)
|
|
{
|
|
pFiler->writeUInt64(m_holes[i].size());
|
|
for (size_t j(0); j < m_holes[i].size(); ++j)
|
|
{
|
|
pFiler->writePoint3d(m_holes[i][j]);
|
|
}
|
|
}
|
|
|
|
pFiler->writeUInt64(m_outer.size());
|
|
for (size_t i(0); i < m_outer.size(); ++i)
|
|
{
|
|
pFiler->writePoint3d(m_outer[i]);
|
|
}
|
|
|
|
pFiler->writeInt32(m_iSmoothLevel);
|
|
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::dxfInFields(AcDbDxfFiler* pFiler)
|
|
{
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::subExplode(AcDbVoidPtrArray& entitySet) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbTerrain::subList() const {}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbVoidPtrArray ar = Get3DBuffer();
|
|
for (int i(0); i < ar.length(); ++i)
|
|
{
|
|
AcDbEntity *pEnt = AcDbEntity::cast((AcDbObject*)ar[i]);
|
|
if (pEnt)
|
|
{
|
|
AcDbSubDMesh *pMesh = AcDbSubDMesh::cast(pEnt);
|
|
if (pMesh)
|
|
pMesh->getGripPoints(gripPoints, osnapModes, geomIds);
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::subGetGripPoints(AcDbGripDataPtrArray& grips,
|
|
const double curViewUnitSize,
|
|
const int gripSize,
|
|
const AcGeVector3d& curViewDir,
|
|
const int bitflags) const { return Acad::eNotImplementedYet; }
|
|
|
|
Acad::ErrorStatus AecDbTerrain::subMoveGripPointsAt(const AcDbVoidPtrArray& appData, const AcGeVector3d& offset, const int bitflags)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbTerrain::GetGripText(int nPos, CString& sText)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::subIntersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::subIntersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
const AcGePlane& projPlane,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
return Draw3d(dc);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbTerrain::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
if (Has3DBuffer())
|
|
{
|
|
Draw3DBuffers(dc);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 没有外轮廓，说明不是区域地形
|
|
Geometry::GePolyArray3d holes;
|
|
if (m_outer.empty())
|
|
{
|
|
if (!m_holes.empty())
|
|
{
|
|
// 先取出外轮廓
|
|
Geometry::GePoint3dArray arOuter;
|
|
Geometry::calcConvexHull2D(m_points, arOuter);
|
|
holes.assign(m_holes.begin(), m_holes.end());
|
|
holes.push_back(arOuter);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
holes.assign(m_holes.begin(), m_holes.end());
|
|
holes.push_back(m_outer);
|
|
}
|
|
|
|
AcGePoint3dArray vertexArray;
|
|
AcArray<Adesk::Int32> faceArray;
|
|
Geometry::delaunayTriangulationMeshWithHolds(m_points, holes, vertexArray, faceArray);
|
|
|
|
AcDbSubDMesh *pMesh = new AcDbSubDMesh();
|
|
Acad::ErrorStatus es;
|
|
if ((es = pMesh->setSubDMesh(vertexArray, faceArray, m_iSmoothLevel)) != Acad::eOk)
|
|
{
|
|
acutPrintf(_T("\n设置平滑度%d失败，按照0级平滑度生成。"), m_iSmoothLevel);
|
|
pMesh->setSubDMesh(vertexArray, faceArray, 0);
|
|
DELETE_PTR(pMesh);
|
|
return es;
|
|
}
|
|
|
|
pMesh->setTransparency(transparency());
|
|
dc.DrawEntity(pMesh);
|
|
|
|
Add3DBuffer(pMesh);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
SHJson::WValue& AecDbTerrain::ToJson(bool bExprotGeo) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::ToJson(bExprotGeo);
|
|
}
|
|
|
|
bool AecDbTerrain::ByJson(const SHJson::WValue &v)
|
|
{
|
|
AssertWriteEnabled();
|
|
return AecDbEntityBase::ByJson(v);
|
|
}
|
|
|
|
AecDbObjXDataMap* AecDbTerrain::GetSpecialtyData(AcDb::OpenMode bMode)
|
|
{
|
|
if (bMode == AcDb::kForWrite)
|
|
AssertWriteEnabled();
|
|
else
|
|
assertReadEnabled();
|
|
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
const AecDbObjXDataMap* AecDbTerrain::GetSpecialtyData() const
|
|
{
|
|
assertReadEnabled();
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
int AecDbTerrain::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray &arEntPtrs) const
|
|
{
|
|
assertReadEnabled();
|
|
return GetDraw3dables(arEntPtrs, false);
|
|
}
|
|
|
|
int AecDbTerrain::GetDraw3dables(AcDbVoidPtrArray &arEntPtrs, bool bWriteBimInfo) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbEntity *pEnt = NULL, *pEntClone = NULL;
|
|
|
|
AcDb3dSolid *pSolidAll = NULL;
|
|
AcDb3dSolid *pSolid = NULL;
|
|
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0; i < ar3D.length(); i++)
|
|
{
|
|
pEnt = (AcDbEntity *)ar3D.at(i);
|
|
pEntClone = (AcDbEntity *)pEnt->clone();
|
|
if (pEntClone != NULL)
|
|
{
|
|
pEntClone->setColorIndex(pEnt->colorIndex());
|
|
pEntClone->setLayer(layerId());
|
|
pEntClone->setLinetype(linetypeId());
|
|
arEntPtrs.append(pEntClone);
|
|
}
|
|
}
|
|
return arEntPtrs.length();
|
|
}
|
|
|
|
void AecDbTerrain::setPoints(const AcGePoint3dArray &ar)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
m_points.clear();
|
|
for (int i(0); i < ar.length(); ++i)
|
|
{
|
|
m_points.push_back(ar[i]);
|
|
}
|
|
m_dElev = calcAverageZ(m_points);
|
|
}
|
|
|
|
void AecDbTerrain::setPoints(const Geometry::GePoint3dArray &ar)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_points.clear();
|
|
m_points.assign(ar.begin(), ar.end());
|
|
m_dElev = calcAverageZ(m_points);
|
|
}
|
|
|
|
void AecDbTerrain::setOuter(const Geometry::GePoint3dArray &outer)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_outer.clear();
|
|
m_outer.assign(outer.begin(), outer.end());
|
|
}
|
|
|
|
void AecDbTerrain::addHold(std::vector<AcGePoint3d> &poly)
|
|
{
|
|
AssertWriteEnabled();
|
|
if (!poly.empty())
|
|
m_holes.push_back(poly);
|
|
}
|
|
|
|
bool AecDbTerrain::clearHolds()
|
|
{
|
|
AssertWriteEnabled();
|
|
m_holes.clear();
|
|
return m_holes.empty();
|
|
}
|
|
|
|
bool AecDbTerrain::deleteHold(const AcGePoint3d &ptInHold)
|
|
{
|
|
AssertWriteEnabled();
|
|
AcGePoint2d pt(ptInHold.x, ptInHold.y);
|
|
|
|
Geometry::GePwh2d pwh;
|
|
pwh.inner_holes.clear();
|
|
|
|
Geometry::GePolyArray3d::iterator it(m_holes.begin());
|
|
for (; it != m_holes.end(); ++it)
|
|
{
|
|
pwh.outer_boundary.vertexs.clear();
|
|
for (size_t j(0); j < it->size(); ++j)
|
|
{
|
|
pwh.outer_boundary.vertexs.push_back(AcGePoint2d(it->at(j).x , it->at(j).y));
|
|
}
|
|
if (Geometry::boundary_check(pt, pwh) == Geometry::eInside)
|
|
{
|
|
m_holes.erase(it);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
double AecDbTerrain::getElev()
|
|
{
|
|
return m_dElev;
|
|
}
|
|
|
|
void AecDbTerrain::setSmoothLevel(int i)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_iSmoothLevel = i;
|
|
}
|
|
|
|
int AecDbTerrain::getSmoothLevel()
|
|
{
|
|
return m_iSmoothLevel;
|
|
}
|