468 lines
13 KiB
C++
468 lines
13 KiB
C++
|
|
||
|
|
#include "StdAfx.h"
|
||
|
|
#include "_cgal.h"
|
||
|
|
#include "mg_cgal_export.h"
|
||
|
|
|
||
|
|
/*
|
||
|
|
modernGlue.dll 完全满足ABI安全,但要安全使用, 请保证:
|
||
|
|
modernGlue.dll 申请的内存,一定要用 modernGlue.dll 内的函数释放
|
||
|
|
本工程申请的内存,一定在本工程内释放.
|
||
|
|
不要跨dll释放内存.
|
||
|
|
*/
|
||
|
|
|
||
|
|
// 检测 pod 类型
|
||
|
|
#define CGAL_STATIC_ASSERT(expr, msg) typedef char ERROR_##msg[ (expr) ? 1 : -1 ]
|
||
|
|
|
||
|
|
namespace
|
||
|
|
{
|
||
|
|
void pt_copy(const AcGePoint2d &src, _cgal::Pt2d &pt) { pt.x = src.x; pt.y = src.y; }
|
||
|
|
|
||
|
|
void pt_copy(const _cgal::Pt2d &src, AcGePoint2d &pt) { pt.x = src.x; pt.y = src.y; }
|
||
|
|
|
||
|
|
void pt_copy(const AcGePoint3d &src, _cgal::Pt3d &pt) { pt.x = src.x; pt.y = src.y; pt.z = src.z; }
|
||
|
|
|
||
|
|
void pt_copy(const _cgal::Pt3d &src, AcGePoint3d &pt) { pt.x = src.x; pt.y = src.y; pt.z = src.z; }
|
||
|
|
|
||
|
|
void pt_copy(const AcGePoint3d &src, _cgal::Pt2d &pt) { pt.x = src.x; pt.y = src.y; }
|
||
|
|
|
||
|
|
void pt_copy(const _cgal::Pt2d &src, AcGePoint3d &pt) { pt.x = src.x; pt.y = src.y; pt.z = .0; }
|
||
|
|
|
||
|
|
template <class T_SRC, class T_DST>
|
||
|
|
void vector_arr(const std::vector<T_SRC> &src, _cgal::CgalArray<T_DST> &dest)
|
||
|
|
{
|
||
|
|
if (src.empty()) return;
|
||
|
|
|
||
|
|
dest.count = (int)src.size();
|
||
|
|
dest.pData = new T_DST[dest.count]();
|
||
|
|
|
||
|
|
for (int i(0); i < dest.count; ++i)
|
||
|
|
pt_copy(src[i], dest.pData[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T_SRC, class T_DST>
|
||
|
|
void arr_vector(const _cgal::CgalArray<T_DST> &src, std::vector<T_SRC> &dest)
|
||
|
|
{
|
||
|
|
if (src.count <= 0) return;
|
||
|
|
|
||
|
|
dest.resize(src.count);
|
||
|
|
|
||
|
|
for (int i(0); i < src.count; ++i)
|
||
|
|
pt_copy(src.pData[i], dest[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
void pwh_gePwh(const _cgal::Pwh2d &src, Geometry::GePwh2d &dst)
|
||
|
|
{
|
||
|
|
arr_vector(src.outer_boundary.vertices, dst.outer_boundary.vertexs);
|
||
|
|
|
||
|
|
dst.inner_holes.resize(src.inner_holes.count);
|
||
|
|
|
||
|
|
for (int i(0); i < src.inner_holes.count; ++i)
|
||
|
|
arr_vector(src.inner_holes.pData[i].vertices, dst.inner_holes[i].vertexs);
|
||
|
|
}
|
||
|
|
|
||
|
|
void pwh_gePwh(const _cgal::Pwh2dList &src, Geometry::GePwh2dList &dst)
|
||
|
|
{
|
||
|
|
dst.resize(src.count);
|
||
|
|
for (int i(0); i < src.count; ++i)
|
||
|
|
pwh_gePwh(src.pData[i], dst[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
/////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
template <typename T>
|
||
|
|
class auto_release
|
||
|
|
{
|
||
|
|
CGAL_STATIC_ASSERT(__is_pod(T), Only_POD_types_allowed);
|
||
|
|
|
||
|
|
public:
|
||
|
|
typedef void (*deleter)(T&);
|
||
|
|
private:
|
||
|
|
T m_T;
|
||
|
|
deleter m_deleter; // 保存 C 接口的释放函数指针
|
||
|
|
|
||
|
|
// 封死拷贝语义
|
||
|
|
auto_release(const auto_release &);
|
||
|
|
auto_release &operator=(const auto_release &);
|
||
|
|
|
||
|
|
public:
|
||
|
|
auto_release(const T &t, const deleter &delfunc) : m_T(t), m_deleter(delfunc) {}
|
||
|
|
auto_release(): m_deleter(NULL) { ::memset(&m_T, 0, sizeof(T)); }
|
||
|
|
|
||
|
|
~auto_release()
|
||
|
|
{
|
||
|
|
if (m_deleter)
|
||
|
|
m_deleter(m_T);
|
||
|
|
}
|
||
|
|
|
||
|
|
const T& get() const { return m_T; }
|
||
|
|
T& get() { return m_T; }
|
||
|
|
|
||
|
|
void set(T &t, const deleter &delfunc) { if (m_deleter) m_deleter(m_T); m_T = t; m_deleter = delfunc; }
|
||
|
|
};
|
||
|
|
|
||
|
|
template<class T>
|
||
|
|
void cgal_free_array(_cgal::CgalArray<T> &Arr)
|
||
|
|
{
|
||
|
|
if (Arr.pData)
|
||
|
|
{
|
||
|
|
delete[] Arr.pData; // 在 dll 的堆里安全释放
|
||
|
|
Arr.pData = 0;
|
||
|
|
Arr.count = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void cgal_free_polygon(T &polygon)
|
||
|
|
{
|
||
|
|
cgal_free_array(polygon.vertices);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void cgal_free_polygonList(T &lst)
|
||
|
|
{
|
||
|
|
for (int i(0); i < lst.count; ++i)
|
||
|
|
cgal_free_polygon(lst.pData[i]);
|
||
|
|
cgal_free_array(lst);
|
||
|
|
}
|
||
|
|
|
||
|
|
void cgal_free_pwh2d(_cgal::Pwh2d &pwh)
|
||
|
|
{
|
||
|
|
cgal_free_polygon(pwh.outer_boundary);
|
||
|
|
cgal_free_polygonList(pwh.inner_holes);
|
||
|
|
}
|
||
|
|
|
||
|
|
void cgal_free_pwh2dList(_cgal::Pwh2dList &pwhlst)
|
||
|
|
{
|
||
|
|
for (int i(0); i < pwhlst.count; ++i)
|
||
|
|
cgal_free_pwh2d(pwhlst.pData[i]);
|
||
|
|
cgal_free_array(pwhlst);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void free_local_obj(_cgal::Pt2dArr &ar) { cgal_free_array(ar); }
|
||
|
|
void free_local_obj(_cgal::Pt3dArr &ar) { cgal_free_array(ar); }
|
||
|
|
void free_local_obj(_cgal::IntArray &ar) { cgal_free_array(ar); }
|
||
|
|
void free_local_obj(_cgal::Pwh2d &ar) { cgal_free_pwh2d(ar); }
|
||
|
|
void free_local_obj(_cgal::Pwh2dList &ar) { cgal_free_pwh2dList(ar); }
|
||
|
|
void free_local_obj(_cgal::Polygon2d &ar) { cgal_free_polygon(ar); }
|
||
|
|
void free_local_obj(_cgal::Polygon2dList &ar) { cgal_free_polygonList(ar); }
|
||
|
|
void free_local_obj(_cgal::Polygon3d &ar) { cgal_free_polygon(ar); }
|
||
|
|
void free_local_obj(_cgal::Polygon3dList &ar) { cgal_free_polygonList(ar); }
|
||
|
|
|
||
|
|
void free_mg_obj(_cgal::Pt2dArr &ar) { mg_cgal_free_Pt2dArray(ar); }
|
||
|
|
void free_mg_obj(_cgal::Pt3dArr &ar) { mg_cgal_free_Pt3dArray(ar); }
|
||
|
|
void free_mg_obj(_cgal::IntArray &ar) { mg_cgal_free_IntArray(ar); }
|
||
|
|
void free_mg_obj(_cgal::Pwh2d &ar) { mg_cgal_free_Pwh2d(ar); }
|
||
|
|
void free_mg_obj(_cgal::Pwh2dList &ar) { mg_cgal_free_Pwh2dList(ar); }
|
||
|
|
void free_mg_obj(_cgal::Polygon2d &ar) { mg_cgal_free_Polygon2d(ar); }
|
||
|
|
void free_mg_obj(_cgal::Polygon2dList &ar) { mg_cgal_free_Polygon2dList(ar); }
|
||
|
|
void free_mg_obj(_cgal::Polygon3d &ar) { mg_cgal_free_Polygon3d(ar); }
|
||
|
|
void free_mg_obj(_cgal::Polygon3dList &ar) { mg_cgal_free_Polygon3dList(ar); }
|
||
|
|
|
||
|
|
template <class T_SRC, class T_DST>
|
||
|
|
_cgal::CgalArray<T_DST> get_cgal_ptArr(const std::vector<T_SRC> &arPts)
|
||
|
|
{
|
||
|
|
typedef _cgal::CgalArray<T_DST> _ARR;
|
||
|
|
_ARR out;
|
||
|
|
::memset(&out, 0, sizeof(_ARR)); // 一定要清空一下，保证 arpts 为空时，out也是空
|
||
|
|
vector_arr(arPts, out);
|
||
|
|
return out;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T_SRC, class T_DST>
|
||
|
|
void get_cgal_ptArr(const std::vector<T_SRC> &arPts, auto_release<_cgal::CgalArray<T_DST>> &auto_rel)
|
||
|
|
{
|
||
|
|
_cgal::CgalArray<T_DST> out = get_cgal_ptArr<T_SRC, T_DST>(arPts);
|
||
|
|
auto_rel.set(out, free_local_obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T_DST>
|
||
|
|
T_DST get_cgal_empty_obj()
|
||
|
|
{
|
||
|
|
T_DST dst;
|
||
|
|
::memset(&dst, 0, sizeof(T_DST));
|
||
|
|
return dst;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T_DST>
|
||
|
|
void get_cgal_empty_obj(auto_release<T_DST> &auto_rel)
|
||
|
|
{
|
||
|
|
T_DST dst = get_cgal_empty_obj<T_DST>();
|
||
|
|
auto_rel.set(dst, free_mg_obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
// T_SRC : Geometry::GePolygonXd
|
||
|
|
// T_DST : _cgal::PolygonXd
|
||
|
|
template <class T_SRC, class T_DST>
|
||
|
|
T_DST get_cgal_polygon(const T_SRC &holds)
|
||
|
|
{
|
||
|
|
T_DST out;
|
||
|
|
::memset(&out, 0, sizeof(T_DST));
|
||
|
|
vector_arr(holds.vertexs, out.vertices);
|
||
|
|
return out;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T_SRC, class T_DST>
|
||
|
|
void get_cgal_polygon(const T_SRC &holds, auto_release<T_DST> &auto_rel)
|
||
|
|
{
|
||
|
|
T_DST out = get_cgal_polygon<T_SRC, T_DST>(holds);
|
||
|
|
auto_rel.set(out, free_local_obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
// T_SRC : AcGePoint3d (GePolyArray3d)
|
||
|
|
// T_DST : _cgal::PolygonXdList
|
||
|
|
template <class T_SRC, class T_DST>
|
||
|
|
_cgal::CgalArray<T_DST> get_cgal_polygonArr(const std::vector<std::vector<T_SRC>> &holds)
|
||
|
|
{
|
||
|
|
_cgal::CgalArray<T_DST> out;
|
||
|
|
out.count = (int)holds.size();
|
||
|
|
out.pData = NULL;
|
||
|
|
if (out.count > 0)
|
||
|
|
{
|
||
|
|
out.pData = new T_DST[out.count]();
|
||
|
|
for (int i(0); i < out.count; ++i)
|
||
|
|
vector_arr(holds[i], out.pData[i].vertices);
|
||
|
|
}
|
||
|
|
return out;
|
||
|
|
}
|
||
|
|
|
||
|
|
// T_SRC : AcGePoint3d (GePolyArray3d)
|
||
|
|
// T_DST : _cgal::PolygonXdList
|
||
|
|
template <class T_SRC, class T_DST>
|
||
|
|
void get_cgal_polygonArr(const std::vector<std::vector<T_SRC>> &holds, auto_release<_cgal::CgalArray<T_DST>> &auto_rel)
|
||
|
|
{
|
||
|
|
_cgal::CgalArray<T_DST> out = get_cgal_polygonArr<T_SRC, T_DST>(holds);
|
||
|
|
auto_rel.set(out, free_local_obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T_SRC, class T_DST>
|
||
|
|
_cgal::CgalArray<T_DST> get_cgal_polygonList(const std::vector<T_SRC> &src)
|
||
|
|
{
|
||
|
|
_cgal::CgalArray<T_DST> out;
|
||
|
|
out.count = (int)src.size();
|
||
|
|
out.pData = NULL;
|
||
|
|
if (out.count > 0)
|
||
|
|
{
|
||
|
|
out.pData = new T_DST[out.count]();
|
||
|
|
for (int i(0); i < out.count; ++i)
|
||
|
|
out.pData[i] = get_cgal_polygon<T_SRC, T_DST>(src[i]);
|
||
|
|
}
|
||
|
|
return out;
|
||
|
|
}
|
||
|
|
|
||
|
|
void get_cgal_pwh2d(const Geometry::GePwh2d &src, auto_release<_cgal::Pwh2d> &auto_rel)
|
||
|
|
{
|
||
|
|
_cgal::Pwh2d pwh;
|
||
|
|
pwh.outer_boundary = get_cgal_polygon<Geometry::GePolygon2d, _cgal::Polygon2d>(src.outer_boundary);
|
||
|
|
pwh.inner_holes = get_cgal_polygonList<Geometry::GePolygon2d, _cgal::Polygon2d>(src.inner_holes);
|
||
|
|
auto_rel.set(pwh, free_local_obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
namespace Geometry
|
||
|
|
{
|
||
|
|
void delaunayTriangulationMesh(const GePoint3dArray &arPts
|
||
|
|
, AcGePoint3dArray &vertexArray
|
||
|
|
, AcArray<Adesk::Int32> &faceArray)
|
||
|
|
{
|
||
|
|
GePolyArray3d holds;
|
||
|
|
delaunayTriangulationMeshWithHolds(arPts, holds, vertexArray, faceArray);
|
||
|
|
}
|
||
|
|
|
||
|
|
void delaunayTriangulationMeshWithHolds(const GePoint3dArray &arPts
|
||
|
|
, const GePolyArray3d &holds
|
||
|
|
, AcGePoint3dArray &vertexArray
|
||
|
|
, AcArray<Adesk::Int32> &faceArray)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pt3dArr> _arpts;
|
||
|
|
get_cgal_ptArr<AcGePoint3d, _cgal::Pt3d>(arPts, _arpts);
|
||
|
|
|
||
|
|
auto_release<_cgal::Polygon3dList> _holds;
|
||
|
|
get_cgal_polygonArr<AcGePoint3d, _cgal::Polygon3d>(holds, _holds);
|
||
|
|
|
||
|
|
auto_release<_cgal::Pt3dArr> _vecties;
|
||
|
|
get_cgal_empty_obj(_vecties);
|
||
|
|
|
||
|
|
auto_release<_cgal::IntArray> _faces;
|
||
|
|
get_cgal_empty_obj(_faces);
|
||
|
|
|
||
|
|
|
||
|
|
mg_cgal_delaunayTriangulationMeshWithHolds(_arpts.get(), _holds.get(), _vecties.get(), _faces.get());
|
||
|
|
|
||
|
|
AcGePoint3d pt3d;
|
||
|
|
for (int i(0); i < _vecties.get().count; ++i)
|
||
|
|
{
|
||
|
|
pt_copy(_vecties.get().pData[i], pt3d);
|
||
|
|
vertexArray.append(pt3d);
|
||
|
|
}
|
||
|
|
|
||
|
|
faceArray.setLogicalLength(_faces.get().count);
|
||
|
|
::memcpy(faceArray.asArrayPtr(), _faces.get().pData, _faces.get().count * sizeof(int));
|
||
|
|
}
|
||
|
|
|
||
|
|
void calcConvexHull2D(const GePoint2dArray & arPts, GePoint2dArray & poly)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pt2dArr> _arPts, _poly;
|
||
|
|
get_cgal_ptArr<AcGePoint2d, _cgal::Pt2d>(arPts, _arPts);
|
||
|
|
get_cgal_empty_obj(_poly);
|
||
|
|
|
||
|
|
mg_cgal_calcConvexHull2D_2d_2d(_arPts.get(), _poly.get());
|
||
|
|
|
||
|
|
arr_vector(_poly.get(), poly);
|
||
|
|
}
|
||
|
|
|
||
|
|
void calcConvexHull2D(const GePoint3dArray &arPts, GePoint2dArray &poly)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pt3dArr> _arPts;
|
||
|
|
get_cgal_ptArr<AcGePoint3d, _cgal::Pt3d>(arPts, _arPts);
|
||
|
|
|
||
|
|
auto_release<_cgal::Pt2dArr> _poly;
|
||
|
|
get_cgal_empty_obj(_poly);
|
||
|
|
|
||
|
|
mg_cgal_calcConvexHull2D_3d_2d(_arPts.get(), _poly.get());
|
||
|
|
|
||
|
|
arr_vector(_poly.get(), poly);
|
||
|
|
}
|
||
|
|
|
||
|
|
void calcConvexHull2D(const GePoint3dArray &arPts, GePoint3dArray &poly)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pt3dArr> _arPts;
|
||
|
|
get_cgal_ptArr<AcGePoint3d, _cgal::Pt3d>(arPts, _arPts);
|
||
|
|
|
||
|
|
auto_release<_cgal::Pt3dArr> _poly;
|
||
|
|
get_cgal_empty_obj(_poly);
|
||
|
|
|
||
|
|
mg_cgal_calcConvexHull2D_3d_3d(_arPts.get(), _poly.get());
|
||
|
|
|
||
|
|
arr_vector(_poly.get(), poly);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool is_vaild_polygon(const GePwh2d &geP)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pwh2d> _geP;
|
||
|
|
get_cgal_pwh2d(geP, _geP);
|
||
|
|
return mg_cgal_is_vaild_polygon_with_hole(_geP.get());
|
||
|
|
}
|
||
|
|
|
||
|
|
bool is_vaild_polygon(const GePolygon2d & geP)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Polygon2d> _geP;
|
||
|
|
get_cgal_polygon<GePolygon2d, _cgal::Polygon2d>(geP, _geP);
|
||
|
|
return mg_cgal_is_vaild_polygon(_geP.get());
|
||
|
|
}
|
||
|
|
|
||
|
|
bool is_intersect(const GePwh2d &geP, const GePwh2d &geQ)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pwh2d> _geP, _geQ;
|
||
|
|
get_cgal_pwh2d(geP, _geP);
|
||
|
|
get_cgal_pwh2d(geQ, _geQ);
|
||
|
|
return mg_cgal_is_intersect(_geP.get(), _geQ.get());
|
||
|
|
}
|
||
|
|
|
||
|
|
void intersect(const GePwh2d &geP
|
||
|
|
, const GePwh2d &geQ
|
||
|
|
, GePwh2dList &gepwhlst)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pwh2d> _geP, _geQ;
|
||
|
|
get_cgal_pwh2d(geP, _geP);
|
||
|
|
get_cgal_pwh2d(geQ, _geQ);
|
||
|
|
|
||
|
|
auto_release<_cgal::Pwh2dList> _gepwhlst;
|
||
|
|
get_cgal_empty_obj<_cgal::Pwh2dList>(_gepwhlst);
|
||
|
|
|
||
|
|
mg_cgal_intersect(_geP.get(), _geQ.get(), _gepwhlst.get());
|
||
|
|
|
||
|
|
pwh_gePwh(_gepwhlst.get(), gepwhlst);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool join( const GePwh2d &geP
|
||
|
|
, const GePwh2d &geQ
|
||
|
|
, GePwh2d &gepwh)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pwh2d> _geP, _geQ;
|
||
|
|
get_cgal_pwh2d(geP, _geP);
|
||
|
|
get_cgal_pwh2d(geQ, _geQ);
|
||
|
|
|
||
|
|
auto_release<_cgal::Pwh2d> _gepwh;
|
||
|
|
get_cgal_empty_obj<_cgal::Pwh2d>(_gepwh);
|
||
|
|
|
||
|
|
bool brel = mg_cgal_join(_geP.get(), _geQ.get(), _gepwh.get());
|
||
|
|
|
||
|
|
pwh_gePwh(_gepwh.get(), gepwh);
|
||
|
|
|
||
|
|
return brel;
|
||
|
|
}
|
||
|
|
|
||
|
|
void difference( const GePwh2d &geP
|
||
|
|
, const GePwh2d &geQ
|
||
|
|
, GePwh2dList &gepwhlst)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pwh2d> _geP, _geQ;
|
||
|
|
get_cgal_pwh2d(geP, _geP);
|
||
|
|
get_cgal_pwh2d(geQ, _geQ);
|
||
|
|
|
||
|
|
auto_release<_cgal::Pwh2dList> _gepwhlst;
|
||
|
|
get_cgal_empty_obj<_cgal::Pwh2dList>(_gepwhlst);
|
||
|
|
|
||
|
|
mg_cgal_difference(_geP.get(), _geQ.get(), _gepwhlst.get());
|
||
|
|
pwh_gePwh(_gepwhlst.get(), gepwhlst);
|
||
|
|
}
|
||
|
|
|
||
|
|
void symmetric_difference( const GePwh2d &geP
|
||
|
|
, const GePwh2d &geQ
|
||
|
|
, GePwh2dList &gepwhlst)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pwh2d> _geP, _geQ;
|
||
|
|
get_cgal_pwh2d(geP, _geP);
|
||
|
|
get_cgal_pwh2d(geQ, _geQ);
|
||
|
|
|
||
|
|
auto_release<_cgal::Pwh2dList> _gepwhlst;
|
||
|
|
get_cgal_empty_obj<_cgal::Pwh2dList>(_gepwhlst);
|
||
|
|
|
||
|
|
mg_cgal_symmetric_difference(_geP.get(), _geQ.get(), _gepwhlst.get());
|
||
|
|
|
||
|
|
pwh_gePwh(_gepwhlst.get(), gepwhlst);
|
||
|
|
}
|
||
|
|
|
||
|
|
Geometry::Bounded_side boundary_check(const AcGePoint2d & pt, const GePwh2d & gepwh)
|
||
|
|
{
|
||
|
|
_cgal::Pt2d _pt;
|
||
|
|
pt_copy(pt, _pt);
|
||
|
|
auto_release<_cgal::Pwh2d> _gepwh;
|
||
|
|
get_cgal_pwh2d(gepwh, _gepwh);
|
||
|
|
return (Geometry::Bounded_side)mg_cgal_boundary_check(_pt, _gepwh.get());
|
||
|
|
}
|
||
|
|
|
||
|
|
bool is_counterclockwise(const GePwh2d & P)
|
||
|
|
{
|
||
|
|
auto_release<_cgal::Pwh2d> _P;
|
||
|
|
get_cgal_pwh2d(P, _P);
|
||
|
|
return mg_cgal_is_counterclockwise_with_hole(_P.get());
|
||
|
|
}
|
||
|
|
|
||
|
|
bool is_counterclockwise(const AcGePoint2d &ptS
|
||
|
|
, const AcGePoint2d &ptM
|
||
|
|
, const AcGePoint2d &ptE )
|
||
|
|
{
|
||
|
|
_cgal::Pt2d _ptS, _ptM, _ptE;
|
||
|
|
pt_copy(ptS, _ptS);
|
||
|
|
pt_copy(ptM, _ptM);
|
||
|
|
pt_copy(ptE, _ptE);
|
||
|
|
return mg_cgal_is_counterclockwise(_ptS, _ptM, _ptE);
|
||
|
|
}
|
||
|
|
|
||
|
|
void convexHull2d(const AcGePoint2dArray &input, AcGePoint2dArray &output)
|
||
|
|
{
|
||
|
|
GePoint2dArray arIn(input.length());
|
||
|
|
::memcpy(&(*arIn.begin()), input.asArrayPtr(), input.length() * sizeof(AcGePoint2d));
|
||
|
|
|
||
|
|
auto_release<_cgal::Pt2dArr> _input, _out;
|
||
|
|
get_cgal_ptArr<AcGePoint2d, _cgal::Pt2d>(arIn, _input);
|
||
|
|
get_cgal_empty_obj(_out);
|
||
|
|
|
||
|
|
mg_cgal_convexHull2d(_input.get(), _out.get());
|
||
|
|
|
||
|
|
output.setLogicalLength(_out.get().count);
|
||
|
|
::memcpy(output.asArrayPtr(), _out.get().pData, _out.get().count * sizeof(AcGePoint2d));
|
||
|
|
}
|
||
|
|
}
|