grid

src/errors/graph/layering/grid/GridError.ts

@@ -0,0 +1,8 @@
+import BPMNError from "../../../BPMNError.js";
+
+export default class GridError extends BPMNError {
+	public constructor(message: string) {
+		super(message);
+		this.name = GridError.name;
+	}
+}

src/graph/grid/Grid.ts

@@ -0,0 +1,96 @@
+import GridError from "../../errors/graph/layering/grid/GridError.js";
+
+/**
+ * Стека для укладка графа на двумерной плоскости
+ */
+export class Grid<TElement> {
+	/**
+     * Ячейки сетки, которые могут хранить в себе элементы
+     * @protected
+     */
+	protected readonly _cells: (TElement | undefined)[][];
+
+	/**
+	 * Количество элементов в каждой из строк сетки
+	 * @private
+	 */
+	private readonly width: number;
+	/**
+	 * Количество элементов в каждом из столбцов сетки
+	 * @private
+	 */
+	private readonly height: number;
+
+	public constructor(width: number, height: number) {
+		this.width = width;
+		this.height = height;
+		this._cells = Array.from({ length: height }, () => new Array(width));
+	}
+
+	/**
+     * Поместить элемент в ячейку сетки
+     * @param row Индекс строки ячейки
+     * @param col Индекс стобца сетки
+     * @param value Элемент, который необходимо разместить
+     */
+	public set(row: number, col: number, value: TElement) : this {
+		this.validate(row, col);
+
+        this._cells[row]![col] = value;
+
+        return this;
+	}
+
+	public get(row: number, col: number) : TElement | undefined {
+		this.validate(row, col);
+		return this._cells[row]![col];
+	}
+
+	public getPositionOf(element: TElement) : ({ row: number, column: number }) | null {
+		for(let i = 0; i < this._cells.length; i++) {
+			const row = this._cells[i]!;
+
+			for(let j = 0; j < row.length; j++)
+				if(row[j] === element)
+					return { row: i, column: j };
+		}
+
+		return null;
+	}
+
+	public delete(row: number, col: number) : this {
+		this.validate(row, col);
+
+		const r = this._cells[row];
+		if(!r)
+			return this;
+
+		delete r[col];
+
+		return this;
+	}
+
+	public isEmpty(row: number, col: number) : boolean {
+		this.validate(row, col);
+
+		const r = this._cells[row];
+		if(!r)
+			return true;
+
+		return r[col] === undefined;
+	}
+
+	public getSize(): { width: number; height: number } {
+		return { width: this.width, height: this.height };
+	}
+
+	protected validate(row: number, col: number) : void {
+		if(row < 0 || row >= this._cells.length)
+			throw new GridError(`Row index is out of bounds [0, ${this._cells.length - 1}]: ${row}`);
+
+		const r = this._cells[row]!;
+
+		if(col < 0 || col >= r.length)
+			throw new GridError(`Column index is out of bounds [0, ${r.length - 1}]: ${row}`);
+	}
+}

src/graph/grid/NodeGrid.ts

@@ -0,0 +1,50 @@
+import {Grid} from "./Grid.js";
+import Node from "../node/Node.js";
+import DummyNode from "../node/DummyNode.js";
+
+export default class NodeGrid<TNode extends Node> extends Grid<TNode> {
+	public getHeight(row: number, col: number) : number {
+		this.validate(row, col);
+
+		const r = this._cells[row];
+		if(!r)
+			return 0.0;
+
+		let height = 0.0;
+		for(const el of r)
+			height = Math.max(height, el?.getHeight() ?? 0.0);
+
+		return height;
+	}
+
+	public getWidth(row: number, col: number) : number {
+		this.validate(row, col);
+
+		let width = 0.0;
+		for(const r of this._cells) {
+			if(!r)
+				continue;
+
+			width = Math.max(width, r[col]?.getWidth() ?? 0.0);
+		}
+
+		return width;
+	}
+
+	public getCellSize(row: number, col: number) : { width: number, height: number } {
+		return { width: this.getWidth(row, col), height: this.getHeight(row, col) };
+	}
+
+	public toString() : string {
+		let result = "";
+
+		for(const r of this._cells) {
+			for(const cell of r) {
+				result += cell ? `[${cell instanceof DummyNode ? 'dn' : 'node'}(${cell.getX()}, ${cell.getY()})]` : '[]';
+			}
+			result += "\n";
+		}
+
+		return result;
+	}
+}

src/index.ts

@@ -3,6 +3,12 @@ import Graph from "./graph/Graph.js";
 import Node from "./graph/node/Node.js";
 import Edge from "./graph/edge/Edge.js";
 import BPMNError from "./errors/BPMNError.js";
+import DzwfJsonDeserializer from "./io/deserialize/json/DzwfJsonDeserializer.js";
+import {readFileSync} from "node:fs";
+import CycleRemoveStep from "./optimizer/steps/CycleRemoveStep.js";
+import LayerAssignmentStep from "./optimizer/steps/LayerAssignmentStep.js";
+import NodeOrderingStep from "./optimizer/steps/NodeOrderingStep.js";
+import CoordinateAssignmentStep from "./optimizer/steps/CoordinateAssignmentStep.js";
 
 export class BPMNOptimizer {
 	private _optimizationAlgorithm?: SiguiyamaAlgorithm;
@@ -26,4 +32,10 @@ export class BPMNOptimizer {
 
 		this._optimizationAlgorithm.run(this._graph);
 	}
-}
+}
+
+const deserializer = new DzwfJsonDeserializer();
+const data = deserializer.deserialize(readFileSync("./data/bpmn-graph.json").toString());
+const algorithm = new SiguiyamaAlgorithm().addStep(new CycleRemoveStep()).addStep(new LayerAssignmentStep()).addStep(new NodeOrderingStep()).addStep(new CoordinateAssignmentStep());
+const optimizer = new BPMNOptimizer().setOptimizationAlgorithm(algorithm).setGraph(data.graph);
+optimizer.run();

src/optimizer/siguiyama/SiguiyamaContext.ts

@@ -2,6 +2,7 @@ import Edge from "../../graph/edge/Edge.js"
 import Layering from "../../graph/layering/Layering.js";
 import Node from "../../graph/node/Node.js"
 import { AlgorithmContext } from "../AlgorithmContext.js"
+import NodeGrid from "../../graph/grid/NodeGrid.js";
 
 /**
  * Набор рёбер обратной связи - рёбра, которые были инвертированы на этапе удаления циклов и должны быть восстановлены на этапе назначения координат.
@@ -17,4 +18,5 @@ export type SiguiyamaContext = AlgorithmContext & Partial<{
 	feedbackSet: FeedbackSet,
 	edgeSubdivisions: EdgeSubdivisions<Node, Edge<Node>>
 	layering: Layering<Node, Edge<Node>>,
+	grid: NodeGrid<Node>
 }>

src/optimizer/steps/CoordinateAssignmentStep.ts

@@ -4,6 +4,7 @@ import EdgeRoutingStepError from "../../errors/optimizer/EdgeRoutingStepError.js
 import Edge from "../../graph/edge/Edge.js";
 import Layering from "../../graph/layering/Layering.js";
 import Node from "../../graph/node/Node.js";
+import NodeGrid from "../../graph/grid/NodeGrid.js";
 
 /**
  * Шаг назначения координат вершинам
@@ -44,7 +45,10 @@ export default class CoordinateAssignmentStep extends AlgorithmStep<SiguiyamaCon
 		if(!layering)
 			throw new Error("Layering of graph was not found!");
 
-		this.assignCoordinates(layering);
+		const grid = this.buildGrid(layering);
+		this.assignCoordinatesByGrid(grid);
+
+		context.grid = grid;
 	}
 
 	/**
@@ -79,4 +83,41 @@ export default class CoordinateAssignmentStep extends AlgorithmStep<SiguiyamaCon
 			xOffset += width + this._padding;
 		}
 	}
+
+	private buildGrid(layering: Layering<Node, Edge<Node>>) : NodeGrid<Node> {
+		const layers = layering.getLayers().toReversed();
+		const grid = new NodeGrid(layers.length, Math.max(...layers.map((l) => l.getNodes().length)))
+
+		for(let i = 0; i < layers.length; i++) {
+			const layer = layers[i]!, nodes = layer.getNodes();
+
+			for(let j = 0; j < nodes.length; j++) {
+				grid.set(j, i, nodes[j]!);
+			}
+		}
+
+		return grid;
+	}
+
+	private assignCoordinatesByGrid(grid: NodeGrid<Node>) : void {
+		const gridSize = grid.getSize();
+
+		let yOffset = 0.0;
+		for(let r = 0; r < gridSize.height; r++) {
+			const rowHeight = grid.getHeight(r, 0);
+			let xOffset = 0.0;
+
+			for(let c = 0; c < gridSize.width; c++) {
+				const cellSize = grid.getCellSize(r, c);
+				const node = grid.get(r, c);
+
+				if(node)
+					node.setX(xOffset + cellSize.width / 2 - node.getWidth() / 2).setY(yOffset + cellSize.height / 2 - node.getHeight() / 2);
+
+				xOffset += cellSize.width + this._padding;
+			}
+
+			yOffset += rowHeight + this._layerGap;
+		}
+	}
 }

src/optimizer/steps/EdgeRoutingStep.ts

@@ -1,12 +1,12 @@
 import AlgorithmStep from "../AlgorithmStep.js";
 import {EdgeSubdivisions, SiguiyamaContext} from "../siguiyama/SiguiyamaContext.js";
 import EdgeRoutingStepError from "../../errors/optimizer/EdgeRoutingStepError.js";
+import Graph from "../../graph/Graph.js";
 import Node from "../../graph/node/Node.js";
 import Edge from "../../graph/edge/Edge.js";
+import NodeGrid from "../../graph/grid/NodeGrid.js";
 import DummyNode from "../../graph/node/DummyNode.js";
 import DummyEdge from "../../graph/edge/DummyEdge.js";
-import Graph from "../../graph/Graph.js";
-import Layering from "../../graph/layering/Layering.js";
 
 export default class EdgeRoutingStep extends AlgorithmStep<SiguiyamaContext> {
 	public constructor() {
@@ -14,77 +14,43 @@ export default class EdgeRoutingStep extends AlgorithmStep<SiguiyamaContext> {
 	}
 
 	public run(context: SiguiyamaContext) : void {
-		const { layering, graph, edgeSubdivisions } = context;
+		const { graph, grid, edgeSubdivisions } = context;
 
-		if(!layering)
-			throw new EdgeRoutingStepError("Layering is null or undefined");
 		if(!graph)
 			throw new EdgeRoutingStepError("Graph is null or undefined");
+		if(!grid)
+			throw new EdgeRoutingStepError("Grid is null or undefined");
 		if(!edgeSubdivisions)
-			throw new EdgeRoutingStepError("Edge Subdivisions are null or undefined");
+			throw new EdgeRoutingStepError("Edge subdivisions information is null or undefined");
 
-		this.routeEdges(graph, layering, edgeSubdivisions);
+		this.manhattanEdgeRouting(graph, grid, edgeSubdivisions);
 	}
 
-	private routeEdges(graph: Graph<Node, Edge<Node>>, layering: Layering<Node, Edge<Node>>, edgeSubdivisions: EdgeSubdivisions<Node, Edge<Node>>): void {
+	private manhattanEdgeRouting(graph: Graph<Node, Edge<Node>>, grid: NodeGrid<Node>, edgeSubdivisions: EdgeSubdivisions<Node, Edge<Node>>) : void {
 		const edges = graph.getEdges();
 
 		for(const edge of edges) {
-			const from = edge.getFrom();
-			const to = edge.getTo();
-			const fromNodeIndex = this.getNodeIndex(layering, from);
-			const toNodeIndex = this.getNodeIndex(layering, to);
+			const from = edge.getFrom(), to = edge.getTo();
+			const fromPosition = grid.getPositionOf(from), toPosition = grid.getPositionOf(to);
 
-			if(fromNodeIndex === -1 || toNodeIndex === -1 || fromNodeIndex === toNodeIndex)
+			if(!fromPosition || !toPosition || fromPosition.row === toPosition.row)
 				continue;
 
-			const fromLayerIndex = layering.getNodeLayerIndex(from);
-			if(fromLayerIndex === -1)
-				continue;
+			const fromRow = fromPosition.row, fromColumn = fromPosition.column;
+			const toRow = toPosition.row, toColumn = toPosition.column;
 
-			const targetRowIndex = fromNodeIndex > toNodeIndex ? fromNodeIndex - 1 : fromNodeIndex + 1;
-			const neighborRowCenter = this.getRowCenter(layering, targetRowIndex);
-			if(neighborRowCenter === null)
-				continue;
+			const targetCellPosition: { row: number, column: number } = toRow > fromRow ? { row: toRow, column: fromColumn } : { row: fromRow, column: toColumn };
 
-			const fromCenterY = from.getY() + from.getHeight() / 2;
-			const routedNode = new DummyNode(
-				from.getX() + from.getWidth() / 2,
-				(fromCenterY + neighborRowCenter) / 2
-			);
+			const cellSize = grid.getCellSize(targetCellPosition.row, targetCellPosition.column);
+			const dummyNode = new DummyNode(cellSize.width / 2,cellSize.height / 2);
+			graph.addNode(dummyNode);
+			grid.set(targetCellPosition.row, targetCellPosition.column, dummyNode);
 
-			layering.addToLayer(fromLayerIndex, routedNode);
-			graph.addNode(routedNode);
-
-			const left = new DummyEdge(from, routedNode);
-			const right = new DummyEdge(routedNode, to);
-
-			graph.addEdge(left);
-			graph.addEdge(right);
-			graph.removeEdge(edge.getId());
+			const left = new DummyEdge(from, dummyNode), right = new DummyEdge(dummyNode, to);
+			graph.addEdge(left).addEdge(right).removeEdge(edge.getId());
 
 			edgeSubdivisions.set(edge, { left, right });
-		}
-	}
-
-	private getRowCenter(layering: Layering<Node, Edge<Node>>, rowIndex: number): number | null {
-		if(rowIndex < 0)
-			return null;
 
-		for(const layer of layering.getLayers()) {
-			const node = layer.getNodes().at(rowIndex);
-			if(node)
-				return node.getY() + node.getHeight() / 2;
 		}
-
-		return null;
-	}
-
-	private getNodeIndex(layering: Layering<Node, Edge<Node>>, node: Node) : number {
-		const layerIndex = layering.getNodeLayerIndex(node);
-		if(layerIndex === -1)
-			return -1;
-
-		return layering.getLayers()[layerIndex]!.getNodes().indexOf(node);
 	}
 }