Dual graph algorithm

Question

Hello to all of you!
Does anyone know a known algorithm to create the dual graph of a planar (undirected) graph? Or could you give me a hint? I tried to devise a DFS approach, which would use the back and cross edges of the DFS tree in order to form the faces. The problem is that I need the set of disjoint minimum cycles. Thus I would need an algorithm to calculate the difference AUB - A^B, for two cycles A,B, where B is a part of A. By the way, is there any recommended representation of a face?
Thank you in advance and thaks for your time!
P.S. For those who would ask what is a face, a face is the area defined by a minimum cycle e.g.:
In this mesh (ignore dots):
a-b-c
I . I . I
d-e-f
a,b,c,d form a face
b,c,e,f form a face
and there is also the external face -which by the way how can it be defined?
P.S.2 the Dual Graph is the graph formed by representing each face as a node and each edge which separates two faces, as an edge between the two newlly created nodes.

Answer 1

OK , guess you're right! Since the following graph:
O     O
|\   /|
| \ / |
|  O  |
| / \ |
|/   \|
O     O
and this one
O---
|    \
| O  |
| | \|
| |  O
| | /|
| O  |
|   /
O---are the same, however they have a different embedding AND dual graph.
So, the embedding is defined by the coordinates of the nodes, along with
their connectivity info.
This means that for a start I need an algorithm to return the different faces of
the graph. (at least these ones have to be fixed in number -no?). Then from
the topological information for each face I should check their neighboring
relations.
For the face discovery I have thought of the following algorithm (in language):
Create the DFS tree
-Start from the root r of the DFS tree and visit each neighboring node based
on the preordering number
-When we reach a node b which has one or more back-edges we have a
cycle.
--For each back edge we go back to the node bs, starting from the
back-edge which leads us to the node bs with the greatest start time
(gretest preorder number).
--from this node, bs, visit neighboring nodes, again based on preordering,
until we find the node b (which will complete the cycle)
---While going towards b follow in reverse direction, each backedge that
terminates a currntly visited node, and starts from a node t whose
preorder[t] <= preorder[b]  (to avoid bypassing b by going deeper in the tree)
and
postorder[t] > postorder[b] (to avoid reaching another branch)
-When we reach a node, cs,which has a cross edge to another node, ce, of
the DFS tree (as a cross edge I mean a (u,v) where pre[u]>pre[v] and
post[u]>post[v]) we have found another cycle, thus a face
--from ce we go up the DFS, i.e., in reverse preordering, until we find a node
a whose postorder[a] > post[cs]
--from a we go down the DFS (in preordering) choosing the neighbor, an,
whose postorder[an] >= postorder[cs] (equality means we have found cs
thus we're done).  While descending we follow the same rules as before, in
the case of the back edge.Of course the implementation of this algorithms has to support two-way movement in the DFS tree. The distinction between tree,back and cross edges is made through the pre and post ordering.
I'm not sure but i think that, with the restrictions I have put, this algorithm can be ran while discovering and creating the DFS tree, rather after the DFS tree has been fully created.
So if the algorithm IS correct, I only need a way to derive the connectivity between the produced faces via their topological information. That is, apart from the indisputable fact that if two faces have two nodes in common, they are neighbors, we have to locate all other edges between faces.
One idea is for each pair of faces to check their min and max, X and Y coordinates. I have a sense that for faces f1and f2 where,
f1_max_X > f2_max_X and
f1_min_X < f2_min_X and
f1_max_Y > f2_max_Y and
f1_min_Y < f2_min_Y
(there must be at most one equality (i.e. <=)but I guess its no harm to add all equalities there)
holds, f1 and f2 are neighbors, thus an edge (f1,f2) must exist in the dual graph.
Of course I have written a lot but I really would like to know if there's a "good" algortihm to create faces out there and a technique to create edges between faces given the coordinates.
I propose the ideas in case someone finds something wrong and reports it or otherwise someone else finds my answer useful in the same topic.
Thank you in advance!
Message was edited by:
M.M.