Half-edge representation, CGAL vs OpenMesh

classic Classic list List threaded Threaded
7 messages Options
Reply | Threaded
Open this post in threaded view
|

Half-edge representation, CGAL vs OpenMesh

Nicholas Mario Wardhana
Hi all,

I am planning to use the half edge data structure in my research,
especially for edge-to-face traversal and edge iteration about a
vertex, and I found that the representation and the operations are
readily implemented in CGAL and OpenMesh, e.g. via their respective
circulators. Anybody has done a comparison between the two? So far I
found that in a related paper
(http://www.graphics.rwth-aachen.de/uploads/media/openmesh.pdf),
OpenMesh boasts its efficient handling of dynamic structure, which
CGAL does not seem to accommodate, but this paper is quite old
(published in 2002). On the other hand, CGAL's polyhedron tutorial
(http://www.cgal.org/Tutorials/Polyhedron/tutorial.pdf) only mentions
that the √3-subdivision is faster in CGAL, but I do not need this
feature. Googling and digging up the archives do not really help.

I am better-acquainted to CGAL, so this is one advantage to me,
whereas I only recently know OpenMesh. Nevertheless, I will consider
the trade-off between the two libraries.

By the way, please correct me if I make any mistake here.

Thank you!

Best regards,
Nicholas Mario Wardhana

--
You are currently subscribed to cgal-discuss.
To unsubscribe or access the archives, go to
https://lists-sop.inria.fr/wws/info/cgal-discuss

Reply | Threaded
Open this post in threaded view
|

Re: Half-edge representation, CGAL vs OpenMesh

Nicholas Mario Wardhana
I made a mistake in my previous e-mail.

> I am planning to use the half edge data structure in my research,
> especially for edge-to-face traversal and edge iteration about a
> vertex,

That should have been "and face iteration about a vertex".

Thank you.

Best regards,
Nicholas Mario Wardhana

--
You are currently subscribed to cgal-discuss.
To unsubscribe or access the archives, go to
https://lists-sop.inria.fr/wws/info/cgal-discuss

Reply | Threaded
Open this post in threaded view
|

Re: Half-edge representation, CGAL vs OpenMesh

Pierre Alliez-2
In reply to this post by Nicholas Mario Wardhana
dear Nicholas,

openmesh is less generic but easy when dealing with many attributes.
although you can use boost property map with CGAL.

tell us more the algorithms you plan to use/implement, ok?

pierre


Le 05/01/2011 13:06, Nicholas Mario Wardhana a écrit :

> Hi all,
>
> I am planning to use the half edge data structure in my research,
> especially for edge-to-face traversal and edge iteration about a
> vertex, and I found that the representation and the operations are
> readily implemented in CGAL and OpenMesh, e.g. via their respective
> circulators. Anybody has done a comparison between the two? So far I
> found that in a related paper
> (http://www.graphics.rwth-aachen.de/uploads/media/openmesh.pdf),
> OpenMesh boasts its efficient handling of dynamic structure, which
> CGAL does not seem to accommodate, but this paper is quite old
> (published in 2002). On the other hand, CGAL's polyhedron tutorial
> (http://www.cgal.org/Tutorials/Polyhedron/tutorial.pdf) only mentions
> that the √3-subdivision is faster in CGAL, but I do not need this
> feature. Googling and digging up the archives do not really help.
>
> I am better-acquainted to CGAL, so this is one advantage to me,
> whereas I only recently know OpenMesh. Nevertheless, I will consider
> the trade-off between the two libraries.
>
> By the way, please correct me if I make any mistake here.
>
> Thank you!
>
> Best regards,
> Nicholas Mario Wardhana
>


--
Pierre Alliez
INRIA Sophia Antipolis - Mediterranee
http://www-sop.inria.fr/members/Pierre.Alliez/


--
You are currently subscribed to cgal-discuss.
To unsubscribe or access the archives, go to
https://lists-sop.inria.fr/wws/info/cgal-discuss

Reply | Threaded
Open this post in threaded view
|

Re: Half-edge representation, CGAL vs OpenMesh

Nicholas Mario Wardhana
On 12 January 2011 22:01, Pierre Alliez <[hidden email]> wrote:

> dear Nicholas,
>
> openmesh is less generic but easy when dealing with many attributes.
> although you can use boost property map with CGAL.
>
> tell us more the algorithms you plan to use/implement, ok?
>
> pierre
>
>

Hi Pierre,

Thank you for your reply. However, I'm sorry to say that we abandoned
this idea. In our project, we were originally planning to find the
intersection of polyhedra, which are represented in their half-edges,
but we discarded this idea and use different approach. We are making
our own data structure, as it is simpler to do.

Best regards,
Nicholas Mario Wardhana

--
You are currently subscribed to cgal-discuss.
To unsubscribe or access the archives, go to
https://lists-sop.inria.fr/wws/info/cgal-discuss

Reply | Threaded
Open this post in threaded view
|

Re: Half-edge representation, CGAL vs OpenMesh

Sebastien Loriot (GeometryFactory)
Nicholas Mario Wardhana wrote:

> On 12 January 2011 22:01, Pierre Alliez <[hidden email]> wrote:
>> dear Nicholas,
>>
>> openmesh is less generic but easy when dealing with many attributes.
>> although you can use boost property map with CGAL.
>>
>> tell us more the algorithms you plan to use/implement, ok?
>>
>> pierre
>>
>>
>
> Hi Pierre,
>
> Thank you for your reply. However, I'm sorry to say that we abandoned
> this idea. In our project, we were originally planning to find the
> intersection of polyhedra, which are represented in their half-edges,
> but we discarded this idea and use different approach. We are making
> our own data structure, as it is simpler to do.
>
I am quite surprised by your answer. What are the limitation of the
existing data structures?



> Best regards,
> Nicholas Mario Wardhana
>


--
You are currently subscribed to cgal-discuss.
To unsubscribe or access the archives, go to
https://lists-sop.inria.fr/wws/info/cgal-discuss

Reply | Threaded
Open this post in threaded view
|

Re: Half-edge representation, CGAL vs OpenMesh

Nicholas Mario Wardhana
On 13 January 2011 15:01, Sebastien Loriot (GeometryFactory)
<[hidden email]> wrote:
> I am quite surprised by your answer. What are the limitation of the
> existing data structures?
>

Hi Sebastien,

What we abandon is the idea of using half-edge representation.
Previously we were about to implement a method to compute the
intersections of some polyhedra, which are represented by their
half-edges. However, after our recent internal discussion, it turned
out that our previous method was too complicated, so we are trying
different approach. So far face-vertex (FV) representation is enough
for this purpose, and we are not sure whether either CGAL or OpenMesh
directly supports it. For CGAL, we can't find a class like polygon in
3D space to represent the face, and I suppose the face classes in both
CGAL and OpenMesh (HalfedgeDS<Traits,Items,Alloc>::Face in CGAL and
OpenMesh::PolyMeshT<Kernel> in OpenMesh, although I am not really sure
about the latter) are quite closely related to half-edge structure
(please correct me if I am wrong), so currently we develop our simple
FV data structure.

My apology if I did not make myself clearly enough in the previous
e-mail, and thank you.

Best regards,
Nicholas Mario Wardhana

--
You are currently subscribed to cgal-discuss.
To unsubscribe or access the archives, go to
https://lists-sop.inria.fr/wws/info/cgal-discuss

Reply | Threaded
Open this post in threaded view
|

Re: Half-edge representation, CGAL vs OpenMesh

Sebastien Loriot (GeometryFactory)
Nicholas Mario Wardhana wrote:

> On 13 January 2011 15:01, Sebastien Loriot (GeometryFactory)
> <[hidden email]> wrote:
>> I am quite surprised by your answer. What are the limitation of the
>> existing data structures?
>>
>
> Hi Sebastien,
>
> What we abandon is the idea of using half-edge representation.
> Previously we were about to implement a method to compute the
> intersections of some polyhedra, which are represented by their
> half-edges. However, after our recent internal discussion, it turned
> out that our previous method was too complicated, so we are trying
> different approach. So far face-vertex (FV) representation is enough
> for this purpose, and we are not sure whether either CGAL or OpenMesh
> directly supports it. For CGAL, we can't find a class like polygon in
> 3D space to represent the face, and I suppose the face classes in both
> CGAL and OpenMesh (HalfedgeDS<Traits,Items,Alloc>::Face in CGAL and
> OpenMesh::PolyMeshT<Kernel> in OpenMesh, although I am not really sure
> about the latter) are quite closely related to half-edge structure
> (please correct me if I am wrong), so currently we develop our simple
> FV data structure.
>
> My apology if I did not make myself clearly enough in the previous
> e-mail, and thank you.
>
> Best regards,
> Nicholas Mario Wardhana
>
The Polyhedron_3 class of CGAL documented here:
http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Polyhedron_ref/Class_Polyhedron_3.html
provides iterator over vertices,facets and halfedges.

Given a facet, you can use Halfedge_around_facet_const_circulator to get
the vertices of a face (using the incident vertex to each halfedge).

See:
http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Polyhedron_ref/Class_Polyhedron_3-Traits---Facet.html

I don't want to prevent you from implementing your own data structure if
you think it will be more efficient but you may save time by using an
existing one (in particular because many additional functionalities are
available in CGAL).


S.


--
You are currently subscribed to cgal-discuss.
To unsubscribe or access the archives, go to
https://lists-sop.inria.fr/wws/info/cgal-discuss