sp-graph-layout 1.0.0__tar.gz

sp_graph_layout-1.0.0/CMakeLists.txt

@@ -0,0 +1,164 @@
+cmake_minimum_required(VERSION 4.0)
+project(GraphLayout)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+option(GRAPH_LAYOUT_ENABLE_TESTS "Build tests" OFF)
+option(GRAPH_LAYOUT_ENABLE_RANDOM_TESTS "Build random tests" OFF)
+option(GRAPH_LAYOUT_ENABLE_STRICT "Use strict compile options" OFF)
+option(GRAPH_LAYOUT_ENABLE_COVERAGE "Enable coverage reporting" OFF)
+option(GRAPH_LAYOUT_BIND_PYTHON "Enable python binding" OFF)
+option(GRAPH_LAYOUT_BIND_ES "Enable ECMAScript binding" OFF)
+
+if(APPLE)
+    set(ENV{PKG_CONFIG_PATH} "/opt/homebrew/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}")
+endif()
+
+include(FetchContent)
+
+FetchContent_Declare(
+        SVGDiagram
+        GIT_REPOSITORY https://github.com/CyberZHG/SVGDiagram.git
+        GIT_TAG v1.3.0
+)
+
+FetchContent_MakeAvailable(SVGDiagram)
+
+if(GRAPH_LAYOUT_ENABLE_STRICT)
+    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+        add_compile_options(
+                -Wall
+                -Wextra
+                -Werror
+                -Wpedantic
+                -Wmissing-include-dirs
+                -Wundef
+                -Wredundant-decls
+        )
+    endif()
+endif()
+
+if(GRAPH_LAYOUT_ENABLE_COVERAGE)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+        add_compile_options(--coverage -O0 -g)
+        add_link_options(--coverage)
+    endif()
+endif()
+
+add_library(GraphLayout STATIC
+        include/graph_layout.h
+        src/graph_layout.cpp
+        include/directed/feedback_arcs.h
+        src/directed/feedback_arcs.cpp
+        include/common/graph_def.h
+        src/common/graph_def.cpp
+        include/directed/layer_assignment.h
+        src/directed/layer_assignment.cpp
+        src/common/graph_def_splitter.cpp
+        include/directed/cross_minimization.h
+        src/directed/cross_minimization.cpp
+        include/common/binary_indexed_tree.h
+        src/common/binary_indexed_tree.cpp
+        include/directed/vertex_positioning.h
+        src/directed/vertex_positioning.cpp
+        include/common/graph_attributes.h
+        src/common/graph_attributes.cpp
+        include/common/compare_svg.h
+        src/common/compare_svg.cpp
+)
+
+target_include_directories(GraphLayout
+        PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+target_link_libraries(GraphLayout
+        PRIVATE SVGDiagram
+)
+
+if(GRAPH_LAYOUT_ENABLE_TESTS)
+    enable_testing()
+
+    FetchContent_Declare(
+            googletest
+            GIT_REPOSITORY https://github.com/google/googletest.git
+            GIT_TAG v1.17.0
+    )
+
+    FetchContent_MakeAvailable(googletest)
+
+    add_executable(runTests
+            tests/test_main.cpp
+            tests/feedback_arcs/test_eades_93.cpp
+            tests/layer_assignment/test_topological.cpp
+            tests/graph_def/test_component_splitter.cpp
+            tests/layer_assignment/test_gansner_93.cpp
+            tests/cross_minimization/test_cross_minimization.cpp
+            tests/cross_minimization/test_barycenter.cpp
+            tests/cross_minimization/test_median.cpp
+            tests/cross_minimization/test_pairwise_switch.cpp
+            tests/vertex_positioning/test_brandes_kopf.cpp
+            tests/graph_layout/test_directed_graph_hierarchical_layout.cpp
+            tests/feedback_arcs/test_min_id.cpp
+            tests/docs/test_basic.cpp
+            tests/docs/test_graph_attr.cpp
+            tests/docs/test_vertex_attr.cpp
+            tests/docs/test_edge_attr.cpp
+    )
+
+    target_link_libraries(runTests
+            PRIVATE GraphLayout
+            PRIVATE gtest gtest_main
+    )
+
+    if (GRAPH_LAYOUT_ENABLE_RANDOM_TESTS)
+        target_compile_definitions(runTests
+                PRIVATE GRAPH_LAYOUT_ENABLE_RANDOM_TESTS=ON
+        )
+    endif ()
+
+    add_test(NAME GraphLayoutTests COMMAND runTests)
+endif ()
+
+if(GRAPH_LAYOUT_BIND_PYTHON)
+    include(FetchContent)
+    FetchContent_Declare(
+            pybind11
+            GIT_REPOSITORY https://github.com/pybind/pybind11.git
+            GIT_TAG v3.0
+    )
+    FetchContent_MakeAvailable(pybind11)
+
+    pybind11_add_module(_core
+            python/bindings.cpp
+    )
+    target_link_libraries(_core
+            PRIVATE GraphLayout
+    )
+    install(TARGETS _core
+            LIBRARY DESTINATION sp_graph_layout)
+    install(FILES python/wrapper/__init__.py DESTINATION sp_graph_layout)
+endif()
+
+if (GRAPH_LAYOUT_BIND_ES)
+
+    add_executable(GraphLayoutWASM
+            wasm/graph_layout_wasm.cpp)
+
+    target_link_libraries(GraphLayoutWASM
+            PRIVATE GraphLayout
+    )
+
+    target_compile_options(GraphLayoutWASM PRIVATE "-O3")
+
+    set_target_properties(GraphLayoutWASM PROPERTIES SUFFIX ".js")
+
+    target_link_options(GraphLayoutWASM PRIVATE
+            "--bind"
+            "-sMODULARIZE=1"
+            "-sEXPORT_ES6=1"
+            "-sEXPORT_NAME=GraphLayoutWASMModule"
+    )
+endif ()

sp_graph_layout-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 - Present CyberZHG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sp_graph_layout-1.0.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.2
+Name: sp-graph-layout
+Version: 1.0.0
+Summary: A library for visualizing directed graphs.
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://github.com/CyberZHG/GraphLayout
+Project-URL: Repository, https://github.com/CyberZHG/GraphLayout
+Project-URL: Issues, https://github.com/CyberZHG/GraphLayout/issues
+Project-URL: Documentation, https://cyberzhg.github.io/GraphLayout/
+Requires-Python: >=3.8
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: black; extra == "test"
+Requires-Dist: isort; extra == "test"
+Requires-Dist: flake8; extra == "test"
+Description-Content-Type: text/markdown
+
+Graph Layout
+============
+
+## Overview
+
+A library for visualizing directed graphs.
+
+|                                   rank dir = TB                                    |                                   rank dir = LR                                    |
+|:----------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------:|
+| ![](https://github.com/CyberZHG/GraphLayout/blob/main/docs/images/example1_tb.svg) | ![](https://github.com/CyberZHG/GraphLayout/blob/main/docs/images/example1_lr.svg) |
+| ![](https://github.com/CyberZHG/GraphLayout/blob/main/docs/images/example2_tb.svg) | ![](https://github.com/CyberZHG/GraphLayout/blob/main/docs/images/example2_lr.svg) |
+
+## Documentation
+
+* [Documentation](https://cyberzhg.github.io/GraphLayout/)
+
+    * [Installation](https://cyberzhg.github.io/GraphLayout/install.html)
+    * [Basic Concepts](https://cyberzhg.github.io/GraphLayout/basic.html)
+    * [Graph Attributes](https://cyberzhg.github.io/GraphLayout/graph_attr.html)
+    * [Vertex Attributes](https://cyberzhg.github.io/GraphLayout/vertex_attr.html)
+    * [Edge Attributes](https://cyberzhg.github.io/GraphLayout/edge_attr.html)

sp_graph_layout-1.0.0/README.md

@@ -0,0 +1,28 @@
+Graph Layout
+============
+
+[![C++ Unit Tests](https://github.com/CyberZHG/GraphLayout/actions/workflows/cpp-unit-test.yml/badge.svg)](https://github.com/CyberZHG/GraphLayout/actions/workflows/cpp-unit-test.yml)
+[![Python Build & Test](https://github.com/CyberZHG/GraphLayout/actions/workflows/python-build-test.yml/badge.svg)](https://github.com/CyberZHG/GraphLayout/actions/workflows/python-build-test.yml)
+[![WASM Build & Test](https://github.com/CyberZHG/GraphLayout/actions/workflows/wasm-build-test.yml/badge.svg)](https://github.com/CyberZHG/GraphLayout/actions/workflows/wasm-build-test.yml)
+[![Deploy Docs to GitHub Pages](https://github.com/CyberZHG/GraphLayout/actions/workflows/deploy-docs.yml/badge.svg)](https://github.com/CyberZHG/GraphLayout/actions/workflows/deploy-docs.yml)
+[![PyPI version](https://img.shields.io/pypi/v/sp-graph-layout.svg)](https://pypi.org/project/sp-graph-layout/)
+[![npm version](https://img.shields.io/npm/v/sp-graph-layout.svg)](https://www.npmjs.com/package/sp-graph-layout)
+
+## Overview
+
+A library for visualizing directed graphs.
+
+|         rank dir = TB          |         rank dir = LR          |
+|:------------------------------:|:------------------------------:|
+| ![](docs/images/example1_tb.svg) | ![](docs/images/example1_lr.svg) |
+| ![](docs/images/example2_tb.svg) | ![](docs/images/example2_lr.svg) |
+
+## Documentation
+
+* [Documentation](https://cyberzhg.github.io/GraphLayout/)
+
+  * [Installation](https://cyberzhg.github.io/GraphLayout/install.html)
+  * [Basic Concepts](https://cyberzhg.github.io/GraphLayout/basic.html)
+  * [Graph Attributes](https://cyberzhg.github.io/GraphLayout/graph_attr.html)
+  * [Vertex Attributes](https://cyberzhg.github.io/GraphLayout/vertex_attr.html)
+  * [Edge Attributes](https://cyberzhg.github.io/GraphLayout/edge_attr.html)

sp_graph_layout-1.0.0/include/common/binary_indexed_tree.h

@@ -0,0 +1,38 @@
+#ifndef GRAPHLAYOUT_BINARY_INDEXED_TREE_H
+#define GRAPHLAYOUT_BINARY_INDEXED_TREE_H
+
+#include <vector>
+
+namespace graph_layout {
+
+    class BinaryIndexedTree {
+    public:
+        explicit BinaryIndexedTree(size_t n);
+        ~BinaryIndexedTree() = default;
+
+        /** Add a number to a binary indexed tree.
+         *
+         * @param index The index to add the value.
+         * @param val The value to add.
+         */
+        void add(int index, int val = 1);
+
+        /** Get the prefix sum from a binary indexed tree.
+         *
+         * @param index The index of the last element, inclusive.
+         * @return The prefix sum.
+         */
+        [[nodiscard]] long long prefixSum(int index) const;
+
+        void clear();
+        void clear(size_t n);
+
+    private:
+        std::vector<long long> _bit;
+
+        static int next(int index);
+    };
+
+};
+
+#endif //GRAPHLAYOUT_BINARY_INDEXED_TREE_H

sp_graph_layout-1.0.0/include/common/compare_svg.h

@@ -0,0 +1,17 @@
+#ifndef GRAPHLAYOUT_COMPARE_SVG_H
+#define GRAPHLAYOUT_COMPARE_SVG_H
+
+#include <string>
+
+namespace graph_layout {
+    /** A helper function for unit tests only.
+     *
+     * @param a
+     * @param b
+     * @return Whether the two input SVGs are the same.
+     */
+    bool _compareSVG(const std::string& a, const std::string& b);
+}
+
+
+#endif //GRAPHLAYOUT_COMPARE_SVG_H

sp_graph_layout-1.0.0/include/common/graph_attributes.h

@@ -0,0 +1,96 @@
+#ifndef GRAPHLAYOUT_GRAPH_ATTRIBUTES_H
+#define GRAPHLAYOUT_GRAPH_ATTRIBUTES_H
+
+#include <string>
+#include <unordered_map>
+
+namespace graph_layout {
+
+    constexpr std::string ATTRIBUTE_KEY_BG_COLOR = "bgcolor";
+    constexpr std::string ATTRIBUTE_KEY_RANK_DIR = "rankdir";
+    constexpr std::string ATTRIBUTE_KEY_LABEL = "label";
+    constexpr std::string ATTRIBUTE_KEY_SHAPE = "shape";
+    constexpr std::string ATTRIBUTE_KEY_FONT_NAME = "fontname";
+    constexpr std::string ATTRIBUTE_KEY_FONT_SIZE = "fontsize";
+    constexpr std::string ATTRIBUTE_KEY_WIDTH = "width";
+    constexpr std::string ATTRIBUTE_KEY_HEIGHT = "height";
+
+    class Attribute {
+    public:
+        Attribute();
+        explicit Attribute(const std::string& value);
+        ~Attribute() = default;
+
+        void set(const std::string& value);
+        [[nodiscard]] const std::string& value() const;
+
+    protected:
+        std::string _raw;
+    };
+
+    class AttributeColor : public Attribute {
+    public:
+        using Attribute::Attribute;
+
+        [[nodiscard]] static std::tuple<double, double, double> toRGB(const std::string& raw);
+    };
+
+    class AttributeRankDir : public Attribute {
+    public:
+        using Attribute::Attribute;
+
+        static const std::string TOP_TO_BOTTOM;
+        static const std::string BOTTOM_TO_TOP;
+        static const std::string LEFT_TO_RIGHT;
+        static const std::string RIGHT_TO_LEFT;
+    };
+
+    class AttributeShape : public Attribute {
+    public:
+        using Attribute::Attribute;
+
+        static const std::string NONE;
+        static const std::string CIRCLE;
+        static const std::string DOUBLE_CIRCLE;
+        static const std::string ELLIPSE;
+        static const std::string RECT;
+    };
+
+    class Attributes {
+    public:
+        Attributes() = default;
+        ~Attributes() = default;
+
+        [[nodiscard]] std::string graphAttributes(const std::string& key) const;
+        void setGraphAttributes(const std::string& key, const std::string& value);
+        void setGraphAttributes(const std::unordered_map<std::string, std::string> &attributes);
+
+        [[nodiscard]] std::string vertexAttributes(int u, const std::string& key) const;
+        void setVertexAttributes(int u, const std::string& key, const std::string& value);
+        void setVertexAttributes(int u, const std::unordered_map<std::string, std::string> &attributes);
+
+        [[nodiscard]] std::string edgeAttributes(int u, const std::string& key) const;
+        void setEdgeAttributes(int u, const std::string& key, const std::string& value);
+        void setEdgeAttributes(int u, const std::unordered_map<std::string, std::string>& mapping);
+        void transferEdgeAttributes(int u, int v);
+
+        [[nodiscard]] std::string rankDir() const;
+        void setRankDir(const std::string& value);
+
+        void setVertexShape(int u, const std::string& value);
+
+    private:
+        static std::unordered_map<std::string, std::string> DEFAULT_GRAPH_ATTRIBUTE_VALUES;
+        static std::unordered_map<std::string, std::string> DEFAULT_VERTEX_ATTRIBUTE_VALUES;
+        static std::unordered_map<std::string, std::string> DEFAULT_EDGE_ATTRIBUTE_VALUES;
+
+        std::unordered_map<std::string, std::string> _graphAttributes;
+        std::unordered_map<std::string, std::string> _vertexGlobalAttributes;
+        std::unordered_map<int, std::unordered_map<std::string, std::string>> _vertexAttributes;
+        std::unordered_map<std::string, std::string> _edgeGlobalAttributes;
+        std::unordered_map<int, std::unordered_map<std::string, std::string>> _edgeAttributes;
+    };
+
+}
+
+#endif //GRAPHLAYOUT_GRAPH_ATTRIBUTES_H

sp_graph_layout-1.0.0/include/common/graph_def.h

@@ -0,0 +1,149 @@
+#ifndef GRAPHLAYOUT_GRAPH_DEF_H
+#define GRAPHLAYOUT_GRAPH_DEF_H
+
+#include <vector>
+#include <unordered_set>
+#include <unordered_map>
+#include <memory>
+
+namespace graph_layout {
+
+    class EdgeIterationWithIDs;
+
+    struct SPEdge {
+        int id, u, v;
+
+        bool operator==(const SPEdge&) const;
+    };
+
+    struct SPVirtualEdge {
+        SPEdge originalEdge;
+        std::vector<int> virtualEdgeIds;
+    };
+
+    class SPDirectedGraph {
+    public:
+        explicit SPDirectedGraph(size_t numVertices);
+        ~SPDirectedGraph() = default;
+
+        void updateNumVertices(size_t numVertices);
+        [[nodiscard]] size_t numVertices() const { return _numVertices; }
+        [[nodiscard]] size_t numEdges() const { return _edges.size(); }
+        [[nodiscard]] const std::vector<SPEdge>& edges() const { return _edges; }
+        std::vector<SPEdge>& edges() { return _edges;}
+
+        void addEdge(const SPEdge& edge);
+        int addEdge(int u, int v);
+        void addEdges(const std::vector<std::pair<int ,int>>& edges);
+        void addOutEdges(int u, const std::vector<int>& vertices);
+        SPEdge& getEdge(int id);
+        void removeEdge(int id);
+
+        bool operator==(const SPDirectedGraph& other) const;
+
+        void disableSelfCycleEdges();
+        void enableSelfCycleEdges();
+
+        void reverseEdges(const std::unordered_set<int>& ids);
+        void reverseEdgesBack();
+        [[nodiscard]] bool isReverseEdge(int id) const;
+
+        void sortEdgesById();
+        const std::unordered_map<int, size_t>& getEdgeIdToIndexMap();
+        const std::vector<int>& getInDegrees();
+        const std::vector<int>& getOutDegrees();
+        const std::vector<std::vector<int>>& getInVertices();
+        const std::vector<std::vector<int>>& getOutVertices();
+        std::vector<std::vector<int>>& getInEdgeIdsRef();
+        std::vector<std::vector<int>>& getOutEdgeIdsRef();
+        const std::vector<std::vector<int>>& getInEdgeIds();
+        const std::vector<std::vector<int>>& getOutEdgeIds();
+        EdgeIterationWithIDs getInEdges(int v);
+        EdgeIterationWithIDs getOutEdges(int u);
+        bool hasCycle();
+
+        [[nodiscard]] SPDirectedGraph buildSpanningTree(const std::vector<int>& parents);
+
+    private:
+        size_t _numVertices{};
+        std::vector<SPEdge> _edges;
+
+        bool _edgeIdToIndexMapInitialized = false;
+        std::unordered_map<int, size_t> _edgeIdToIndexMap;
+
+        bool _degreesInitialized = false;
+        std::vector<int> _inDegrees;
+        std::vector<int> _outDegrees;
+
+        bool _inOutVerticesInitialized = false;
+        std::vector<std::vector<int>> _inVertices;
+        std::vector<std::vector<int>> _outVertices;
+
+        bool _inOutEdgesInitialized = false;
+        std::vector<std::vector<int>> _inEdges;
+        std::vector<std::vector<int>> _outEdges;
+
+        bool _hasCycleInitialized = false;
+        bool _hasCycle = false;
+
+        std::vector<SPEdge> _selfCycleEdges;
+
+        std::unordered_set<int> _reverseIds;
+
+        void resetInitialization();
+        void initializeDegrees();
+        void initializeInOutVertices();
+        void initializeInOutEdges();
+        void initializeHasCycle();
+    };
+
+    class EdgeIterationWithIDs {
+    public:
+        EdgeIterationWithIDs(SPDirectedGraph& graph, const std::vector<int>& ids) : _graph(graph), _ids(ids) {}
+
+        class iterator {
+        public:
+            explicit iterator(SPDirectedGraph& graph, const std::vector<int>& ids, const int index) : _graph(graph), _ids(ids), _index(index) {}
+            const SPEdge &operator*() const;
+            iterator& operator++() { ++_index; return *this; }
+            bool operator!=(const iterator& other) const { return _index != other._index; }
+        private:
+            SPDirectedGraph& _graph;
+            const std::vector<int>& _ids;
+            int _index;
+        };
+
+        [[nodiscard]] iterator begin() const { return iterator(_graph, _ids, 0); }
+        [[nodiscard]] iterator end() const { return iterator(_graph, _ids, static_cast<int>(_ids.size())); }
+    private:
+        SPDirectedGraph &_graph;
+        const std::vector<int> &_ids;
+    };
+
+    class RandomSimpleDirectedGraphGenerator {
+    public:
+        explicit RandomSimpleDirectedGraphGenerator(const int maxNumVertices) : _minNumVertices(1), _maxNumVertices(maxNumVertices), _allowSelfCycle(false) {}
+
+        [[nodiscard]] SPDirectedGraph generateRandomGraph() const;
+        [[nodiscard]] SPDirectedGraph generateRandomGraphWithoutDuplicateEdge() const;
+    private:
+        int _minNumVertices;
+        int _maxNumVertices;
+        bool _allowSelfCycle;
+    };
+
+    class GraphComponentSplitter {
+    public:
+        static std::vector<int> getConnectedComponents(const SPDirectedGraph& graph);
+        std::vector<SPDirectedGraph>& splitGraph(const SPDirectedGraph& graph);
+        [[nodiscard]] SPDirectedGraph mergeBack() const;
+        [[nodiscard]] int originalVertexId(int groupIndex, int u) const;
+
+    private:
+        std::vector<SPDirectedGraph> _graphs;
+        std::vector<std::vector<int>> _groups;
+    };
+
+}
+
+#endif //GRAPHLAYOUT_GRAPH_DEF_H

sp_graph_layout-1.0.0/include/directed/cross_minimization.h

@@ -0,0 +1,106 @@
+#ifndef GRAPHLAYOUT_CROSS_MINIMIZATION_H
+#define GRAPHLAYOUT_CROSS_MINIMIZATION_H
+
+#include "common/graph_def.h"
+#include "common/binary_indexed_tree.h"
+#include <functional>
+
+namespace graph_layout {
+
+    /** The struct for storing the results of cross minimization */
+    struct SPLayering {
+        // Discrete ranks for each layer.
+        std::vector<int> layerRanks;
+        // Vertex order within each layer.
+        std::vector<std::vector<int>> orders;
+        // Mapping from a vertex ID to its index in the corresponding layer.
+        std::vector<std::unordered_map<int, int>> positions;
+        // Mapping from a vertex ID to the layer it belongs to.
+        std::unordered_map<int, int> idToLayer;
+        // Maximum number of vertices in each layer.
+        size_t width;
+
+        /** Initialize the two mappings in this struct.
+         *
+         * Note that we only guarantee that the mappings are initialized
+         * in the return values of `CrossMinimization`.
+         */
+        void initializeMapping();
+    };
+
+    enum class CrossMinimizationMethod {
+        // Barycenter heuristic.
+        BARYCENTER,
+        // Median heuristic.
+        MEDIAN,
+        // Greedily switch two adjacent vertices.
+        PAIRWISE_SWITCH,
+    };
+
+    /** Reduce the number of crossings between two adjacent layers. */
+    class CrossMinimization {
+    public:
+        explicit CrossMinimization(CrossMinimizationMethod method = CrossMinimizationMethod::BARYCENTER);
+        ~CrossMinimization() = default;
+
+        // The start index for virtual edges.
+        static constexpr int VIRTUAL_EDGE_ID_OFFSET = 1000000000;
+
+        void setMethod(CrossMinimizationMethod method);
+
+        /** Reduce the number of crossings between each two adjacent layers.
+         *
+         * @param graph A connected DAG.
+         * @param ranks Layer assignment of vertices.
+         * @return Orders of vertices in each layer and any virtual edges added to the graph.
+         */
+        std::pair<SPLayering, std::vector<SPVirtualEdge>> reduceNumCross(SPDirectedGraph& graph, std::vector<int>& ranks) const;
+
+        /** Add virtual edges to the graph so that no edge spans more than two layers.
+         *
+         * @param graph A connected DAG.
+         * @param ranks Layer assignment of vertices.
+         * @return Orders of vertices in each layer and any virtual edges added to the graph.
+         */
+        static std::pair<SPLayering, std::vector<SPVirtualEdge>> addVirtualEdges(SPDirectedGraph& graph, std::vector<int>& ranks);
+
+        /** Compute the total number of crossings between each two adjacent layers.
+         *
+         * This function is mainly used for testing.
+         *
+         * @param graph  A connected DAG.
+         * @param layering A cross minimization result.
+         * @return Total number of crossings.
+         */
+        static long long computeNumCross(SPDirectedGraph& graph, const SPLayering& layering);
+
+    private:
+        CrossMinimizationMethod _method;
+
+        static long long computeNumCross(
+            SPDirectedGraph &graph,
+            BinaryIndexedTree &bit,
+            const std::vector<int> &order1,
+            const std::vector<int> &order2,
+            bool forward = true);
+        static long long computeNumCross(SPDirectedGraph& graph,
+            const std::vector<std::unordered_map<int, int>> &positions,
+            std::vector<int> &adjPositionsU,
+            std::vector<int> &adjPositionsV,
+            int layerIndex, int u, int v, bool forward);
+        static long long computeNumCross(SPDirectedGraph& graph,
+            const std::vector<std::unordered_map<int, int>> &positions,
+            std::vector<int> &adjPositionsU,
+            std::vector<int> &adjPositionsV,
+            int layerIndex, int u, int v);
+
+        static void reduceNumCrossWithWeightingHeuristic(SPDirectedGraph& graph, SPLayering& layering,
+            const std::function<double(SPDirectedGraph&, const std::unordered_map<int, int>&, int, bool)> &weighting);
+        static void reduceNumCrossWithBaryCenterHeuristic(SPDirectedGraph& graph, SPLayering& layering);
+        static void reduceNumCrossWithMedianHeuristic(SPDirectedGraph& graph, SPLayering& layering);
+        static void reduceNumCrossWithPairwiseSwitchHeuristic(SPDirectedGraph& graph, SPLayering& layering);
+    };
+
+}
+
+#endif //GRAPHLAYOUT_CROSS_MINIMIZATION_H