@statelyai/layout 0.3.0 → 0.4.1

package/src/layered/orthogonal-cycle-order.ts

@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2020 Kiel University and others.
+ * Adapted from ELK v0.11.0 HyperEdgeCycleDetector.
+ * Source commit: 54123e884b1ae743b453260f713b20c9bf5787f2
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+import type { JavaRandom } from "../java-random";
+export interface OrthogonalDependency {
+  source: number;
+  target: number;
+  weight: number;
+  critical: boolean;
+}
+/** ELK's weighted segment ordering; returned dependencies point backwards in that order. */
+export function detectOrthogonalCycles(
+  count: number,
+  dependencies: readonly OrthogonalDependency[],
+  criticalOnly: boolean,
+  random: JavaRandom,
+): { marks: number[]; backwards: OrthogonalDependency[] } {
+  const considered = dependencies.filter((d) => !criticalOnly || d.critical);
+  const incoming = Array.from({ length: count }, () => [] as OrthogonalDependency[]);
+  const outgoing = Array.from({ length: count }, () => [] as OrthogonalDependency[]);
+  for (const dependency of considered) {
+    incoming[dependency.target]!.push(dependency);
+    outgoing[dependency.source]!.push(dependency);
+  }
+  const inWeight = incoming.map((edges) => edges.reduce((sum, e) => sum + e.weight, 0));
+  const outWeight = outgoing.map((edges) => edges.reduce((sum, e) => sum + e.weight, 0));
+  const criticalIn = incoming.map((edges) =>
+    edges.reduce((sum, e) => sum + (e.critical ? e.weight : 0), 0),
+  );
+  const criticalOut = outgoing.map((edges) =>
+    edges.reduce((sum, e) => sum + (e.critical ? e.weight : 0), 0),
+  );
+  const marks = Array.from({ length: count }, (_, i) => -i - 1);
+  const remaining = new Set(marks.map((_, i) => i));
+  const sinks: number[] = [],
+    sources: number[] = [];
+  for (let i = 0; i < count; i++)
+    if (outWeight[i] === 0) sinks.push(i);
+    else if (inWeight[i] === 0) sources.push(i);
+  let nextSink = count - 1,
+    nextSource = count + 1;
+  const update = (node: number) => {
+    for (const edge of outgoing[node]!) {
+      const target = edge.target;
+      if (marks[target]! < 0 && edge.weight > 0) {
+        inWeight[target]! -= edge.weight;
+        if (edge.critical) criticalIn[target]! -= edge.weight;
+        if (inWeight[target]! <= 0 && outWeight[target]! > 0) sources.push(target);
+      }
+    }
+    for (const edge of incoming[node]!) {
+      const source = edge.source;
+      if (marks[source]! < 0 && edge.weight > 0) {
+        outWeight[source]! -= edge.weight;
+        if (edge.critical) criticalOut[source]! -= edge.weight;
+        if (outWeight[source]! <= 0 && inWeight[source]! > 0) sinks.push(source);
+      }
+    }
+  };
+  while (remaining.size) {
+    while (sinks.length) {
+      const node = sinks.shift()!;
+      remaining.delete(node);
+      marks[node] = nextSink--;
+      update(node);
+    }
+    while (sources.length) {
+      const node = sources.shift()!;
+      remaining.delete(node);
+      marks[node] = nextSource++;
+      update(node);
+    }
+    let maximum = -2147483648;
+    let candidates: number[] = [];
+    // TreeSet compares initial negative marks, hence reverse segment creation order.
+    for (const node of [...remaining].sort((a, b) => marks[a]! - marks[b]!)) {
+      if (!criticalOnly && criticalOut[node]! > 0 && criticalIn[node]! <= 0) {
+        candidates = [node];
+        break;
+      }
+      const outflow = outWeight[node]! - inWeight[node]!;
+      if (outflow >= maximum) {
+        if (outflow > maximum) {
+          candidates = [];
+          maximum = outflow;
+        }
+        candidates.push(node);
+      }
+    }
+    if (candidates.length) {
+      const node = candidates[random.nextInt(candidates.length)]!;
+      remaining.delete(node);
+      marks[node] = nextSource++;
+      update(node);
+    }
+  }
+  for (let i = 0; i < count; i++) if (marks[i]! < count) marks[i]! += count + 1;
+  // Upstream iterates each source's outgoing list, not the global edge list.
+  const backwards = outgoing.flatMap((edges) =>
+    edges.filter((e) => marks[e.source]! > marks[e.target]!),
+  );
+  return { marks, backwards };
+}

package/src/layered/orthogonal-hypersegments.ts

@@ -0,0 +1,154 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2016, 2020 Kiel University and others.
+ * Adapted from ELK v0.11.0 OrthogonalRoutingGenerator, HyperEdgeSegment
+ * and HyperedgeCrossingsCounter.
+ * Source commit: 54123e884b1ae743b453260f713b20c9bf5787f2
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+export interface OrthogonalPort {
+  id: string;
+  side: "source" | "target";
+  position: number;
+}
+export interface OrthogonalConnection {
+  source: string;
+  target: string;
+}
+/** ELK visits output ports on each boundary side, then recursively follows all connected edges. */
+export function createOrthogonalHypersegments(
+  ports: readonly OrthogonalPort[],
+  connections: readonly OrthogonalConnection[],
+  /** Position of a connection in its port's incoming or outgoing edge list, when known. */
+  listRank?: (connection: number, list: "incoming" | "outgoing") => number | undefined,
+) {
+  const byId = new Map(ports.map((p) => [p.id, p]));
+  const incoming = new Map(ports.map((p) => [p.id, [] as number[]]));
+  const outgoing = new Map(ports.map((p) => [p.id, [] as number[]]));
+  for (const [index, edge] of connections.entries()) {
+    incoming.get(edge.target)!.push(index);
+    outgoing.get(edge.source)!.push(index);
+  }
+  // ELK follows each port's edges in list order; fall back to connection order.
+  if (listRank)
+    for (const [lists, list] of [
+      [incoming, "incoming"],
+      [outgoing, "outgoing"],
+    ] as const)
+      for (const members of lists.values())
+        members.sort((a, b) => {
+          const ra = listRank(a, list),
+            rb = listRank(b, list);
+          return ra !== undefined && rb !== undefined ? ra - rb || a - b : a - b;
+        });
+  const segmentByPort = new Map<string, number>();
+  const segments: Array<{ ports: string[]; incoming: number[]; outgoing: number[] }> = [];
+  const visit = (id: string, index: number) => {
+    if (segmentByPort.has(id)) return;
+    segmentByPort.set(id, index);
+    const port = byId.get(id)!,
+      segment = segments[index]!;
+    segment.ports.push(id);
+    (port.side === "source" ? segment.incoming : segment.outgoing).push(port.position);
+    for (const connection of incoming.get(id)!) visit(connections[connection]!.source, index);
+    for (const connection of outgoing.get(id)!) visit(connections[connection]!.target, index);
+  };
+  for (const side of ["source", "target"] as const)
+    for (const port of ports) {
+      if (port.side !== side || outgoing.get(port.id)!.length === 0 || segmentByPort.has(port.id))
+        continue;
+      const index = segments.length;
+      segments.push({ ports: [], incoming: [], outgoing: [] });
+      visit(port.id, index);
+    }
+  for (const segment of segments) {
+    segment.incoming = [...new Set(segment.incoming)].sort((a, b) => a - b);
+    segment.outgoing = [...new Set(segment.outgoing)].sort((a, b) => a - b);
+  }
+  return { segments, segmentByPort };
+}
+
+/** ELK's hyperedge crossing estimate; positions are distinct ordinal port ranks on each side. */
+export function countOrthogonalHypersegmentCrossings(
+  ports: readonly OrthogonalPort[],
+  connections: readonly OrthogonalConnection[],
+): number {
+  return scoreOrthogonalHypersegments(ports, connections).count;
+}
+
+/**
+ * {@link countOrthogonalHypersegmentCrossings}, optionally separating shared
+ * tracks. ELK routes a hyperedge on one shared track. When it joins two or
+ * more ports on each side, its edges would run opposite ways along that
+ * track, which routing never allows; `separateShared` counts such a
+ * hyperedge's edges one by one instead. `shared` reports whether one exists.
+ */
+export function scoreOrthogonalHypersegments(
+  ports: readonly OrthogonalPort[],
+  connections: readonly OrthogonalConnection[],
+  separateShared = false,
+): { count: number; shared: boolean } {
+  const { segments: merged, segmentByPort } = createOrthogonalHypersegments(ports, connections);
+  const sharedSegments = new Set(
+    merged.flatMap((s, i) => (s.incoming.length > 1 && s.outgoing.length > 1 ? [i] : [])),
+  );
+  const separating = separateShared && sharedSegments.size > 0;
+  const spans = merged
+    .filter((_, i) => !separating || !sharedSegments.has(i))
+    .map((s) => ({
+      leftStart: Math.min(...s.incoming),
+      leftEnd: Math.max(...s.incoming),
+      rightStart: Math.min(...s.outgoing),
+      rightEnd: Math.max(...s.outgoing),
+    }));
+  let count = 0;
+  for (let i = 0; i < spans.length; i++)
+    for (let j = i + 1; j < spans.length; j++) {
+      const a = spans[i]!,
+        b = spans[j]!;
+      if ((a.leftStart - b.leftStart) * (a.rightStart - b.rightStart) < 0) count++;
+      if (a.leftStart < b.leftEnd && b.leftStart < a.leftEnd) count++;
+      if (a.rightStart < b.rightEnd && b.rightStart < a.rightEnd) count++;
+    }
+  if (separating) {
+    // A separated edge is a one-point span on each side.
+    const position = new Map(ports.map((p) => [p.id, p.position]));
+    const edges = connections
+      .filter((c) => sharedSegments.has(segmentByPort.get(c.source)!))
+      .map((c) => [position.get(c.source)!, position.get(c.target)!] as const);
+    for (const [left, right] of edges)
+      for (const b of spans) {
+        if ((left - b.leftStart) * (right - b.rightStart) < 0) count++;
+        if (left < b.leftEnd && b.leftStart < left) count++;
+        if (right < b.rightEnd && b.rightStart < right) count++;
+      }
+    count += strictInversions(edges);
+  }
+  return { count, shared: sharedSegments.size > 0 };
+}
+
+/** Pairs whose ends are strictly inverted: two separated edges that cross, in O(n log n). */
+function strictInversions(pairs: ReadonlyArray<readonly [number, number]>): number {
+  const ranks = [...new Set(pairs.map(([, right]) => right))].sort((a, b) => a - b);
+  const rankOf = new Map(ranks.map((value, index) => [value, index + 1]));
+  const tree = new Array<number>(ranks.length + 1).fill(0);
+  const atMost = (rank: number) => {
+    let sum = 0;
+    for (let i = rank; i > 0; i -= i & -i) sum += tree[i]!;
+    return sum;
+  };
+  const sorted = [...pairs].sort((a, b) => a[0] - b[0]);
+  let inserted = 0,
+    count = 0;
+  for (let start = 0; start < sorted.length;) {
+    let end = start;
+    while (end < sorted.length && sorted[end]![0] === sorted[start]![0]) end++;
+    // Edges with an equal left end never cross; compare against earlier ones only.
+    for (let i = start; i < end; i++) count += inserted - atMost(rankOf.get(sorted[i]![1])!);
+    for (let i = start; i < end; i++) {
+      for (let r = rankOf.get(sorted[i]![1])!; r <= ranks.length; r += r & -r) tree[r]!++;
+      inserted++;
+    }
+    start = end;
+  }
+  return count;
+}

package/src/layered/orthogonal-junctions.ts

@@ -0,0 +1,202 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2020 Kiel University and others.
+ * Native adaptation of ELK orthogonal routing junction generation.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+import type { GraphEdge, GraphNode, GraphPort, Point } from "@statelyai/graph";
+import type { AcyclicOrientation, LayeredPhaseInput } from "./types";
+import type { OrthogonalSegment } from "./orthogonal-segments";
+import { createOrthogonalHypersegments, type OrthogonalPort } from "./orthogonal-hypersegments";
+import { isMergedHyperedgeDummy } from "./hyperedge-dummy-merger";
+export type OrthogonalJunctionGroup = Array<{
+  edgeId: string;
+  reversed: boolean;
+  segment: OrthogonalSegment;
+  partner?: OrthogonalSegment;
+  sourceValue: number;
+  targetValue: number;
+}>;
+/** Emit branches from routing-port spans, before endpoint restoration and compaction. */
+export function orthogonalJunctionPoints(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+  raw: ReadonlyMap<string, { source: Point; target: Point }>,
+  flowLayerByNodeId: ReadonlyMap<string, number>,
+  junctionGroups: OrthogonalJunctionGroup[],
+  pointsByEdgeId: ReadonlyMap<string, readonly Point[]>,
+  orthogonalTrackByEdgeId: ReadonlyMap<string, number>,
+  orthogonalDetourByEdgeId: ReadonlyMap<
+    string,
+    { firstTrack: number; secondTrack: number; crossover: number }
+  >,
+  portDirection: (node: GraphNode, port: GraphPort) => GraphPort["direction"],
+): ReadonlyMap<string, readonly Point[]> {
+  const horizontal = input.direction === "left" || input.direction === "right";
+  const increasing = input.direction === "right" || input.direction === "down";
+  const nodeById = new Map(input.graph.nodes.map((n) => [n.id, n]));
+  const junctionPointsByEdgeId = new Map<string, readonly Point[]>();
+
+  type BoundaryEdge = {
+    edge: GraphEdge;
+    source: string;
+    target: string;
+    sourceValue: number;
+    targetValue: number;
+    inLayer: boolean;
+  };
+  const boundaries = new Map<
+    number,
+    { ports: Map<string, OrthogonalPort>; edges: BoundaryEdge[] }
+  >();
+  const face = (edge: GraphEdge, source: boolean) => {
+    const id = source ? edge.sourceId : edge.targetId;
+    const node = nodeById.get(id)!;
+    const name = source ? edge.sourcePort : edge.targetPort;
+    const port = node.ports?.find((p) => p.name === name);
+    if (node.id.startsWith("__layout_dummy:") && (name === "input" || name === "output"))
+      return horizontal
+        ? (name === "output") === increasing
+          ? "EAST"
+          : "WEST"
+        : (name === "output") === increasing
+          ? "SOUTH"
+          : "NORTH";
+    const side = port && input.portSettings?.(port, node)?.["port.side"];
+    if (side && side !== "UNDEFINED") return side;
+    const physicalSource = source !== orientation.reversedEdgeIds.has(edge.id);
+    const outgoing = port
+      ? (portDirection(node, port) ?? port.direction) === "out"
+      : physicalSource;
+    return horizontal
+      ? outgoing === increasing
+        ? "EAST"
+        : "WEST"
+      : outgoing === increasing
+        ? "SOUTH"
+        : "NORTH";
+  };
+  for (const edge of input.graph.edges) {
+    const from = flowLayerByNodeId.get(edge.sourceId),
+      to = flowLayerByNodeId.get(edge.targetId);
+    const endpoints = raw.get(edge.id);
+    if (from === undefined || to === undefined || !endpoints || edge.sourceId === edge.targetId)
+      continue;
+    const firstFace = face(edge, true),
+      lastFace = face(edge, false);
+    const positiveFace = horizontal ? "EAST" : "SOUTH",
+      negativeFace = horizontal ? "WEST" : "NORTH";
+    if (
+      ![positiveFace, negativeFace].includes(String(firstFace)) ||
+      ![positiveFace, negativeFace].includes(String(lastFace))
+    )
+      continue;
+    const firstBoundary = from - (firstFace === negativeFace ? 1 : 0),
+      lastBoundary = to - (lastFace === negativeFace ? 1 : 0);
+    if (firstBoundary !== lastBoundary) continue;
+    let boundary = boundaries.get(firstBoundary);
+    if (!boundary) boundaries.set(firstBoundary, (boundary = { ports: new Map(), edges: [] }));
+    const key = (source: boolean) => {
+      const id = source ? edge.sourceId : edge.targetId,
+        name = source ? edge.sourcePort : edge.targetPort;
+      if (isMergedHyperedgeDummy(input, id))
+        return JSON.stringify([id, source ? firstFace : lastFace]);
+      return name !== undefined ? JSON.stringify([id, name]) : JSON.stringify([edge.id, source]);
+    };
+    for (const source of [true, false]) {
+      const id = key(source),
+        point = source ? endpoints.source : endpoints.target;
+      if (!boundary.ports.has(id))
+        boundary.ports.set(id, {
+          id,
+          side:
+            ((source ? firstFace : lastFace) === positiveFace) === increasing ? "source" : "target",
+          position: horizontal ? point.y : point.x,
+        });
+    }
+    const reversed = orientation.reversedEdgeIds.has(edge.id);
+    const source = key(!reversed),
+      target = key(reversed);
+    boundary.edges.push({
+      edge,
+      source,
+      target,
+      sourceValue: boundary.ports.get(source)!.position,
+      targetValue: boundary.ports.get(target)!.position,
+      inLayer: from === to,
+    });
+  }
+  const routedEdges = new Set(
+    junctionGroups.flatMap((group) => group.map((record) => record.edgeId)),
+  );
+  const inLayerGroups: typeof junctionGroups = [];
+  for (const [, boundary] of [...boundaries].sort(([a], [b]) => (increasing ? a - b : b - a))) {
+    if (!boundary.edges.some((e) => e.inLayer)) continue;
+    const ports = [...boundary.ports.values()].sort((a, b) => a.position - b.position);
+    const grouped = createOrthogonalHypersegments(ports, boundary.edges);
+    const records: (typeof junctionGroups)[number] = [];
+    for (const group of grouped.segments)
+      for (const port of group.ports) {
+        const members = boundary.edges.filter(
+          (e) => e.source === port && e.inLayer && !routedEdges.has(e.edge.id),
+        );
+        for (const record of members) {
+          const values = [...group.incoming, ...group.outgoing];
+          records.push({
+            edgeId: record.edge.id,
+            reversed: orientation.reversedEdgeIds.has(record.edge.id),
+            sourceValue: record.sourceValue,
+            targetValue: record.targetValue,
+            segment: { ...group, start: Math.min(...values), end: Math.max(...values), slot: 0 },
+          });
+        }
+      }
+    inLayerGroups.push(records);
+  }
+  junctionGroups = [...inLayerGroups, ...junctionGroups];
+  const createdJunctions = new Set<string>();
+  for (const group of junctionGroups) {
+    for (const { edgeId, reversed, segment, partner, sourceValue, targetValue } of group) {
+      const physical = [...(pointsByEdgeId.get(edgeId) ?? [])];
+      if (reversed) physical.reverse();
+      const bends = Math.abs(segment.start - segment.end) < 1e-3 ? [] : physical.slice(1, -1);
+      const junctions: Point[] = [];
+      for (const [index, point] of bends.entries()) {
+        const track = orthogonalTrackByEdgeId.get(edgeId);
+        const detour = orthogonalDetourByEdgeId.get(edgeId);
+        const flow = horizontal ? point.x : point.y;
+        if (track !== undefined && Math.abs(flow - track) > 1e-9) continue;
+        if (
+          detour &&
+          Math.abs(flow - detour.firstTrack) > 1e-9 &&
+          Math.abs(flow - detour.secondTrack) > 1e-9
+        )
+          continue;
+        const current = partner && index >= 2 ? partner : segment;
+        const value =
+          index === 0
+            ? sourceValue
+            : index === bends.length - 1
+              ? targetValue
+              : segment.outgoing[0]!;
+        const boundary =
+          current.incoming.length > 0 &&
+          current.outgoing.length > 0 &&
+          ((Math.abs(value - current.incoming[0]!) < 1e-3 &&
+            Math.abs(value - current.outgoing[0]!) < 1e-3) ||
+            (Math.abs(value - current.incoming.at(-1)!) < 1e-3 &&
+              Math.abs(value - current.outgoing.at(-1)!) < 1e-3));
+        const key = `${point.x}:${point.y}`;
+        if (
+          !createdJunctions.has(key) &&
+          ((value > current.start && value < current.end) || boundary)
+        ) {
+          junctions.push(point);
+          createdJunctions.add(key);
+        }
+      }
+      junctionPointsByEdgeId.set(edgeId, junctions);
+    }
+  }
+
+  return junctionPointsByEdgeId;
+}