Openmesh函数库设计及与CGAL的对比

#include<CGAL/Simple_cartesian.h>
#include<CGAL/Polyhedron_3.h>
#include<iostream>

typedefCGAL::Simple_cartesian<double>Kernel;
typedefKernel::Point_3Point_3;
typedefCGAL::Polyhedron_3<Kernel>Polyhedron;
typedefPolyhedron::Vertex_iteratorVertex_iterator;

intmain(){
Point_3p(1.0,0.0,0.0);
Point_3q(0.0,1.0,0.0);
Point_3r(0.0,0.0,1.0);
Point_3s(0.0,0.0,0.0);

PolyhedronP;
P.make_tetrahedron(p,q,r,s);
CGAL::set_ascii_mode(std::cout);
for(Vertex_iteratorv=P.vertices_begin();v!=P.vertices_end();++v)
std::cout<<v->point()<<std::endl;
return0;
}

typedefCGAL::Polyhedron_3<Traits,
CGAL::Polyhedron_items_3,
CGAL::HalfedgeDS_default>Polyhedron;

#include<CGAL/Cartesian.h>
#include<CGAL/HalfedgeDS_vector.h>
#include<CGAL/Polyhedron_3.h>
#include<iostream>

typedefCGAL::Cartesian<double>Kernel;//CGAL用Traits(Kernel)表示采用的数据精度类型如这里的Cartesian<double>

typedefKernel::Point_3Point_3;
typedefCGAL::Polyhedron_3<Kernel,
CGAL::Polyhedron_items_3,
CGAL::HalfedgeDS_vector>Polyhedron;//使用基于vector实现的半边结构

intmain(){
Point_3p(1.0,0.0,0.0);
Point_3q(0.0,1.0,0.0);
Point_3r(0.0,0.0,1.0);
Point_3s(0.0,0.0,0.0);

PolyhedronP;//alternativeconstructor:PolyhedronP(4,12,4);
P.make_tetrahedron(p,q,r,s);
CGAL::set_ascii_mode(std::cout);
std::copy(P.points_begin(),P.points_end(),
	std::ostream_iterator<Point_3>(std::cout,"\n"));
return0;
}

#include<CGAL/Simple_cartesian.h>
#include<CGAL/IO/Color.h>
#include<CGAL/Polyhedron_3.h>

//Afacetypewithacolormembervariable.
template<classRefs>
structMy_face:publicCGAL::HalfedgeDS_face_base<Refs>{
CGAL::Colorcolor;
};

//Anitemstypeusingmyface.
structMy_items:publicCGAL::Polyhedron_items_3{
template<classRefs,classTraits>
structFace_wrapper{
typedefMy_face<Refs>Face;
};
};

typedefCGAL::Simple_cartesian<double>Kernel;
typedefCGAL::Polyhedron_3<Kernel,My_items>Polyhedron;
typedefPolyhedron::Halfedge_handleHalfedge_handle;

intmain(){
PolyhedronP;
Halfedge_handleh=P.make_tetrahedron();
h->facet()->color=CGAL::RED;
return0;
}

openmesh,的设计

Openmesh中的接口：

typedefOpenMesh::PolyMesh_ArrayKernelT<>MyMesh;

使用默认的三角网格，arraybased

typedefOpenMesh::TriMesh_ArrayKernelT<>MyMesh;

//Definemypersonaltraits
structMyTraits:OpenMesh::DefaultTraits
{
//LetPointandNormalbeavectorofdoubles
typedefOpenMesh::Vec3dPoint;//Point的类型被定义为3维double类型
typedefOpenMesh::Vec3dNormal;

//AlreadydefinedinOpenMesh::DefaultTraits
//HalfedgeAttributes(OpenMesh::Attributes::PrevHalfedge);
//UncommentnextlinetodisableattributePrevHalfedge
//HalfedgeAttributes(OpenMesh::Attributes::None);
//
//or
//
//HalfedgeAttributes(0);
};

#endif

//Definemymeshwiththenewtraits!
typedefOpenMesh::TriMesh_ArrayKernelT<MyTraits>MyMesh;

//------------------------------------------------------------------main----

MyMeshmesh;

//Justmakesurethatpointelementtypeisdouble
if(typeid(OpenMesh::vector_traits<MyMesh::Point>::value_type)
!=typeid(double))
{
std::cerr<<"Ouch!ERROR!Datatypeiswrong!\n";
return1;
}

//另外一个例子

structMyTraits:publicOpenMesh::DefaultTraits
{
//storebarycenterofneighborsinthismember
VertexTraits
{
private:
Pointcog_;
public:

VertexT():cog_(Point(0.0f,0.0f,0.0f)){}

constPoint&cog()const{returncog_;}
voidset_cog(constPoint&_p){cog_=_p;}
};
};

#endif

typedefOpenMesh::TriMesh_ArrayKernelT<MyTraits>MyMesh;
typedefOpenMesh::TriMesh_ArrayKernelT<>MyMesh2;

注意和CGAL的不同这里用户自定义traits更加简单友好，没有任何的模板参数。

以前旧版本的openmesh里面的vertex还要写成下面的形式，有模板参数，那么现在这个是如何实现的呢？

template<classBase>classVertexT:publicBase

///DefinitionofmeshitemsforuseintheArrayKernel
structArrayItems
{

//------------------------------------------------------internalvertextype

///Thevertexitem
classVertex
{
friendclassArrayKernel;
HalfedgeHandlehalfedge_handle_;
};

//----------------------------------------------------internalhalfedgetype

#ifndefDOXY_IGNORE_THIS
classHalfedge_without_prev
{
friendclassArrayKernel;
FaceHandleface_handle_;
VertexHandlevertex_handle_;
HalfedgeHandlenext_halfedge_handle_;
};
#endif

#ifndefDOXY_IGNORE_THIS
classHalfedge_with_prev:publicHalfedge_without_prev
{
friendclassArrayKernel;
HalfedgeHandleprev_halfedge_handle_;
};
#endif

//TODO:shouldbeselectedwithconfig.hdefine
typedefHalfedge_with_prevHalfedge;
typedefGenProg::Bool2Type<true>HasPrevHalfedge;

//--------------------------------------------------------internaledgetype
#ifndefDOXY_IGNORE_THIS
classEdge
{
friendclassArrayKernel;
Halfedgehalfedges_[2];
};
#endif

//--------------------------------------------------------internalfacetype
#ifndefDOXY_IGNORE_THIS
classFace
{
friendclassArrayKernel;
HalfedgeHandlehalfedge_handle_;
};
};

classBaseHandle;

///Handleforavertexentity
structVertexHandle:publicBaseHandle
{
explicitVertexHandle(int_idx=-1):BaseHandle(_idx){}
};

///Handleforahalfedgeentity
structHalfedgeHandle:publicBaseHandle
{
explicitHalfedgeHandle(int_idx=-1):BaseHandle(_idx){}
};

///Handleforaedgeentity
structEdgeHandle:publicBaseHandle
{
explicitEdgeHandle(int_idx=-1):BaseHandle(_idx){}
};

///Handleforafaceentity
structFaceHandle:publicBaseHandle
{
explicitFaceHandle(int_idx=-1):BaseHandle(_idx){}
};

//一个具体的kernel如何定义的呢

classArrayKernel:publicBaseKernel,publicArrayItems
{
public:

//handles
typedefOpenMesh::VertexHandleVertexHandle;
typedefOpenMesh::HalfedgeHandleHalfedgeHandle;
typedefOpenMesh::EdgeHandleEdgeHandle;
typedefOpenMesh::FaceHandleFaceHandle;
typedefAttributes::StatusInfoStatusInfo;
typedefVPropHandleT<StatusInfo>VertexStatusPropertyHandle;
typedefHPropHandleT<StatusInfo>HalfedgeStatusPropertyHandle;
typedefEPropHandleT<StatusInfo>EdgeStatusPropertyHandle;
typedefFPropHandleT<StatusInfo>FaceStatusPropertyHandle;

HalfedgeHandleopposite_halfedge_handle(HalfedgeHandle_heh)const
{returnHalfedgeHandle((_heh.idx()&1)?_heh.idx()-1:_heh.idx()+1);}

private:
//iterators
typedefstd::vector<Vertex>VertexContainer;
typedefstd::vector<Edge>EdgeContainer;
typedefstd::vector<Face>FaceContainer;
typedefVertexContainer::iteratorKernelVertexIter;
typedefVertexContainer::const_iteratorKernelConstVertexIter;
typedefEdgeContainer::iteratorKernelEdgeIter;
typedefEdgeContainer::const_iteratorKernelConstEdgeIter;
typedefFaceContainer::iteratorKernelFaceIter;
typedefFaceContainer::const_iteratorKernelConstFaceIter;
typedefstd::vector<uint>BitMaskContainer;

KernelVertexItervertices_begin(){returnvertices_.begin();}
KernelConstVertexItervertices_begin()const{returnvertices_.begin();}
KernelVertexItervertices_end(){returnvertices_.end();}
KernelConstVertexItervertices_end()const{returnvertices_.end();}

KernelEdgeIteredges_begin(){returnedges_.begin();}
KernelConstEdgeIteredges_begin()const{returnedges_.begin();}
KernelEdgeIteredges_end(){returnedges_.end();}
KernelConstEdgeIteredges_end()const{returnedges_.end();}

KernelFaceIterfaces_begin(){returnfaces_.begin();}
KernelConstFaceIterfaces_begin()const{returnfaces_.begin();}
KernelFaceIterfaces_end(){returnfaces_.end();}
KernelConstFaceIterfaces_end()const{returnfaces_.end();}

private:
VertexContainervertices_;
EdgeContaineredges_;
FaceContainerfaces_;

MyMesh::VertexIterv_it

v_it->cog()//旧版本

//新版本要用mesh.data(v_it)->cog()//看了一版本变化说明，似乎是说因为MS不支持模版的前置循环声明好像，不得已为之的。

我们看下为了实现下面的应用代码，程序内部是怎么构架的。

应用代码：

structMyTraits:publicOpenMesh::DefaultTraits
{
//storebarycenterofneighborsinthismember
VertexTraits
{
private:
Pointcog_;
public:

VertexT():cog_(Point(0.0f,0.0f,0.0f)){}

constPoint&cog()const{returncog_;}
voidset_cog(constPoint&_p){cog_=_p;}
};
};

#endif

typedefOpenMesh::TriMesh_ArrayKernelT<MyTraits>MyMesh;//下面就可以MyMeshmesh;使用这个mesh了。

structDefaultTraits
{
///ThedefaultcoordinatetypeisOpenMesh::Vec3f.
typedefVec3fPoint;

///ThedefaultnormaltypeisOpenMesh::Vec3f.
typedefVec3fNormal;
…
#ifndefDOXY_IGNORE_THIS
VertexTraits{};
HalfedgeTraits{};
EdgeTraits{};
FaceTraits{};
#endif
VertexAttributes(0);
…

};

///Macrofordefiningthevertextraits.See\refmesh_type.
#defineVertexTraits\
template<classBase,classRefs>structVertexT:publicBase//其余Tratis如face,halfedge的一样的方式处理

所以实际代码展开之后类似下面

structMyTraits:publicOpenMesh::DefaultTraits
{
template<classBase,classRefs>structVertexT:publicBase
{
intsome_additional_index;
};
};

ThetemplateargumentBaseprovidesaccesstothemeshhandlesandtothePointandScalartypebyitsmemberclassRefs.

AddingaMyMesh::FaceHandletothevertexclasscanthereforebeimplementedlikethis:

下面显示如何给顶点添加面handle属性。
structMyTraits:publicOpenMesh::DefaultTraits
{
VertexTraits
{
intsome_additional_index;
typenameBase::Refs::FaceHandlemy_face_handle;
};
};

template<classTraits,boolIsTriMesh>
structFinalMeshItemsT
{
structRefs
{
typedeftypenameTraits::PointPoint;//所以用户提供的MyTraits可能会改变Point的类型
typedeftypenamevector_traits<Point>::value_typeScalar;
…
typedefOpenMesh::VertexHandleVertexHandle;
…

};
//---exportRefstypes---
typedeftypenameRefs::PointPoint;
…

classITraits
{};

typedeftypenameTraits::templateVertexT<ITraits,Refs>VertexData;//这里用到了VertexT（可能由用户修改提供）
typedeftypenameTraits::templateHalfedgeT<ITraits,Refs>HalfedgeData;
…

};
}//namespaceOpenMesh

template<classMeshItems,classConnectivity>
classAttribKernelT:publicConnectivity//classTriConnectivity:publicPolyConnectivity

{//classPolyConnectivity:publicArrayKernel

public:

//----------------------------------------------------------------itemtypes

typedeftypenameConnectivity::VertexVertex;
typedeftypenameConnectivity::HalfedgeHalfedge;
typedeftypenameConnectivity::EdgeEdge;
typedeftypenameConnectivity::FaceFace;

typedeftypenameMeshItems::PointPoint;
typedeftypenameMeshItems::NormalNormal;
…
typedeftypenameMeshItems::VertexDataVertexData;
typedeftypenameMeshItems::HalfedgeDataHalfedgeData;
typedeftypenameMeshItems::EdgeDataEdgeData;
typedeftypenameMeshItems::FaceDataFaceData;

typedefAttribKernelT<MeshItems,Connectivity>AttribKernel;

enumAttribs{
VAttribs=MeshItems::VAttribs,
HAttribs=MeshItems::HAttribs,
EAttribs=MeshItems::EAttribs,
FAttribs=MeshItems::FAttribs
};

typedefVPropHandleT<VertexData>DataVPropHandle;
typedefHPropHandleT<HalfedgeData>DataHPropHandle;
typedefEPropHandleT<EdgeData>DataEPropHandle;
typedefFPropHandleT<FaceData>DataFPropHandle;

public:

//--------------------------------------------------constructor/destructor

AttribKernelT()
:refcount_vnormals_(0),
refcount_vcolors_(0),
…

{
add_property(points_,"v:points");

if(VAttribs&Attributes::Normal)
request_vertex_normals();
…
//FIXME:datapropertiesmightactuallycoststorageeven
//iftherearenodatatraits??
add_property(data_vpph_);
add_property(data_fpph_);
add_property(data_hpph_);
add_property(data_epph_);
}

virtual~AttribKernelT()
{
//shouldremoveproperties,butthiswillbedonein
//BaseKernel'sdestructoranyway...
}

/**Assignmentfromanothermeshof\emanothertype.
\noteAllthat'scopiedisconnectivityandvertexpositions.
Allotherinformation(likee.g.attributesoradditional
elementsfromtraitsclasses)isnotcopied.
\noteIfyouwanttocopyallinformation,including*custom*properties,
usePolyMeshT::operator=()instead.
TODO:versionwhichcopiesstandardpropertiesspecifiedbytheuser
*/
template<class_AttribKernel>
voidassign(const_AttribKernel&_other)
{
assign_connectivity(_other);
for(typenameConnectivity::VertexIterv_it=Connectivity::vertices_begin();
v_it!=Connectivity::vertices_end();++v_it)
{//assumesPointconstructorsupportscastfrom_AttribKernel::Point
set_point(v_it,(Point)_other.point(v_it));
}
}
…
//------------------------------------------------request/allocproperties

voidrequest_vertex_normals()
{
if(!refcount_vnormals_++)
add_property(vertex_normals_,"v:normals");
}

…
//-------------------------------------------------release/freeproperties

voidrelease_vertex_normals()
{
if((refcount_vnormals_>0)&&(!--refcount_vnormals_))
remove_property(vertex_normals_);
}

….
//----------------------------------------------dynamiccheckforproperties

boolhas_vertex_normals()const{returnvertex_normals_.is_valid();}
…

public:

typedefVPropHandleT<Point>PointsPropertyHandle;
typedefVPropHandleT<Normal>VertexNormalsPropertyHandle;
…
public:
//standardvertexproperties
PointsPropertyHandlepoints_pph()const
{returnpoints_;}
…
VertexData&data(VertexHandle_vh)
{returnproperty(data_vpph_,_vh);}

…
private:
//standardvertexproperties
PointsPropertyHandlepoints_;
VertexNormalsPropertyHandlevertex_normals_;
…

//datapropertieshandles
DataVPropHandledata_vpph_;
DataHPropHandledata_hpph_;
DataEPropHandledata_epph_;
DataFPropHandledata_fpph_;

…
};

template<classT>
voidadd_property(VPropHandleT<T>&_ph,conststd::string&_name="<vprop>")
{
_ph=VPropHandleT<T>(vprops_.add(T(),_name));
vprops_.resize(n_vertices());//inBaseKernelPropertyContainervprops_;
}

classArrayKernel:publicBaseKernel,publicArrayItems
{
public:

//handles
typedefOpenMesh::VertexHandleVertexHandle;
typedefOpenMesh::HalfedgeHandleHalfedgeHandle;
typedefOpenMesh::EdgeHandleEdgeHandle;
typedefOpenMesh::FaceHandleFaceHandle;

typedefstd::vector<Vertex>VertexContainer;

Vertex&vertex(VertexHandle_vh)
{
assert(is_valid_handle(_vh));
returnvertices_[_vh.idx()];
}
private:
VertexContainervertices_;
EdgeContaineredges_;
FaceContainerfaces_;
}

classBaseKernel
{
private:
PropertyContainervprops_;
PropertyContainerhprops_;
PropertyContainereprops_;
PropertyContainerfprops_;
PropertyContainermprops_;
};

template<classKernel>
classTriMeshT:publicPolyMeshT<Kernel>
{
public:
//self
typedefTriMeshT<Kernel>This;
typedefPolyMeshT<Kernel>PolyMesh;

//---items---
typedeftypenamePolyMesh::ScalarScalar;
typedeftypenamePolyMesh::PointPoint;
…
//---handles---
typedeftypenamePolyMesh::VertexHandleVertexHandle;
typedeftypenamePolyMesh::HalfedgeHandleHalfedgeHandle;
typedeftypenamePolyMesh::EdgeHandleEdgeHandle;
typedeftypenamePolyMesh::FaceHandleFaceHandle;

//---iterators---
typedeftypenamePolyMesh::VertexIterVertexIter;
…
//---circulators---
typedeftypenamePolyMesh::VertexVertexIterVertexVertexIter;
…

}