@graphty/layout 1.2.8 → 1.3.2

package/src/algorithms/planarity/embedding.ts

@@ -2,215 +2,209 @@
  * Embedding functions for planar graphs
  */
 
-import { Node, Edge, Embedding, PositionMap } from '../../types';
+import { Edge, Embedding, Node, PositionMap } from "../../types";
+import { RandomNumberGenerator } from "../../utils/random";
 
 /**
  * Create a triangulation-based embedding for a planar graph
- * 
  * @param nodes - List of nodes
  * @param edges - List of edges
+ * @param seed - Random seed for deterministic embedding generation
  * @returns Embedding object
  */
-export function createTriangulationEmbedding(
-  nodes: Node[],
-  edges: Edge[]
-): Embedding {
-  // Create a simple embedding using the incremental approach
-  const embedding: Embedding = {
-    nodeOrder: [...nodes],
-    faceList: [],
-    nodePositions: {}
-  };
-
-  // Create a map of adjacent nodes
-  const adjMap: Record<Node, Set<Node>> = {};
-  for (const node of nodes) {
-    adjMap[node] = new Set<Node>();
-  }
-
-  for (const [u, v] of edges) {
-    adjMap[u].add(v);
-    adjMap[v].add(u);
-  }
-
-  // Create outer face as a cycle (if possible)
-  const outerFace = findCycle(nodes, edges, adjMap) || nodes;
-  embedding.faceList.push(outerFace);
-
-  // Position nodes on a convex polygon (outer face)
-  const n = outerFace.length;
-  for (let i = 0; i < n; i++) {
-    const angle = 2 * Math.PI * i / n;
-    embedding.nodePositions[outerFace[i]] = [Math.cos(angle), Math.sin(angle)];
-  }
-
-  // Position interior nodes using barycentric coordinates
-  const interiorNodes = nodes.filter(node => !embedding.nodePositions[node]);
-
-  for (const node of interiorNodes) {
-    const neighbors = Array.from(adjMap[node]);
-
-    if (neighbors.length === 0) {
-      // Isolated node, place at center
-      embedding.nodePositions[node] = [0, 0];
-    } else {
-      // Average position of neighbors that have positions
-      let xSum = 0, ySum = 0, count = 0;
-
-      for (const neighbor of neighbors) {
-        if (embedding.nodePositions[neighbor]) {
-          xSum += embedding.nodePositions[neighbor][0];
-          ySum += embedding.nodePositions[neighbor][1];
-          count++;
+export function createTriangulationEmbedding(nodes: Node[], edges: Edge[], seed: number | null = null): Embedding {
+    // Create RNG instance for deterministic randomness
+    const rng = new RandomNumberGenerator(seed ?? undefined);
+
+    // Create a simple embedding using the incremental approach
+    const embedding: Embedding = {
+        nodeOrder: [...nodes],
+        faceList: [],
+        nodePositions: {},
+    };
+
+    // Create a map of adjacent nodes
+    const adjMap: Record<Node, Set<Node>> = {};
+    for (const node of nodes) {
+        adjMap[node] = new Set<Node>();
+    }
+
+    for (const [u, v] of edges) {
+        adjMap[u].add(v);
+        adjMap[v].add(u);
+    }
+
+    // Create outer face as a cycle (if possible)
+    const outerFace = findCycle(nodes, edges, adjMap) || nodes;
+    embedding.faceList.push(outerFace);
+
+    // Position nodes on a convex polygon (outer face)
+    const n = outerFace.length;
+    for (let i = 0; i < n; i++) {
+        const angle = (2 * Math.PI * i) / n;
+        embedding.nodePositions[outerFace[i]] = [Math.cos(angle), Math.sin(angle)];
+    }
+
+    // Position interior nodes using barycentric coordinates
+    const interiorNodes = nodes.filter((node) => !embedding.nodePositions[node]);
+
+    for (const node of interiorNodes) {
+        const neighbors = Array.from(adjMap[node]);
+
+        if (neighbors.length === 0) {
+            // Isolated node, place at center
+            embedding.nodePositions[node] = [0, 0];
+        } else {
+            // Average position of neighbors that have positions
+            let xSum = 0,
+                ySum = 0,
+                count = 0;
+
+            for (const neighbor of neighbors) {
+                if (embedding.nodePositions[neighbor]) {
+                    xSum += embedding.nodePositions[neighbor][0];
+                    ySum += embedding.nodePositions[neighbor][1];
+                    count++;
+                }
+            }
+
+            if (count > 0) {
+                // Place slightly away from center to avoid overlaps
+                const jitter = 0.1 * (rng.rand() as number);
+                embedding.nodePositions[node] = [
+                    xSum / count + jitter * ((rng.rand() as number) - 0.5),
+                    ySum / count + jitter * ((rng.rand() as number) - 0.5),
+                ];
+            } else {
+                // No neighbors have positions yet, place randomly inside unit circle
+                const r = 0.5 * (rng.rand() as number);
+                const angle = 2 * Math.PI * (rng.rand() as number);
+                embedding.nodePositions[node] = [r * Math.cos(angle), r * Math.sin(angle)];
+            }
         }
-      }
-
-      if (count > 0) {
-        // Place slightly away from center to avoid overlaps
-        const jitter = 0.1 * Math.random();
-        embedding.nodePositions[node] = [
-          xSum / count + jitter * (Math.random() - 0.5),
-          ySum / count + jitter * (Math.random() - 0.5)
-        ];
-      } else {
-        // No neighbors have positions yet, place randomly inside unit circle
-        const r = 0.5 * Math.random();
-        const angle = 2 * Math.PI * Math.random();
-        embedding.nodePositions[node] = [r * Math.cos(angle), r * Math.sin(angle)];
-      }
     }
-  }
 
-  return embedding;
+    return embedding;
 }
 
 /**
  * Find a simple cycle in the graph (for outer face)
- * 
  * @param nodes - List of nodes
  * @param edges - List of edges
  * @param adjMap - Adjacency map
  * @returns Cycle as array of nodes, or null if none found
  */
-export function findCycle(
-  nodes: Node[],
-  edges: Edge[],
-  adjMap: Record<Node, Set<Node>>
-): Node[] | null {
-  if (nodes.length === 0) return null;
-  if (nodes.length <= 2) return nodes; // Not a real cycle but handle it
-
-  // Try to find a Hamiltonian cycle for simplicity (for small graphs)
-  if (nodes.length <= 8) {
-    const visited = new Set<Node>();
-    const path: Node[] = [];
-
-    function hamiltonianCycleDFS(node: Node): boolean {
-      path.push(node);
-      visited.add(node);
-
-      if (path.length === nodes.length) {
-        // Check if it's a cycle (last node connects to first)
-        if (adjMap[node].has(path[0])) {
-          return true;
+export function findCycle(nodes: Node[], edges: Edge[], adjMap: Record<Node, Set<Node>>): Node[] | null {
+    if (nodes.length === 0) {return null;}
+    if (nodes.length <= 2) {return nodes;} // Not a real cycle but handle it
+
+    // Try to find a Hamiltonian cycle for simplicity (for small graphs)
+    if (nodes.length <= 8) {
+        const visited = new Set<Node>();
+        const path: Node[] = [];
+
+        function hamiltonianCycleDFS(node: Node): boolean {
+            path.push(node);
+            visited.add(node);
+
+            if (path.length === nodes.length) {
+                // Check if it's a cycle (last node connects to first)
+                if (adjMap[node].has(path[0])) {
+                    return true;
+                }
+                // Not a cycle
+                visited.delete(node);
+                path.pop();
+                return false;
+            }
+
+            for (const neighbor of adjMap[node]) {
+                if (!visited.has(neighbor)) {
+                    if (hamiltonianCycleDFS(neighbor)) {
+                        return true;
+                    }
+                }
+            }
+
+            visited.delete(node);
+            path.pop();
+            return false;
         }
-        // Not a cycle
-        visited.delete(node);
-        path.pop();
-        return false;
-      }
 
-      for (const neighbor of adjMap[node]) {
-        if (!visited.has(neighbor)) {
-          if (hamiltonianCycleDFS(neighbor)) {
-            return true;
-          }
+        if (hamiltonianCycleDFS(nodes[0])) {
+            return path;
         }
-      }
-
-      visited.delete(node);
-      path.pop();
-      return false;
     }
 
-    if (hamiltonianCycleDFS(nodes[0])) {
-      return path;
-    }
-  }
+    // Fallback: try to find any cycle using DFS
+    const visited = new Set<Node>();
+    const parent: Record<Node, Node | null> = {};
+    let cycleFound: Node[] | null = null;
 
-  // Fallback: try to find any cycle using DFS
-  const visited = new Set<Node>();
-  const parent: Record<Node, Node | null> = {};
-  let cycleFound: Node[] | null = null;
+    function findCycleDFS(node: Node, parentNode: Node | null): boolean {
+        visited.add(node);
 
-  function findCycleDFS(node: Node, parentNode: Node | null): boolean {
-    visited.add(node);
+        for (const neighbor of adjMap[node]) {
+            if (neighbor === parentNode) {continue;}
 
-    for (const neighbor of adjMap[node]) {
-      if (neighbor === parentNode) continue;
+            if (visited.has(neighbor)) {
+                // Found a cycle
+                cycleFound = constructCycle(node, neighbor, parent);
+                return true;
+            }
 
-      if (visited.has(neighbor)) {
-        // Found a cycle
-        cycleFound = constructCycle(node, neighbor, parent);
-        return true;
-      }
+            parent[neighbor] = node;
+            if (findCycleDFS(neighbor, node)) {
+                return true;
+            }
+        }
 
-      parent[neighbor] = node;
-      if (findCycleDFS(neighbor, node)) {
-        return true;
-      }
+        return false;
     }
 
-    return false;
-  }
+    function constructCycle(u: Node, v: Node, parent: Record<Node, Node | null>): Node[] {
+        const cycle: Node[] = [v, u];
+        let current = u;
 
-  function constructCycle(u: Node, v: Node, parent: Record<Node, Node | null>): Node[] {
-    const cycle: Node[] = [v, u];
-    let current = u;
+        while (parent[current] !== undefined && parent[current] !== v) {
+            current = parent[current]!;
+            cycle.push(current);
+        }
 
-    while (parent[current] !== undefined && parent[current] !== v) {
-      current = parent[current]!;
-      cycle.push(current);
+        return cycle;
     }
 
-    return cycle;
-  }
-
-  // Try to find a cycle
-  for (const node of nodes) {
-    if (!visited.has(node)) {
-      parent[node] = null;
-      if (findCycleDFS(node, null)) {
-        break;
-      }
+    // Try to find a cycle
+    for (const node of nodes) {
+        if (!visited.has(node)) {
+            parent[node] = null;
+            if (findCycleDFS(node, null)) {
+                break;
+            }
+        }
     }
-  }
 
-  return cycleFound || nodes; // Fallback to all nodes if no cycle found
+    return cycleFound || nodes; // Fallback to all nodes if no cycle found
 }
 
 /**
  * Convert a combinatorial embedding to node positions
- * 
  * @param embedding - The embedding object
  * @param nodes - List of nodes
  * @returns Dictionary mapping nodes to positions
  */
-export function combinatorialEmbeddingToPos(
-  embedding: Embedding,
-  nodes: Node[]
-): PositionMap {
-  const pos: PositionMap = {};
-
-  // Use the positions from the embedding
-  for (const node of nodes) {
-    if (embedding.nodePositions[node]) {
-      pos[node] = embedding.nodePositions[node];
-    } else {
-      // Fallback for any nodes without positions
-      pos[node] = [0, 0];
+export function combinatorialEmbeddingToPos(embedding: Embedding, nodes: Node[]): PositionMap {
+    const pos: PositionMap = {};
+
+    // Use the positions from the embedding
+    for (const node of nodes) {
+        if (embedding.nodePositions[node]) {
+            pos[node] = embedding.nodePositions[node];
+        } else {
+            // Fallback for any nodes without positions
+            pos[node] = [0, 0];
+        }
     }
-  }
 
-  return pos;
-}
+    return pos;
+}

package/src/algorithms/planarity/index.ts

@@ -2,11 +2,7 @@
  * Re-export all planarity algorithms
  */
 
-export { checkPlanarity } from './check';
-export { isK5, isK33, tryFindBipartitePartition } from './special-graphs';
-export { lrPlanarityTest } from './lr-test';
-export { 
-  createTriangulationEmbedding, 
-  findCycle, 
-  combinatorialEmbeddingToPos 
-} from './embedding';
+export { checkPlanarity } from "./check";
+export { combinatorialEmbeddingToPos,createTriangulationEmbedding, findCycle } from "./embedding";
+export { lrPlanarityTest } from "./lr-test";
+export { isK5, isK33, tryFindBipartitePartition } from "./special-graphs";

package/src/algorithms/planarity/lr-test.ts

@@ -2,69 +2,70 @@
  * Left-Right Planarity Test implementation
  */
 
-import { Node, Edge, Embedding } from '../../types';
-import { createTriangulationEmbedding } from './embedding';
+import { Edge, Embedding,Node } from "../../types";
+import { createTriangulationEmbedding } from "./embedding";
 
 /**
  * Left-Right Planarity Test for general graphs
- *
  * @param nodes - List of nodes
  * @param edges - List of edges
+ * @param seed - Random seed for deterministic embedding generation
  * @returns Object containing isPlanar flag and embedding
  */
 export function lrPlanarityTest(
-  nodes: Node[],
-  edges: Edge[]
+    nodes: Node[],
+    edges: Edge[],
+    seed: number | null = null,
 ): { isPlanar: boolean; embedding: Embedding | null } {
-  // Create adjacency list for the graph
-  const adjList: Record<Node, Node[]> = {};
-  for (const node of nodes) {
-    adjList[node] = [];
-  }
+    // Create adjacency list for the graph
+    const adjList: Record<Node, Node[]> = {};
+    for (const node of nodes) {
+        adjList[node] = [];
+    }
 
-  for (const [u, v] of edges) {
-    adjList[u].push(v);
-    adjList[v].push(u);
-  }
+    for (const [u, v] of edges) {
+        adjList[u].push(v);
+        adjList[v].push(u);
+    }
 
-  // Step 1: Perform DFS to get an st-numbering (ordering of nodes)
-  const visited = new Set<Node>();
-  const ordering: Node[] = [];
+    // Step 1: Perform DFS to get an st-numbering (ordering of nodes)
+    const visited = new Set<Node>();
+    const ordering: Node[] = [];
 
-  function dfs(node: Node): void {
-    visited.add(node);
-    ordering.push(node);
+    function dfs(node: Node): void {
+        visited.add(node);
+        ordering.push(node);
 
-    for (const neighbor of adjList[node]) {
-      if (!visited.has(neighbor)) {
-        dfs(neighbor);
-      }
+        for (const neighbor of adjList[node]) {
+            if (!visited.has(neighbor)) {
+                dfs(neighbor);
+            }
+        }
     }
-  }
 
-  // Start DFS from first node
-  dfs(nodes[0]);
+    // Start DFS from first node
+    dfs(nodes[0]);
 
-  // If the graph is disconnected, it's still planar but we need to handle each component
-  if (ordering.length < nodes.length) {
-    // Create a simple triangulation embedding for disconnected graphs
-    return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges) };
-  }
+    // If the graph is disconnected, it's still planar but we need to handle each component
+    if (ordering.length < nodes.length) {
+        // Create a simple triangulation embedding for disconnected graphs
+        return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges, seed) };
+    }
 
-  // Step 2: For a general implementation, we'll use a simplified approach
-  // since this would normally require implementing the entire LR algorithm
+    // Step 2: For a general implementation, we'll use a simplified approach
+    // since this would normally require implementing the entire LR algorithm
 
-  // For this implementation, since we can't fully implement Boyer-Myrvold,
-  // we'll create a reasonable planar embedding for most planar graphs
+    // For this implementation, since we can't fully implement Boyer-Myrvold,
+    // we'll create a reasonable planar embedding for most planar graphs
 
-  // We assume the graph is planar if it's sparse enough (|E| <= 3|V| - 6)
-  // This is a necessary but not sufficient condition for planar graphs
-  if (edges.length > 3 * nodes.length - 6) {
-    return { isPlanar: false, embedding: null };
-  }
+    // We assume the graph is planar if it's sparse enough (|E| <= 3|V| - 6)
+    // This is a necessary but not sufficient condition for planar graphs
+    if (edges.length > 3 * nodes.length - 6) {
+        return { isPlanar: false, embedding: null };
+    }
 
-  // Create a planar embedding using a triangulation approach
-  const embedding = createTriangulationEmbedding(nodes, edges);
+    // Create a planar embedding using a triangulation approach
+    const embedding = createTriangulationEmbedding(nodes, edges, seed);
 
-  return { isPlanar: true, embedding };
-}
+    return { isPlanar: true, embedding };
+}