GraphAttributes.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphList.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/geometry.h>
#include <ogdf/basic/graphics.h>
#include <ogdf/basic/internal/graph_iterators.h>
 
#include <cstdint>
#include <string>
 
namespace ogdf {
template<class E>
class List;
 
 
class OGDF_EXPORT GraphAttributes {
protected:
    const Graph* m_pGraph; 
 
    bool m_directed; 
 
    // graphical representation of nodes
    NodeArray<double> m_x; 
    NodeArray<double> m_y; 
    NodeArray<double> m_z; 
    NodeArray<double> m_nodeLabelPosX; 
    NodeArray<double> m_nodeLabelPosY; 
    NodeArray<double> m_nodeLabelPosZ; 
    NodeArray<double> m_width; 
    NodeArray<double> m_height; 
    NodeArray<Shape> m_nodeShape; 
    NodeArray<string> m_nodeLabel; 
    NodeArray<Stroke> m_nodeStroke; 
    NodeArray<Fill> m_nodeFill; 
    NodeArray<string> m_nodeTemplate; 
 
    // other node attributes
    NodeArray<int> m_nodeId; 
    NodeArray<int> m_nodeIntWeight; 
    NodeArray<Graph::NodeType> m_vType; 
 
    // graphical representation of edges
    EdgeArray<DPolyline> m_bends; 
    EdgeArray<string> m_edgeLabel; 
    EdgeArray<EdgeArrow> m_edgeArrow; 
    EdgeArray<Stroke> m_edgeStroke; 
 
    // other edge attributes
    EdgeArray<int> m_intWeight; 
    EdgeArray<double> m_doubleWeight; 
    EdgeArray<Graph::EdgeType> m_eType; 
    EdgeArray<uint32_t> m_subGraph; 
 
    long m_attributes; 
 
public:
 
    static const long nodeGraphics;
 
    static const long edgeGraphics;
 
    static const long edgeIntWeight;
 
    static const long edgeDoubleWeight;
 
    static const long edgeLabel;
 
    static const long nodeLabel;
 
    static const long edgeType;
 
    static const long nodeType;
 
    static const long nodeId;
 
    static const long edgeArrow;
 
    static const long edgeStyle;
 
    static const long nodeStyle;
 
    static const long nodeTemplate;
 
    static const long edgeSubGraphs;
 
    static const long nodeWeight;
 
    static const long threeD;
 
    static const long nodeLabelPosition;
 
    static const long all;
 
 
 
 
    GraphAttributes();
 
 
    explicit GraphAttributes(const Graph& G, long attr = nodeGraphics | edgeGraphics);
 
    virtual ~GraphAttributes() = default;
 
    long attributes() const { return m_attributes; }
 
    inline bool has(long attr) const { return (m_attributes & attr) == attr; }
 
 
    virtual void init(const Graph& G, long attr);
 
    void init(long attr);
 
    void addAttributes(long attr);
 
    void destroyAttributes(long attr);
 
    const Graph& constGraph() const { return *m_pGraph; }
 
 
 
    bool directed() const { return m_directed; }
 
    bool& directed() { return m_directed; }
 
 
 
 
    double x(node v) const {
        OGDF_ASSERT(has(nodeGraphics));
        return m_x[v];
    }
 
 
    double& x(node v) {
        OGDF_ASSERT(has(nodeGraphics));
        return m_x[v];
    }
 
 
    double y(node v) const {
        OGDF_ASSERT(has(nodeGraphics));
        return m_y[v];
    }
 
 
    double& y(node v) {
        OGDF_ASSERT(has(nodeGraphics));
        return m_y[v];
    }
 
 
    double z(node v) const {
        OGDF_ASSERT(has(threeD));
        return m_z[v];
    }
 
 
    double& z(node v) {
        OGDF_ASSERT(has(threeD));
        return m_z[v];
    }
 
 
    double xLabel(node v) const {
        OGDF_ASSERT(has(nodeLabelPosition));
        return m_nodeLabelPosX[v];
    }
 
 
    double& xLabel(node v) {
        OGDF_ASSERT(has(nodeLabelPosition));
        return m_nodeLabelPosX[v];
    }
 
 
    double yLabel(node v) const {
        OGDF_ASSERT(has(nodeLabelPosition));
        return m_nodeLabelPosY[v];
    }
 
 
    double& yLabel(node v) {
        OGDF_ASSERT(has(nodeLabelPosition));
        return m_nodeLabelPosY[v];
    }
 
 
    double zLabel(node v) const {
        OGDF_ASSERT(has(nodeLabelPosition));
        OGDF_ASSERT(has(threeD));
        return m_nodeLabelPosZ[v];
    }
 
 
    double& zLabel(node v) {
        OGDF_ASSERT(has(nodeLabelPosition));
        OGDF_ASSERT(has(threeD));
        return m_nodeLabelPosZ[v];
    }
 
 
    double width(node v) const {
        OGDF_ASSERT(has(nodeGraphics));
        return m_width[v];
    }
 
 
    double& width(node v) {
        OGDF_ASSERT(has(nodeGraphics));
        return m_width[v];
    }
 
 
    const NodeArray<double>& width() const {
        OGDF_ASSERT(has(nodeGraphics));
        return m_width;
    }
 
 
    NodeArray<double>& width() {
        OGDF_ASSERT(has(nodeGraphics));
        return m_width;
    }
 
 
    double height(node v) const {
        OGDF_ASSERT(has(nodeGraphics));
        return m_height[v];
    }
 
 
    double& height(node v) {
        OGDF_ASSERT(has(nodeGraphics));
        return m_height[v];
    }
 
 
    const NodeArray<double>& height() const {
        OGDF_ASSERT(has(nodeGraphics));
        return m_height;
    }
 
 
    NodeArray<double>& height() {
        OGDF_ASSERT(has(nodeGraphics));
        return m_height;
    }
 
 
    Shape shape(node v) const {
        OGDF_ASSERT(has(nodeGraphics));
        return m_nodeShape[v];
    }
 
 
    Shape& shape(node v) {
        OGDF_ASSERT(has(nodeGraphics));
        return m_nodeShape[v];
    }
 
 
    StrokeType strokeType(node v) const {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeStroke[v].m_type;
    }
 
 
    StrokeType& strokeType(node v) {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeStroke[v].m_type;
    }
 
 
    const Color& strokeColor(node v) const {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeStroke[v].m_color;
    }
 
 
    Color& strokeColor(node v) {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeStroke[v].m_color;
    }
 
 
    float strokeWidth(node v) const {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeStroke[v].m_width;
    }
 
 
    float& strokeWidth(node v) {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeStroke[v].m_width;
    }
 
 
    FillPattern fillPattern(node v) const {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeFill[v].m_pattern;
    }
 
 
    FillPattern& fillPattern(node v) {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeFill[v].m_pattern;
    }
 
 
    const Color& fillColor(node v) const {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeFill[v].m_color;
    }
 
 
    Color& fillColor(node v) {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeFill[v].m_color;
    }
 
 
    const Color& fillBgColor(node v) const {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeFill[v].m_bgColor;
    }
 
 
    Color& fillBgColor(node v) {
        OGDF_ASSERT(has(nodeStyle));
        return m_nodeFill[v].m_bgColor;
    }
 
 
    const string& label(node v) const {
        OGDF_ASSERT(has(nodeLabel));
        return m_nodeLabel[v];
    }
 
 
    string& label(node v) {
        OGDF_ASSERT(has(nodeLabel));
        return m_nodeLabel[v];
    }
 
 
    const string& templateNode(node v) const {
        OGDF_ASSERT(has(nodeTemplate));
        return m_nodeTemplate[v];
    }
 
 
    string& templateNode(node v) {
        OGDF_ASSERT(has(nodeTemplate));
        return m_nodeTemplate[v];
    }
 
 
    int weight(node v) const {
        OGDF_ASSERT(has(nodeWeight));
        return m_nodeIntWeight[v];
    }
 
 
    int& weight(node v) {
        OGDF_ASSERT(has(nodeWeight));
        return m_nodeIntWeight[v];
    }
 
 
    Graph::NodeType type(node v) const {
        OGDF_ASSERT(has(nodeType));
        return m_vType.valid() ? m_vType[v] : Graph::NodeType::vertex;
    }
 
 
    Graph::NodeType& type(node v) {
        OGDF_ASSERT(has(nodeType));
        return m_vType[v];
    }
 
 
    int idNode(node v) const {
        OGDF_ASSERT(has(nodeId));
        return m_nodeId[v] == -1 ? v->index() : m_nodeId[v];
    }
 
 
    int& idNode(node v) {
        OGDF_ASSERT(has(nodeId));
        if (m_nodeId[v] == -1) {
            m_nodeId[v] = v->index();
        }
        return m_nodeId[v];
    }
 
 
 
 
 
    const DPolyline& bends(edge e) const {
        OGDF_ASSERT(has(edgeGraphics));
        return m_bends[e];
    }
 
 
    DPolyline& bends(edge e) {
        OGDF_ASSERT(has(edgeGraphics));
        return m_bends[e];
    }
 
 
    EdgeArrow arrowType(edge e) const {
        OGDF_ASSERT(has(edgeArrow));
        return m_edgeArrow[e];
    }
 
 
    EdgeArrow& arrowType(edge e) {
        OGDF_ASSERT(has(edgeArrow));
        return m_edgeArrow[e];
    }
 
 
    EdgeArrow effectiveArrowType(edge e) const {
        if (!has(edgeArrow) || arrowType(e) == EdgeArrow::Undefined) {
            if (has(edgeType)) {
                if (type(e) == Graph::EdgeType::generalization) {
                    return EdgeArrow::Last;
                } else {
                    return EdgeArrow::None;
                }
            } else {
                if (directed()) {
                    return EdgeArrow::Last;
                } else {
                    return EdgeArrow::None;
                }
            }
        } else {
            return arrowType(e);
        }
    }
 
 
    StrokeType strokeType(edge e) const {
        OGDF_ASSERT(has(edgeStyle));
        return m_edgeStroke[e].m_type;
    }
 
 
    StrokeType& strokeType(edge e) {
        OGDF_ASSERT(has(edgeStyle));
        return m_edgeStroke[e].m_type;
    }
 
 
    const Color& strokeColor(edge e) const {
        OGDF_ASSERT(has(edgeStyle));
        return m_edgeStroke[e].m_color;
    }
 
 
    Color& strokeColor(edge e) {
        OGDF_ASSERT(has(edgeStyle));
        return m_edgeStroke[e].m_color;
    }
 
 
    float strokeWidth(edge e) const {
        OGDF_ASSERT(has(edgeStyle));
        return m_edgeStroke[e].m_width;
    }
 
 
    float& strokeWidth(edge e) {
        OGDF_ASSERT(has(edgeStyle));
        return m_edgeStroke[e].m_width;
    }
 
 
    const string& label(edge e) const {
        OGDF_ASSERT(has(edgeLabel));
        return m_edgeLabel[e];
    }
 
 
    string& label(edge e) {
        OGDF_ASSERT(has(edgeLabel));
        return m_edgeLabel[e];
    }
 
 
    int intWeight(edge e) const {
        OGDF_ASSERT(has(edgeIntWeight));
        return m_intWeight[e];
    }
 
 
    int& intWeight(edge e) {
        OGDF_ASSERT(has(edgeIntWeight));
        return m_intWeight[e];
    }
 
 
    double doubleWeight(edge e) const {
        OGDF_ASSERT(has(edgeDoubleWeight));
        return m_doubleWeight[e];
    }
 
 
    double& doubleWeight(edge e) {
        OGDF_ASSERT(has(edgeDoubleWeight));
        return m_doubleWeight[e];
    }
 
 
    Graph::EdgeType type(edge e) const {
        OGDF_ASSERT(has(edgeType));
        return m_eType.valid() ? m_eType[e] : Graph::EdgeType::association;
    }
 
 
    Graph::EdgeType& type(edge e) {
        OGDF_ASSERT(has(edgeType));
        return m_eType[e];
    }
 
 
    uint32_t subGraphBits(edge e) const {
        OGDF_ASSERT(has(edgeSubGraphs));
        return m_subGraph[e];
    }
 
 
    uint32_t& subGraphBits(edge e) {
        OGDF_ASSERT(has(edgeSubGraphs));
        return m_subGraph[e];
    }
 
 
    bool inSubGraph(edge e, int n) const {
        OGDF_ASSERT(has(edgeSubGraphs));
        OGDF_ASSERT(n >= 0);
        OGDF_ASSERT(n < 32);
        return (m_subGraph[e] & (1 << n)) != 0;
    }
 
 
    void addSubGraph(edge e, int n) {
        OGDF_ASSERT(has(edgeSubGraphs));
        OGDF_ASSERT(n >= 0);
        OGDF_ASSERT(n < 32);
        m_subGraph[e] |= (1 << n);
    }
 
 
    void removeSubGraph(edge e, int n) {
        OGDF_ASSERT(has(edgeSubGraphs));
        OGDF_ASSERT(n >= 0);
        OGDF_ASSERT(n < 32);
        m_subGraph[e] &= ~(1 << n);
    }
 
 
 
 
    virtual void scale(double sx, double sy, bool scaleNodes = true);
 
 
    virtual void scale(double s, bool scaleNodes = true) { scale(s, s, scaleNodes); }
 
 
    virtual void translate(double dx, double dy);
 
    virtual void translateToNonNeg();
 
 
    virtual void flipVertical() { flipVertical(boundingBox()); }
 
 
    virtual void flipVertical(const DRect& box);
 
 
    virtual void flipHorizontal() { flipHorizontal(boundingBox()); }
 
 
    virtual void flipHorizontal(const DRect& box);
 
 
    virtual void scaleAndTranslate(double sx, double sy, double dx, double dy,
            bool scaleNodes = true);
 
 
    virtual void scaleAndTranslate(double s, double dx, double dy, bool scaleNodes = true) {
        scaleAndTranslate(s, s, dx, dy, scaleNodes);
    }
 
    virtual void rotateRight90();
 
    virtual void rotateLeft90();
 
 
 
    template<typename T>
    using NodeAttributeGetter = T (GraphAttributes::*)(node) const;
 
    template<typename T>
    using EdgeAttributeGetter = T (GraphAttributes::*)(edge) const;
 
 
    template<typename T>
    bool isUniformForNodes(NodeAttributeGetter<T> attribute) const {
        OGDF_ASSERT(attribute != nullptr);
        if (constGraph().numberOfNodes() == 0) {
            return true;
        }
 
        T firstAttr = (this->*attribute)(*constGraph().nodes.begin());
        for (node n : constGraph().nodes) {
            if ((this->*attribute)(n) != firstAttr) {
                return false;
            }
        }
        return true;
    }
 
 
    template<typename T>
    bool isUniformForEdges(EdgeAttributeGetter<T> attribute) const {
        OGDF_ASSERT(attribute != nullptr);
        if (constGraph().numberOfEdges() == 0) {
            return true;
        }
 
        T firstAttr = (this->*attribute)(*constGraph().edges.begin());
        for (edge e : constGraph().edges) {
            if ((this->*attribute)(e) != firstAttr) {
                return false;
            }
        }
        return true;
    }
 
    bool isUniform(long attributes) const;
 
    inline DPoint point(node v) const { return DPoint(m_x[v], m_y[v]); }
 
 
    void transferToOriginal(GraphAttributes& origAttr) const;
 
 
    void transferToCopy(GraphAttributes& copyAttr) const;
 
 
    virtual DRect boundingBox() const;
 
 
    template<class Rectangle = DRect>
    void nodeBoundingBoxes(NodeArray<Rectangle>& boundingBoxes) const {
        for (node v : constGraph().nodes) {
            double vHalfWidth = width(v) / 2.0;
            double vHalfHeight = height(v) / 2.0;
            boundingBoxes[v] = Rectangle(x(v) - vHalfWidth, y(v) - vHalfHeight, x(v) + vHalfWidth,
                    y(v) + vHalfHeight);
        }
    }
 
 
    void setAllWidth(double w);
 
 
    void setAllHeight(double h);
 
 
    void clearAllBends();
 
 
    void removeUnnecessaryBendsHV();
 
 
    void addNodeCenter2Bends(int mode = 1);
 
 
    bool isAssociationClass(node v) const { return type(v) == Graph::NodeType::associationClass; }
 
 
    int hierarchyList(List<List<node>*>& list) const;
 
 
    int hierarchyList(List<List<edge>*>& list) const;
 
 
private:
    void copyNodeAttributes(GraphAttributes& toAttr, node vFrom, node vTo, long attrs) const;
 
    void copyEdgeAttributes(GraphAttributes& toAttr, edge eFrom, edge eTo, long attrs) const;
};
 
}