GraphIO.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/GridLayout.h>
#include <ogdf/basic/exceptions.h>
#include <ogdf/cluster/ClusterGraphAttributes.h>
#include <ogdf/graphalg/steiner_tree/EdgeWeightedGraph.h>
 
#include <sstream>
#include <unordered_map>
 
namespace ogdf {
 
 
 
class GraphIO {
public:
    static OGDF_EXPORT Logger logger;
 
    using ReaderFunc = bool (*)(Graph&, std::istream&);
 
    using WriterFunc = bool (*)(const Graph&, std::ostream&);
 
    using AttrReaderFunc = bool (*)(GraphAttributes&, Graph&, std::istream&);
 
    using AttrWriterFunc = bool (*)(const GraphAttributes&, std::ostream&);
 
    using ClusterReaderFunc = bool (*)(ClusterGraph&, Graph&, std::istream&);
 
    using ClusterWriterFunc = bool (*)(const ClusterGraph&, std::ostream&);
 
    using ClusterAttrReaderFunc = bool (*)(ClusterGraphAttributes&, ClusterGraph&, Graph&,
            std::istream&);
 
    using ClusterAttrWriterFunc = bool (*)(const ClusterGraphAttributes&, std::ostream&);
 
    struct FileType {
        std::vector<std::string> extensions;
        ReaderFunc reader_func;
        ReaderFunc auto_reader_func;
        WriterFunc writer_func;
        AttrReaderFunc attr_reader_func;
        AttrReaderFunc auto_attr_reader_func;
        AttrWriterFunc attr_writer_func;
        ClusterReaderFunc cluster_reader_func;
        ClusterReaderFunc auto_cluster_reader_func;
        ClusterWriterFunc cluster_writer_func;
        ClusterAttrReaderFunc cluster_attr_reader_func;
        ClusterAttrReaderFunc auto_cluster_attr_reader_func;
        ClusterAttrWriterFunc cluster_attr_writer_func;
 
        explicit FileType(std::vector<std::string> extensions, ReaderFunc readerFunc = nullptr,
                WriterFunc writerFunc = nullptr, AttrReaderFunc attrReaderFunc = nullptr,
                AttrWriterFunc attrWriterFunc = nullptr,
                ClusterReaderFunc clusterReaderFunc = nullptr,
                ClusterWriterFunc clusterWriterFunc = nullptr,
                ClusterAttrReaderFunc clusterAttrReaderFunc = nullptr,
                ClusterAttrWriterFunc clusterAttrWriterFunc = nullptr);
 
        FileType& replaceAutoReaders(ReaderFunc readerFunc = nullptr,
                AttrReaderFunc attrReaderFunc = nullptr,
                ClusterReaderFunc clusterReaderFunc = nullptr,
                ClusterAttrReaderFunc clusterAttrReaderFunc = nullptr);
    };
 
    static const OGDF_EXPORT std::vector<FileType> FILE_TYPES;
    static OGDF_EXPORT std::unordered_map<string, const FileType*> FILE_TYPE_MAP;
 
    static OGDF_EXPORT const std::unordered_map<string, const FileType*>& getFileTypeMap();
 
    static OGDF_EXPORT const FileType* getFileType(const string& filename);
 
    class OGDF_EXPORT SVGSettings {
        double m_margin;
        int m_fontSize;
        double m_curviness;
        bool m_bezierInterpolation;
        string m_fontColor;
        string m_fontFamily;
        string m_width;
        string m_height;
 
    public:
        SVGSettings();
 
        bool bezierInterpolation() const { return m_bezierInterpolation; }
 
        double margin() const { return m_margin; }
 
        double curviness() const { return m_curviness; }
 
        int fontSize() const { return m_fontSize; }
 
        const string& fontColor() const { return m_fontColor; }
 
        const string& fontFamily() const { return m_fontFamily; }
 
        const string& width() const { return m_width; }
 
        const string& height() const { return m_height; }
 
        void margin(double m) { m_margin = m; }
 
        void curviness(double value) {
            OGDF_ASSERT(value >= 0);
            OGDF_ASSERT(value <= 1);
 
            m_curviness = value;
        }
 
        void bezierInterpolation(bool enable) { m_bezierInterpolation = enable; }
 
        void fontSize(int fs) { m_fontSize = fs; }
 
        void fontColor(const string& fc) { m_fontColor = fc; }
 
        void fontFamily(const string& fm) { m_fontFamily = fm; }
 
 
        void width(const string& width) { m_width = width; }
 
 
        void height(const string& height) { m_height = height; }
    };
 
 
    static OGDF_EXPORT bool read(Graph& G, const string& filename, ReaderFunc reader = nullptr);
 
    static OGDF_EXPORT bool read(GraphAttributes& GA, Graph& G, const string& filename,
            AttrReaderFunc reader = nullptr);
 
    static OGDF_EXPORT bool read(ClusterGraph& CG, Graph& G, const string& filename,
            ClusterReaderFunc reader = nullptr);
 
    static OGDF_EXPORT bool read(ClusterGraphAttributes& GA, ClusterGraph& CG, Graph& G,
            const string& filename, ClusterAttrReaderFunc reader = nullptr);
 
    static OGDF_EXPORT bool read(Graph& G, std::istream& is);
 
    static OGDF_EXPORT bool read(GraphAttributes& GA, Graph& G, std::istream& is);
 
    static OGDF_EXPORT bool read(ClusterGraph& CG, Graph& G, std::istream& is);
 
    static OGDF_EXPORT bool read(ClusterGraphAttributes& GA, ClusterGraph& CG, Graph& G,
            std::istream& is);
 
    static OGDF_EXPORT bool write(const Graph& G, const string& filename,
            WriterFunc writer = nullptr);
 
    static OGDF_EXPORT bool write(const GraphAttributes& GA, const string& filename,
            AttrWriterFunc writer = nullptr);
 
    static OGDF_EXPORT bool write(const ClusterGraph& CG, const string& filename,
            ClusterWriterFunc writer = nullptr);
 
    static OGDF_EXPORT bool write(const ClusterGraphAttributes& GA, const string& filename,
            ClusterAttrWriterFunc writer = nullptr);
 
 
#pragma mark GML
 
 
    static OGDF_EXPORT bool readGML(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool writeGML(const Graph& G, std::ostream& os);
 
 
    static OGDF_EXPORT bool readGML(ClusterGraph& C, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool writeGML(const ClusterGraph& C, std::ostream& os);
 
 
    static OGDF_EXPORT bool readGML(ClusterGraphAttributes& A, ClusterGraph& C, Graph& G,
            std::istream& is);
 
 
    static OGDF_EXPORT bool writeGML(const ClusterGraphAttributes& A, std::ostream& os);
 
 
    static OGDF_EXPORT bool readGML(GraphAttributes& A, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool writeGML(const GraphAttributes& A, std::ostream& os);
 
 
#pragma mark Rome
 
 
    static OGDF_EXPORT bool readRome(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool writeRome(const Graph& G, std::ostream& os);
 
 
#pragma mark LEDA
 
 
    static OGDF_EXPORT bool readLEDA(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool writeLEDA(const Graph& G, std::ostream& os);
 
 
#pragma mark Chaco
 
 
    static OGDF_EXPORT bool readChaco(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool writeChaco(const Graph& G, std::ostream& os);
 
 
#pragma mark PMDissGraph
 
 
    static OGDF_EXPORT bool readPMDissGraph(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool writePMDissGraph(const Graph& G, std::ostream& os);
 
 
#pragma mark YGraph
 
 
    static OGDF_EXPORT bool readYGraph(Graph& G, std::istream& is);
 
 
#pragma mark Graph6
 
 
    static OGDF_EXPORT bool readGraph6(Graph& G, std::istream& is, bool forceHeader = false);
 
 
    static OGDF_EXPORT bool writeGraph6(const Graph& G, std::ostream& os);
 
 
#pragma mark Digraph6
 
 
    static OGDF_EXPORT bool readDigraph6(Graph& G, std::istream& is, bool forceHeader = false);
 
 
    static OGDF_EXPORT bool writeDigraph6(const Graph& G, std::ostream& os);
 
 
#pragma mark Sparse6
 
 
    static OGDF_EXPORT bool readSparse6(Graph& G, std::istream& is, bool forceHeader = false);
 
 
    static OGDF_EXPORT bool writeSparse6(const Graph& G, std::ostream& os);
 
 
#pragma mark MatrixMarket
 
 
    static OGDF_EXPORT bool readMatrixMarket(Graph& G, std::istream& inStream);
 
 
#pragma mark Rudy
 
 
    static OGDF_EXPORT bool readRudy(GraphAttributes& A, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readRudy(Graph& G, std::istream& is) {
        GraphAttributes A(G, GraphAttributes::edgeDoubleWeight);
        return readRudy(A, G, is);
    }
 
 
    static OGDF_EXPORT bool writeRudy(const GraphAttributes& A, std::ostream& os);
 
 
#pragma mark BENCH
 
 
    static OGDF_EXPORT bool readBENCH(Graph& G, List<node>& hypernodes, List<edge>* shell,
            std::istream& is);
 
 
#pragma mark PLA
 
 
    static OGDF_EXPORT bool readPLA(Graph& G, List<node>& hypernodes, List<edge>* shell,
            std::istream& is);
 
 
#pragma mark ChallengeGraph
 
 
    static OGDF_EXPORT bool readChallengeGraph(Graph& G, GridLayout& gl, std::istream& is);
 
 
    static OGDF_EXPORT bool writeChallengeGraph(const Graph& G, const GridLayout& gl,
            std::ostream& os);
 
 
#pragma mark GraphML
 
 
    static OGDF_EXPORT bool readGraphML(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readGraphML(ClusterGraph& C, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readGraphML(GraphAttributes& A, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readGraphML(ClusterGraphAttributes& A, ClusterGraph& C, Graph& G,
            std::istream& is);
 
 
    static OGDF_EXPORT bool writeGraphML(const Graph& G, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeGraphML(const ClusterGraph& C, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeGraphML(const GraphAttributes& A, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeGraphML(const ClusterGraphAttributes& A, std::ostream& os);
 
 
#pragma mark DOT
 
 
    static OGDF_EXPORT bool readDOT(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readDOT(ClusterGraph& C, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readDOT(GraphAttributes& A, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readDOT(ClusterGraphAttributes& A, ClusterGraph& C, Graph& G,
            std::istream& is);
 
 
    static OGDF_EXPORT bool writeDOT(const Graph& G, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeDOT(const ClusterGraph& C, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeDOT(const GraphAttributes& A, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeDOT(const ClusterGraphAttributes& A, std::ostream& os);
 
 
#pragma mark GEXF
 
 
    static OGDF_EXPORT bool readGEXF(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readGEXF(ClusterGraph& C, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readGEXF(GraphAttributes& A, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readGEXF(ClusterGraphAttributes& A, ClusterGraph& C, Graph& G,
            std::istream& is);
 
 
    static OGDF_EXPORT bool writeGEXF(const Graph& G, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeGEXF(const ClusterGraph& C, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeGEXF(const GraphAttributes& A, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeGEXF(const ClusterGraphAttributes& A, std::ostream& os);
 
 
#pragma mark GDF
 
 
    static OGDF_EXPORT bool readGDF(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readGDF(GraphAttributes& A, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool writeGDF(const Graph& G, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeGDF(const GraphAttributes& A, std::ostream& os);
 
 
#pragma mark TLP
 
 
    static OGDF_EXPORT bool readTLP(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readTLP(ClusterGraph& C, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readTLP(GraphAttributes& A, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readTLP(ClusterGraphAttributes& A, ClusterGraph& C, Graph& G,
            std::istream& is);
 
 
    static OGDF_EXPORT bool writeTLP(const Graph& G, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeTLP(const ClusterGraph& C, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeTLP(const GraphAttributes& A, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeTLP(const ClusterGraphAttributes& A, std::ostream& os);
 
 
#pragma mark DL
 
 
    static OGDF_EXPORT bool readDL(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readDL(GraphAttributes& A, Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool writeDL(const Graph& G, std::ostream& os);
 
 
    static OGDF_EXPORT bool writeDL(const GraphAttributes& A, std::ostream& os);
 
 
#pragma mark STP
 
    static OGDF_EXPORT bool readSTP(GraphAttributes& attr, Graph& G, List<node>& terminals,
            NodeArray<bool>& isTerminal, std::istream& is);
 
    static OGDF_EXPORT bool readSTP(GraphAttributes& attr, Graph& G, std::istream& is) {
        List<node> terminals;
        NodeArray<bool> isTerminal;
        return readSTP(attr, G, terminals, isTerminal, is);
    }
 
    static OGDF_EXPORT bool readSTP(Graph& G, std::istream& is) {
        GraphAttributes attr(G);
        return readSTP(attr, G, is);
    }
 
    template<typename T>
    static bool readSTP(EdgeWeightedGraph<T>& wG, List<node>& terminals,
            NodeArray<bool>& isTerminal, std::istream& is) {
        wG.clear();
        GraphAttributes attr(wG, getEdgeWeightFlag<T>());
        bool res = readSTP(attr, wG, terminals, isTerminal, is);
        for (edge e : wG.edges) {
            wG.setWeight(e, getEdgeWeightAttribute<T>(attr, e));
        }
        return res;
    }
 
    static OGDF_EXPORT bool writeSTP(const GraphAttributes& attr, const List<node>& terminals,
            std::ostream& os, const string& comments = "");
 
    template<typename T>
    static bool writeSTP(const EdgeWeightedGraph<T>& wG, const List<node>& terminals,
            std::ostream& os, const string& comments = "") {
        GraphAttributes attr(wG, getEdgeWeightFlag<T>());
        for (edge e : wG.edges) {
            getEdgeWeightAttribute<T>(attr, e) = wG.weight(e);
        }
        return writeSTP(attr, terminals, os, comments);
    }
 
 
#pragma mark DMF
 
    static OGDF_EXPORT bool readDMF(GraphAttributes& attr, Graph& graph, node& source, node& sink,
            std::istream& is);
 
    static OGDF_EXPORT bool readDMF(GraphAttributes& attr, Graph& graph, std::istream& is) {
        node sink;
        node source;
        return readDMF(attr, graph, sink, source, is);
    };
 
    template<typename T>
    static bool readDMF(Graph& graph, EdgeArray<T>& weights, node& source, node& sink,
            std::istream& is) {
        GraphAttributes attr(graph, getEdgeWeightFlag<T>());
        bool result = readDMF(attr, graph, source, sink, is);
        weights.init(graph);
        for (edge e : graph.edges) {
            weights[e] = getEdgeWeightAttribute<T>(attr, e);
        }
        return result;
    }
 
    static OGDF_EXPORT bool readDMF(Graph& graph, std::istream& is) {
        GraphAttributes attr(graph);
        node source;
        node sink;
        return readDMF(attr, graph, source, sink, is);
    }
 
    static OGDF_EXPORT bool writeDMF(const GraphAttributes& attr, const node source,
            const node sink, std::ostream& os);
 
    template<typename T>
    static bool writeDMF(const Graph& graph, const EdgeArray<T>& weights, const node source,
            const node sink, std::ostream& os) {
        GraphAttributes attr(graph, getEdgeWeightFlag<T>());
        for (edge e : graph.edges) {
            getEdgeWeightAttribute<T>(attr, e) = weights[e];
        }
        return writeDMF(attr, source, sink, os);
    }
 
#pragma mark TsplibXml
 
 
    static OGDF_EXPORT bool readTsplibXml(Graph& G, std::istream& is);
 
 
    static OGDF_EXPORT bool readTsplibXml(GraphAttributes& GA, Graph& G, std::istream& is);
 
 
 
 
    static OGDF_EXPORT bool readEdgeListSubgraph(Graph& G, List<edge>& delEdges, std::istream& is);
 
 
    static OGDF_EXPORT bool writeEdgeListSubgraph(const Graph& G, const List<edge>& delEdges,
            std::ostream& os);
 
 
 
    static OGDF_EXPORT bool drawSVG(const GraphAttributes& A, std::ostream& os,
            const SVGSettings& settings);
 
    static inline bool drawSVG(const GraphAttributes& A, std::ostream& os) {
        // we may not use a defaulted argument settings=svgSettings here if drawSVG should be a AttrWriterFunc:
        // https://stackoverflow.com/a/2225426/805569
        return drawSVG(A, os, svgSettings);
    }
 
    static inline bool drawSVG(const GraphAttributes& A, const string& filename,
            const SVGSettings& settings = svgSettings) {
        std::ofstream os(filename);
        return os.good() && drawSVG(A, os, settings);
    }
 
    static OGDF_EXPORT bool drawSVG(const ClusterGraphAttributes& A, std::ostream& os,
            const SVGSettings& settings);
 
    static inline bool drawSVG(const ClusterGraphAttributes& A, std::ostream& os) {
        return drawSVG(A, os, svgSettings);
    }
 
    static inline bool drawSVG(const ClusterGraphAttributes& A, const string& filename,
            const SVGSettings& settings = svgSettings) {
        std::ofstream os(filename);
        return os.good() && drawSVG(A, os, settings);
    }
 
    static OGDF_EXPORT bool drawTikz(const GraphAttributes& A, std::ostream& os);
 
    static OGDF_EXPORT bool drawTikz(const ClusterGraphAttributes& A, std::ostream& os);
 
 
 
    static char indentChar() { return s_indentChar; }
 
    static int indentWidth() { return s_indentWidth; }
 
 
    static void setIndentChar(char c) {
        OGDF_ASSERT(isspace((int)c));
        s_indentChar = c;
    }
 
 
    static void setIndentWidth(int w) {
        if (w >= 0) {
            s_indentWidth = w;
        }
    }
 
    static OGDF_EXPORT std::ostream& indent(std::ostream& os, int depth);
 
 
    static OGDF_EXPORT bool setColorValue(int value, std::function<void(uint8_t)> setFunction) {
        if (value < 0 || value > 255) {
            GraphIO::logger.lout() << "Error: color value is not between 0 and 255." << std::endl;
            return false;
        }
        setFunction(static_cast<uint8_t>(value));
        return true;
    }
 
 
    template<typename T, typename std::enable_if<std::is_integral<T>::value, bool>::type = 0>
    static long getEdgeWeightFlag() {
        return GraphAttributes::edgeIntWeight;
    }
 
 
    template<typename T, typename std::enable_if<std::is_floating_point<T>::value, bool>::type = 0>
    static long getEdgeWeightFlag() {
        return GraphAttributes::edgeDoubleWeight;
    }
 
 
    template<typename T, typename std::enable_if<std::is_integral<T>::value, bool>::type = 0>
    static int& getEdgeWeightAttribute(GraphAttributes& attr, edge e) {
        return attr.intWeight(e);
    }
 
 
    template<typename T, typename std::enable_if<std::is_floating_point<T>::value, bool>::type = 0>
    static double& getEdgeWeightAttribute(GraphAttributes& attr, edge e) {
        return attr.doubleWeight(e);
    }
 
 
    static SVGSettings OGDF_EXPORT svgSettings;
 
private:
    static OGDF_EXPORT char s_indentChar; 
    static OGDF_EXPORT int s_indentWidth; 
};
 
}