ArrayGraph.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphList.h>
#include <ogdf/energybased/fast_multipole_embedder/EdgeChain.h>
 
#include <cstdint>
#include <functional>
 
namespace ogdf {
class GraphAttributes;
 
namespace fast_multipole_embedder {
 
class ArrayGraph {
public:
    ArrayGraph();
 
    ArrayGraph(uint32_t maxNumNodes, uint32_t maxNumEdges);
 
    ArrayGraph(const GraphAttributes& GA, const EdgeArray<float>& edgeLength,
            const NodeArray<float>& nodeSize);
 
    ~ArrayGraph();
 
    inline uint32_t numNodes() const { return m_numNodes; }
 
    inline uint32_t numEdges() const { return m_numEdges; }
 
 
    void readFrom(const GraphAttributes& GA, const EdgeArray<float>& edgeLength,
            const NodeArray<float>& nodeSize);
 
 
    template<typename CoordinateType, typename LengthType, typename SizeType>
    void readFrom(const Graph& G, NodeArray<CoordinateType>& xPos, NodeArray<CoordinateType>& yPos,
            const EdgeArray<LengthType>& edgeLength, const NodeArray<SizeType>& nodeSize) {
        m_numNodes = 0;
        m_numEdges = 0;
        NodeArray<uint32_t> nodeIndex(G);
        m_numNodes = 0;
        m_numEdges = 0;
        m_desiredAvgEdgeLength = 0;
        m_avgNodeSize = 0;
        for (node v : G.nodes) {
            m_nodeXPos[m_numNodes] = (float)xPos[v];
            m_nodeYPos[m_numNodes] = (float)yPos[v];
            m_nodeSize[m_numNodes] = (float)nodeSize[v];
            m_avgNodeSize += nodeSize[v];
            nodeIndex[v] = m_numNodes;
            m_numNodes++;
        }
        m_avgNodeSize = m_avgNodeSize / (double)m_numNodes;
 
        for (edge e : G.edges) {
            pushBackEdge(nodeIndex[e->source()], nodeIndex[e->target()], (float)edgeLength[e]);
        }
        m_desiredAvgEdgeLength = m_desiredAvgEdgeLength / (double)m_numEdges;
    }
 
 
    void writeTo(GraphAttributes& GA);
 
 
    template<typename CoordinateType>
    void writeTo(const Graph& G, NodeArray<CoordinateType>& xPos, NodeArray<CoordinateType>& yPos) {
        uint32_t i = 0;
        for (node v : G.nodes) {
            xPos[v] = m_nodeXPos[i];
            yPos[v] = m_nodeYPos[i];
            i++;
        }
    }
 
    inline NodeAdjInfo& nodeInfo(uint32_t i) { return m_nodeAdj[i]; }
 
    inline const NodeAdjInfo& nodeInfo(uint32_t i) const { return m_nodeAdj[i]; }
 
    inline EdgeAdjInfo& edgeInfo(uint32_t i) { return m_edgeAdj[i]; }
 
    inline const EdgeAdjInfo& edgeInfo(uint32_t i) const { return m_edgeAdj[i]; }
 
    inline NodeAdjInfo* nodeInfo() { return m_nodeAdj; }
 
    inline const NodeAdjInfo* nodeInfo() const { return m_nodeAdj; }
 
    inline EdgeAdjInfo* edgeInfo() { return m_edgeAdj; }
 
    inline const EdgeAdjInfo* edgeInfo() const { return m_edgeAdj; }
 
    inline float* nodeXPos() { return m_nodeXPos; }
 
    inline const float* nodeXPos() const { return m_nodeXPos; }
 
    inline float* nodeYPos() { return m_nodeYPos; }
 
    inline const float* nodeYPos() const { return m_nodeYPos; }
 
    inline float* nodeSize() { return m_nodeSize; }
 
    inline const float* nodeSize() const { return m_nodeSize; }
 
    inline float* nodeMoveRadius() { return m_nodeMoveRadius; }
 
    inline float* desiredEdgeLength() { return m_desiredEdgeLength; }
 
    inline const float* desiredEdgeLength() const { return m_desiredEdgeLength; }
 
    inline uint32_t firstEdgeAdjIndex(uint32_t nodeIndex) const {
        return nodeInfo(nodeIndex).firstEntry;
    };
 
    inline uint32_t nextEdgeAdjIndex(uint32_t currEdgeAdjIndex, uint32_t nodeIndex) const {
        return edgeInfo(currEdgeAdjIndex).nextEdgeAdjIndex(nodeIndex);
    }
 
    inline uint32_t twinNodeIndex(uint32_t currEdgeAdjIndex, uint32_t nodeIndex) const {
        return edgeInfo(currEdgeAdjIndex).twinNode(nodeIndex);
    }
 
    void for_all_nodes(uint32_t begin, uint32_t end, std::function<void(uint32_t)> func) {
        for (uint32_t i = begin; i <= end; i++) {
            func(i);
        }
    }
 
    inline float avgDesiredEdgeLength() const { return (float)m_desiredAvgEdgeLength; }
 
    inline float avgNodeSize() const { return (float)m_avgNodeSize; }
 
    void transform(float translate, float scale);
 
    void centerGraph();
 
private:
    void pushBackEdge(uint32_t a, uint32_t b, float desiredEdgeLength);
 
    void allocate(uint32_t numNodes, uint32_t numEdges);
 
    void deallocate();
 
    void clear() {
        for (uint32_t i = 0; i < m_numNodes; i++) {
            nodeInfo(i).degree = 0;
        }
 
        m_numNodes = 0;
        m_numEdges = 0;
    }
 
    uint32_t m_numNodes; 
    uint32_t m_numEdges; 
 
    float* m_nodeXPos; 
    float* m_nodeYPos; 
 
    float* m_nodeSize; 
    double m_avgNodeSize; 
 
    float* m_nodeMoveRadius; 
 
    float* m_desiredEdgeLength; 
    double m_desiredAvgEdgeLength; 
 
    NodeAdjInfo* m_nodeAdj; 
    EdgeAdjInfo* m_edgeAdj; 
};
 
}
}