GraphAttributes.h

Go to the documentation of this file.

/*
 * $Revision: 2044 $
 * 
 * last checkin:
 *   $Author: tschaefer $ 
 *   $Date: 2010-10-06 14:54:26 +0200 (Wed, 06 Oct 2010) $ 
 ***************************************************************/
 
#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;

    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