GraphAttributes.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/

#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_ATTRIBUTED_GRAPH_H
#define OGDF_ATTRIBUTED_GRAPH_H

#include <ogdf/basic/NodeArray.h>
#include <ogdf/basic/EdgeArray.h>
#include <ogdf/basic/String.h>
#include <ogdf/basic/geometry.h>

namespace ogdf {

//---------------------------------------------------------
// GraphAttributes
// graph topology + graphical attributes
//---------------------------------------------------------

class OGDF_EXPORT GraphAttributes {
public:
    enum EdgeArrow {
        none, 
        last, 
        first, 
        both, 
        undefined
    };


    enum EdgeStyle {
        esNoPen = 0, 
        esSolid = 1, 
        esDash = 2, 
        esDot = 3, 
        esDashdot = 4, 
        esDashdotdot = 5
    };

    static EdgeStyle intToStyle(int i) {
        switch (i) {
        case 0:
            return esNoPen;
        case 1:
            return esSolid;
        case 2:
            return esDash;
        case 3:
            return esDot;
        case 4:
            return esDashdot;
        case 5:
            return esDashdotdot;
        default:
            return esNoPen;

        }
    }


    enum BrushPattern {
        bpNone = 0,
        bpSolid = 1,
        bpDense1 = 2,
        bpDense2 = 3,
        bpDense3 = 4,
        bpDense4 = 5,
        bpDense5 = 6,
        bpDense6 = 7,
        bpDense7 = 8,
        bpHorizontal = 9,
        bpVertical = 10,
        bpCross = 11,
        BackwardDiagonal = 12,
        ForwardDiagonal = 13,
        DiagonalCross = 14
    };

    static BrushPattern intToPattern(int i) {
        switch (i) {
        case 0:
            return bpNone;
            break;
        case 1:
            return bpSolid;
            break;
        case 2:
            return bpDense1;
            break;
        case 3:
            return bpDense2;
            break;
        case 4:
            return bpDense3;
            break;
        case 5:
            return bpDense4;
            break;
        case 6:
            return bpDense5;
            break;
        case 7:
            return bpDense6;
            break;
        case 8:
            return bpDense7;
            break;
        case 9:
            return bpHorizontal;
            break;
        case 10:
            return bpVertical;
            break;
        case 11:
            return bpCross;
            break;
        case 12:
            return BackwardDiagonal;
            break;
        case 13:
            return ForwardDiagonal;
            break;
        case 14:
            return DiagonalCross;
            break;
        default:
            return bpNone;
            break;
        }
    }

    enum ImageStyle {
        FreeScale = 0, FixScale = 1,
    };
    enum ImageAlignment {
        TopLeft = 0, TopCenter, TopRight, CenterLeft, Center, CenterRight, BottomLeft, BottomCenter, BottomRight
    };

    static ImageStyle intToImageStyle(int i) {
        switch (i) {
        case 0:
            return FreeScale;
            break;
        case 1:
            return FixScale;
            break;
        default:
            return FreeScale;
        }//switch
    }//intToStyle

    static ImageAlignment intToImageAlignment(int i) {
        switch (i) {
        case 0:
            return TopLeft;
            break;
        case 1:
            return TopCenter;
            break;
        case 2:
            return TopRight;
            break;
        case 3:
            return CenterLeft;
            break;
        case 4:
            return Center;
            break;
        case 5:
            return CenterRight;
            break;
        case 6:
            return BottomLeft;
            break;
        case 7:
            return BottomCenter;
            break;
        case 8:
            return BottomRight;
            break;
        default:
            return TopLeft;
        }//switch
    }//intToAlignment

protected:
    void writeLongString(ostream &os, const String &str) const;

    /* Methods for OGML serialization */

    static const char * edgeStyleToOGML(const GraphAttributes::EdgeStyle & edgeStyle);

    static const char * imageAlignmentToOGML(const GraphAttributes::ImageAlignment &imgAlign);

    static const char * imageStyleToOGML(const GraphAttributes::ImageStyle &imgStyle);

    static const char * brushPatternToOGML(const GraphAttributes::BrushPattern & brushPattern);

    static void generateIndent(char ** indent, const int & indentSize);

    String formatLabel(const String & labelText);

    /* End methods for OGML serialization */

    const Graph *m_pGraph; 

    bool m_directed; 

    // graphical representation of nodes
    NodeArray<double> m_x; 
    NodeArray<double> m_y; 
    NodeArray<double> m_width; 
    NodeArray<double> m_height; 
    NodeArray<String> m_nodeLabel; 
    NodeArray<String> m_nodeColor; 
    NodeArray<String> m_nodeLine; 
    NodeArray<int> m_nodeShape; 
    NodeArray<double> m_nodeLineWidth; 
    NodeArray<BrushPattern> m_nodePattern; 
    NodeArray<EdgeStyle> m_nodeStyle; 
    NodeArray<String> m_nodeTemplate; 

    // images
    NodeArray<String> m_imageUri;
    NodeArray<ImageStyle> m_imageStyle;
    NodeArray<ImageAlignment> m_imageAlign;
    NodeArray<bool> m_imageDrawLine;
    NodeArray<double> m_imageWidth;
    NodeArray<double> m_imageHeight;

    // other node attributes
    NodeArray<int> m_nodeId; 
    NodeArray<int> m_level; 
    NodeArray<int> m_nodeIntWeight; 
    NodeArray<Graph::NodeType> m_vType; // type (vertex, dummy, generalizationMerger)

    // graphical representation of edges
    EdgeArray<DPolyline> m_bends; 
    EdgeArray<String> m_edgeLabel; 
    EdgeArray<EdgeArrow> m_edgeArrow; 
    EdgeArray<EdgeStyle> m_edgeStyle; 
    EdgeArray<String> m_edgeColor; 
    EdgeArray<double> m_edgeWidth; 
    EdgeArray<Graph::EdgeType> m_eType; 

    // other edge attributes
    EdgeArray<int> m_intWeight; 
    EdgeArray<double> m_doubleWeight; 
    EdgeArray<unsigned int> m_subGraph; 

    long m_attributes; 

public:
    enum {
        nodeGraphics = 0x00001, 
        edgeGraphics = 0x00002, 
        nodeLevel = 0x00004, 
        edgeIntWeight = 0x00008, 
        edgeDoubleWeight = 0x00010, 
        edgeLabel = 0x00020, 
        nodeLabel = 0x00040, 
        edgeType = 0x00080, 
        nodeType = 0x00100, 
        nodeColor = 0x00200, 
        nodeId = 0x00400, 
        edgeArrow = 0x00800, 
        edgeColor = 0x01000, 
        edgeStyle = 0x02000, 
        nodeStyle = 0x04000, 


        nodeTemplate = 0x08000, 
        edgeSubGraph = 0x10000, 
        nodeWeight = 0x20000
    };

    enum {
        oval = 0x8001, rectangle = 0x8002
    };


    GraphAttributes();


    GraphAttributes(const Graph &G, long initAttributes = nodeGraphics | edgeGraphics);

    virtual ~GraphAttributes() {
    }


    virtual void init(const Graph &G, long initAttr);

    long attributes() const {
        return m_attributes;
    }

    void initAttributes(long attr);

    void destroyAttributes(long attr);

    const Graph& constGraph() const {
        return *m_pGraph;
    }

    bool directed() {
        return m_directed;
    }
    ;

    void directed(bool directed) {
        m_directed = directed;
    }
    ;

    const String &templateNode(node v) const {
        return m_nodeTemplate[v];
    }
    String &templateNode(node v) {
        return m_nodeTemplate[v];
    }

    const double &x(node v) const {
        return m_x[v];
    }
    double &x(node v) {
        return m_x[v];
    }

    const double &y(node v) const {
        return m_y[v];
    }
    double &y(node v) {
        return m_y[v];
    }

    const NodeArray<double> &width() const {
        return m_width;
    }
    NodeArray<double> &width() {
        return m_width;
    }

    const double &width(node v) const {
        return m_width[v];
    }
    double &width(node v) {
        return m_width[v];
    }

    const NodeArray<double> &height() const {
        return m_height;
    }
    NodeArray<double> &height() {
        return m_height;
    }

    const double &height(node v) const {
        return m_height[v];
    }
    double &height(node v) {
        return m_height[v];
    }

    const int &level(node v) const {
        return m_level[v];
    }
    int &level(node v) {
        return m_level[v];
    }

    const int &weight(node v) const {
        return m_nodeIntWeight[v];
    }
    int &weight(node v) {
        return m_nodeIntWeight[v];
    }

    const BrushPattern &nodePattern(node v) const {
        return m_nodePattern[v];
    }
    BrushPattern &nodePattern(node v) {
        return m_nodePattern[v];
    }

    const EdgeStyle &styleNode(node v) const {
        return m_nodeStyle[v];
    }
    EdgeStyle &styleNode(node v) {
        return m_nodeStyle[v];
    }

    const double &lineWidthNode(node v) const {
        return m_nodeLineWidth[v];
    }
    double &lineWidthNode(node v) {
        return m_nodeLineWidth[v];
    }

    const String &nodeLine(node v) const {
        return m_nodeLine[v];
    }
    String &nodeLine(node v) {
        return m_nodeLine[v];
    }

    const DPolyline &bends(edge e) const {
        return m_bends[e];
    }
    DPolyline &bends(edge e) {
        return m_bends[e];
    }

    const int &intWeight(edge e) const {
        return m_intWeight[e];
    }
    int &intWeight(edge e) {
        return m_intWeight[e];
    }

    const double &doubleWeight(edge e) const {
        return m_doubleWeight[e];
    }
    double &doubleWeight(edge e) {
        return m_doubleWeight[e];
    }

    const double &edgeWidth(edge e) const {
        return m_edgeWidth[e];
    }
    double &edgeWidth(edge e) {
        return m_edgeWidth[e];
    }

    const String &colorNode(node v) const {
        return m_nodeColor[v];
    }
    String &colorNode(node v) {
        return m_nodeColor[v];
    }

    int shapeNode(node v) const {
        return m_nodeShape[v];
    }
    int &shapeNode(node v) {
        return m_nodeShape[v];
    }

    const String &labelNode(node v) const {
        return m_nodeLabel[v];
    }
    String &labelNode(node v) {
        return m_nodeLabel[v];
    }

    const String &labelEdge(edge e) const {
        return m_edgeLabel[e];
    }
    String &labelEdge(edge e) {
        return m_edgeLabel[e];
    }

    Graph::EdgeType type(edge e) const {
        return m_eType.valid() ? m_eType[e] : Graph::association;
    }
    Graph::EdgeType &type(edge e) {
        return m_eType[e];
    }

    Graph::NodeType type(node v) const {
        return m_vType.valid() ? m_vType[v] : Graph::vertex;
    }
    Graph::NodeType &type(node v) {
        return m_vType[v];
    }

    const int &idNode(node v) const {
        return m_nodeId[v];
    }
    int &idNode(node v) {
        return m_nodeId[v];
    }

    const EdgeArrow &arrowEdge(edge e) const {
        return m_edgeArrow[e];
    }
    EdgeArrow &arrowEdge(edge e) {
        return m_edgeArrow[e];
    }

    const EdgeStyle &styleEdge(edge e) const {
        return m_edgeStyle[e];
    }
    EdgeStyle &styleEdge(edge e) {
        return m_edgeStyle[e];
    }

    const String &colorEdge(edge e) const {
        return m_edgeColor[e];
    }
    String &colorEdge(edge e) {
        return m_edgeColor[e];
    }

    // Images:
    const String &imageUriNode(node v) const {
        return m_imageUri[v];
    }
    String &imageUriNode(node v) {
        return m_imageUri[v];
    }
    const ImageStyle &imageStyleNode(node v) const {
        return m_imageStyle[v];
    }
    ImageStyle &imageStyleNode(node v) {
        return m_imageStyle[v];
    }
    // Returns image alignment of node v.
    const ImageAlignment &imageAlignmentNode(node v) const {
        return m_imageAlign[v];
    }
    // Returns image alignment of node v.
    ImageAlignment &imageAlignmentNode(node v) {
        return m_imageAlign[v];
    }
    const bool &imageDrawLineNode(node v) const {
        return m_imageDrawLine[v];
    }
    bool &imageDrawLineNode(node v) {
        return m_imageDrawLine[v];
    }
    const double &imageWidthNode(node v) const {
        return m_imageWidth[v];
    }
    double &imageWidthNode(node v) {
        return m_imageWidth[v];
    }
    // Returns image height of node v.
    const double &imageHeightNode(node v) const {
        return m_imageHeight[v];
    }
    // Returns image height of node v.
    double &imageHeightNode(node v) {
        return m_imageHeight[v];
    }

    const unsigned int &subGraphBits(edge e) const {
        return m_subGraph[e];
    }
    unsigned int &subGraphBits(edge e) {
        return m_subGraph[e];
    }

    bool inSubGraph(edge e, int n) const {
        OGDF_ASSERT( n>=0 && n<32 );
        return (m_subGraph[e] & (1 << n)) != 0;
    }
    void addSubGraph(edge e, int n) {
        OGDF_ASSERT( n>=0 && n<32 );
        m_subGraph[e] |= (1 << n);
    }
    void removeSubGraph(edge e, int n) {
        OGDF_ASSERT( n>=0 && n<32 );
        m_subGraph[e] &= ~(1 << n);
    }

    const DRect boundingBox() const;

    bool isAssociationClass(node v) const {
        return (type(v) == Graph::associationClass);
    }

    void addNodeCenter2Bends(int mode = 1);

    void clearAllBends();


    int hierarchyList(List<List<node>*> &list) const;


    int hierarchyList(List<List<edge>*> &list) const;

    void setAllWidth(double w);
    void setAllHeight(double h);

    bool readGML(Graph &G, const String &fileName);

    bool readGML(Graph &G, istream &is);

    void writeGML(const String &fileName) const;

    void writeGML(ostream &os) const;


    void writeSVG(const String &fileName, int fontSize = 3, const String &fontColor = "#000000") const;


    void writeSVG(ostream &os, int fontSize, const String &fontColor) const;

    bool readXML(Graph &G, const String &fileName);

    bool readXML(Graph &G, istream &is);

    void writeXML(const String &fileName, const char* delimiter = "", const char* offset = "") const;

    virtual void writeXML(ostream &os, const char* delimiter = "", const char* offset = "") const;

    bool readRudy(Graph &G, const String &fileName);

    bool readRudy(Graph &G, istream &is);

    void writeRudy(const String &fileName) const;

    void writeRudy(ostream &os) const;


    void removeUnnecessaryBendsHV();
};

} // end namespace ogdf


#endif