Add planar layout to rustworkx

rustworkx-core/src/planar/lr_planar.rs

@@ -16,11 +16,13 @@ use std::vec::IntoIter;
 
 use hashbrown::{hash_map::Entry, HashMap};
 use petgraph::{
+    graph::NodeIndex,
+    stable_graph::StableGraph,
     visit::{
         EdgeCount, EdgeRef, GraphBase, GraphProp, IntoEdges, IntoNodeIdentifiers, NodeCount,
-        Visitable,
+        NodeIndexable, Visitable,
     },
-    Undirected,
+    Directed, Undirected,
 };
 
 use crate::traversal::{depth_first_search, DfsEvent};
@@ -191,7 +193,8 @@ where
     }
 }
 
-enum Sign {
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Sign {
     Plus,
     Minus,
 }
@@ -208,41 +211,49 @@ enum LRTestDfsEvent<N> {
 // An error: graph is *not* planar.
 struct NonPlanar {}
 
-struct LRState<G: GraphBase>
+pub struct LRState<G: GraphBase>
 where
     G::NodeId: Hash + Eq,
 {
-    graph: G,
+    pub graph: G,
     /// roots of the DFS forest.
-    roots: Vec<G::NodeId>,
+    pub roots: Vec<G::NodeId>,
     /// distnace from root.
     height: HashMap<G::NodeId, usize>,
     /// parent edge.
-    eparent: HashMap<G::NodeId, Edge<G>>,
+    pub eparent: HashMap<G::NodeId, Edge<G>>,
     /// height of lowest return point.
     lowpt: HashMap<Edge<G>, usize>,
     /// height of next-to-lowest return point. Only used to check if an edge is chordal.
     lowpt_2: HashMap<Edge<G>, usize>,
     /// next back edge in traversal with lowest return point.
     lowpt_edge: HashMap<Edge<G>, Edge<G>>,
     /// proxy for nesting order ≺ given by twice lowpt (plus 1 if chordal).
-    nesting_depth: HashMap<Edge<G>, usize>,
+    pub nesting_depth: HashMap<Edge<G>, isize>,
     /// stack for conflict pairs.
     stack: Vec<ConflictPair<Edge<G>>>,
     /// marks the top conflict pair when an edge was pushed in the stack.
     stack_emarker: HashMap<Edge<G>, ConflictPair<Edge<G>>>,
     /// edge relative to which side is defined.
-    eref: HashMap<Edge<G>, Edge<G>>,
+    pub eref: HashMap<Edge<G>, Edge<G>>,
     /// side of edge, or modifier for side of reference edge.
-    side: HashMap<Edge<G>, Sign>,
+    pub side: HashMap<Edge<G>, Sign>,
+    /// directed graph used to build the embedding
+    pub dir_graph: StableGraph<(), (), Directed>,
 }
 
 impl<G> LRState<G>
 where
-    G: GraphBase + NodeCount + EdgeCount + IntoEdges + Visitable,
+    G: GraphBase
+        + NodeCount
+        + EdgeCount
+        + IntoNodeIdentifiers
+        + NodeIndexable
+        + IntoEdges
+        + Visitable,
     G::NodeId: Hash + Eq,
 {
-    fn new(graph: G) -> Self {
+    pub fn new(graph: G) -> Self {
         let num_nodes = graph.node_count();
         let num_edges = graph.edge_count();
 
@@ -262,6 +273,33 @@ where
                 .edge_references()
                 .map(|e| ((e.source(), e.target()), Sign::Plus))
                 .collect(),
+            dir_graph: StableGraph::with_capacity(num_nodes, 0),
+        }
+    }
+
+    // Create the directed graph for the embedding in stable format
+    // to match the original graph.
+    fn build_dir_graph(&mut self)
+    where
+        <G as GraphBase>::NodeId: Ord,
+    {
+        let mut tmp_nodes: Vec<usize> = Vec::new();
+        let mut count: usize = 0;
+        for _ in 0..self.graph.node_bound() {
+            self.dir_graph.add_node(());
+        }
+        for gnode in self.graph.node_identifiers() {
+            let gidx = self.graph.to_index(gnode);
+            if gidx != count {
+                for idx in count..gidx {
+                    tmp_nodes.push(idx);
+                }
+                count = gidx;
+            }
+            count += 1;
+        }
+        for tmp_node in tmp_nodes {
+            self.dir_graph.remove_node(NodeIndex::new(tmp_node));
         }
     }
 
@@ -274,6 +312,11 @@ where
                 }
             }
             DfsEvent::TreeEdge(v, w, _) => {
+                let v_dir = NodeIndex::new(self.graph.to_index(v));
+                let w_dir = NodeIndex::new(self.graph.to_index(w));
+                if !self.dir_graph.contains_edge(v_dir, w_dir) {
+                    self.dir_graph.add_edge(v_dir, w_dir, ());
+                }
                 let ei = (v, w);
                 let v_height = self.height[&v];
                 let w_height = v_height + 1;
@@ -287,6 +330,11 @@ where
             DfsEvent::BackEdge(v, w, _) => {
                 // do *not* consider ``(v, w)`` as a back edge if ``(w, v)`` is a tree edge.
                 if Some(&(w, v)) != self.eparent.get(&v) {
+                    let v_dir = NodeIndex::new(self.graph.to_index(v));
+                    let w_dir = NodeIndex::new(self.graph.to_index(w));
+                    if !self.dir_graph.contains_edge(v_dir, w_dir) {
+                        self.dir_graph.add_edge(v_dir, w_dir, ());
+                    }
                     let ei = (v, w);
                     self.lowpt.insert(ei, self.height[&w]);
                     self.lowpt_2.insert(ei, self.height[&v]);
@@ -311,9 +359,9 @@ where
 
                     if self.lowpt_2[&ei] < self.height[&v] {
                         // if it's chordal, add one.
-                        self.nesting_depth.insert(ei, 2 * low + 1);
+                        self.nesting_depth.insert(ei, (2 * low) as isize + 1);
                     } else {
-                        self.nesting_depth.insert(ei, 2 * low);
+                        self.nesting_depth.insert(ei, (2 * low) as isize);
                     }
 
                     // update lowpoints of parent edge.
@@ -656,37 +704,47 @@ where
 /// # Example:
 /// ```rust
 /// use rustworkx_core::petgraph::graph::UnGraph;
-/// use rustworkx_core::planar::is_planar;
+/// use rustworkx_core::planar::{is_planar_for_layout, LRState};
 ///
 /// let grid = UnGraph::<(), ()>::from_edges(&[
 ///    // row edges
 ///    (0, 1), (1, 2), (3, 4), (4, 5), (6, 7), (7, 8),
 ///    // col edges
 ///    (0, 3), (3, 6), (1, 4), (4, 7), (2, 5), (5, 8),
 /// ]);
-/// assert!(is_planar(&grid))
+/// let mut lr_state = LRState::new(&grid);
+/// assert!(is_planar_for_layout(&grid, Some(&mut lr_state)))
 /// ```
-pub fn is_planar<G>(graph: G) -> bool
+pub fn is_planar_for_layout<G>(graph: G, state: Option<&mut LRState<G>>) -> bool
 where
     G: GraphProp<EdgeType = Undirected>
         + NodeCount
         + EdgeCount
         + IntoEdges
+        + NodeIndexable
         + IntoNodeIdentifiers
         + Visitable,
-    G::NodeId: Hash + Eq,
+    G::NodeId: Hash + Eq + Ord,
 {
-    let mut state = LRState::new(graph);
+    // If None passed for state, create new LRState
+    let mut lr_state = LRState::new(graph);
+    let lr_state = match state {
+        Some(state) => state,
+        None => &mut lr_state,
+    };
+
+    // Build directed graph for the embedding
+    lr_state.build_dir_graph();
 
     // Dfs orientation phase
     depth_first_search(graph, graph.node_identifiers(), |event| {
-        state.lr_orientation_visitor(event)
+        lr_state.lr_orientation_visitor(event)
     });
 
     // Left - Right partition.
-    for v in state.roots.clone() {
-        let res = lr_visit_ordered_dfs_tree(&mut state, v, |state, event| {
-            state.lr_testing_visitor(event)
+    for v in lr_state.roots.clone() {
+        let res = lr_visit_ordered_dfs_tree(lr_state, v, |lr_state, event| {
+            lr_state.lr_testing_visitor(event)
         });
         if res.is_err() {
             return false;
@@ -695,3 +753,40 @@ where
 
     true
 }
+
+/// Check if an undirected graph is planar.
+///
+/// A graph is planar iff it can be drawn in a plane without any edge
+/// intersections.
+///
+/// The planarity check algorithm  is based on the
+/// Left-Right Planarity Test:
+///
+/// [`Ulrik Brandes:  The Left-Right Planarity Test (2009)`](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.217.9208)
+///
+/// # Example:
+/// ```rust
+/// use rustworkx_core::petgraph::graph::UnGraph;
+/// use rustworkx_core::planar::is_planar;
+///
+/// let grid = UnGraph::<(), ()>::from_edges(&[
+///    // row edges
+///    (0, 1), (1, 2), (3, 4), (4, 5), (6, 7), (7, 8),
+///    // col edges
+///    (0, 3), (3, 6), (1, 4), (4, 7), (2, 5), (5, 8),
+/// ]);
+/// assert!(is_planar(&grid))
+/// ```
+pub fn is_planar<G>(graph: G) -> bool
+where
+    G: GraphProp<EdgeType = Undirected>
+        + NodeCount
+        + EdgeCount
+        + IntoEdges
+        + IntoNodeIdentifiers
+        + NodeIndexable
+        + Visitable,
+    G::NodeId: Hash + Eq + Ord,
+{
+    is_planar_for_layout(graph, None)
+}

rustworkx-core/src/planar/mod.rs

@@ -12,6 +12,6 @@
 
 //! Module for planar graphs.
 
-mod lr_planar;
+pub mod lr_planar;
 
-pub use lr_planar::is_planar;
+pub use lr_planar::{is_planar, is_planar_for_layout, LRState};