HypergraphAttributes.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphAttributes.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/geometry.h>
#include <ogdf/basic/graphics.h>
#include <ogdf/hypergraph/EdgeStandardRep.h>
#include <ogdf/hypergraph/Hypergraph.h>
 
#include <string>
 
namespace ogdf {
 
class OGDF_EXPORT HypergraphAttributes {
protected:
    const Hypergraph* m_hypergraph;
 
    HypernodeArray<string> m_label;
 
    HypernodeArray<double> m_x;
 
    HypernodeArray<double> m_y;
 
    HypernodeArray<double> m_width;
 
    HypernodeArray<double> m_height;
 
    HypernodeArray<int> m_shape;
 
public:
    HypergraphAttributes() : m_hypergraph(nullptr) { }
 
    explicit HypergraphAttributes(const Hypergraph& H) : m_hypergraph(&H) {
        m_x.init(H, 0.0);
        m_y.init(H, 0.0);
        m_width.init(H, 10.0);
        m_height.init(H, 10.0);
        m_label.init(H);
        m_shape.init(H, static_cast<int>(Shape::Ellipse));
    }
 
    virtual ~HypergraphAttributes() { }
 
    const Hypergraph& constHypergraph() const { return *m_hypergraph; }
 
    const double& x(hypernode v) { return m_x[v]; }
 
    void setX(hypernode v, double pX) { m_x[v] = pX; }
 
    const double& y(hypernode v) { return m_y[v]; }
 
    void setY(hypernode v, double pY) { m_y[v] = pY; }
 
    const double& width(hypernode v) { return m_width[v]; }
 
    void setWidth(hypernode v, int pWidth) { m_width[v] = pWidth; }
 
    const double& height(hypernode v) { return m_height[v]; }
 
    void setHeight(hypernode v, int pHeight) { m_height[v] = pHeight; }
 
    int shape(hypernode v) { return m_shape[v]; }
 
    string& label(hypernode v) { return m_label[v]; }
};
 
class OGDF_EXPORT HypergraphAttributesES : virtual public HypergraphAttributes {
private:
    GraphAttributes* m_repGA;
 
    EdgeStandardRep* m_repG;
 
    EdgeStandardType m_type;
 
public:
    HypergraphAttributesES() : m_repGA(nullptr), m_repG(nullptr) { }
 
    explicit HypergraphAttributesES(const Hypergraph& pH,
            EdgeStandardType pType = EdgeStandardType::star)
        : HypergraphAttributes(pH) {
        m_repG = new EdgeStandardRep(pH, pType);
 
        m_repGA = new GraphAttributes(m_repG->constGraph(),
                GraphAttributes::nodeGraphics | GraphAttributes::edgeGraphics);
 
        m_repGA->directed() = true;
    }
 
    virtual ~HypergraphAttributesES() {
        delete m_repGA;
        delete m_repG;
    }
 
    EdgeStandardType type() const { return m_type; }
 
    const Graph& repGraph() const { return m_repG->constGraph(); }
 
    const GraphAttributes& repGA() const { return *m_repGA; }
 
    HypernodeElement::Type type(hypernode v) { return v->type(); }
 
    HypernodeElement::Type type(node v) {
        if (m_repG->hypernodeMap(v)) {
            return m_repG->hypernodeMap(v)->type();
        } else {
            return HypernodeElement::Type::dummy;
        }
    }
 
    const double& x(node v) { return m_repGA->x(v); }
 
    void setX(node v, double pX) {
        if (m_repG->hypernodeMap(v)) {
            setX(m_repG->hypernodeMap(v), pX);
        } else {
            m_repGA->x(v) = pX;
        }
    }
 
    void setX(hypernode v, double pX) {
        m_x[v] = pX;
        m_repGA->x(m_repG->nodeMap(v)) = pX;
    }
 
    const double& y(node v) { return m_repGA->y(v); }
 
    void setY(hypernode v, double pY) {
        m_y[v] = pY;
        m_repGA->y(m_repG->nodeMap(v)) = pY;
    }
 
    void setY(node v, double pY) {
        if (m_repG->hypernodeMap(v)) {
            setY(m_repG->hypernodeMap(v), pY);
        } else {
            m_repGA->y(v) = pY;
        }
    }
 
    const double& width(node v) { return m_repGA->width(v); }
 
    void setWidth(hypernode v, double pWidth) {
        m_width[v] = pWidth;
        m_repGA->width(m_repG->nodeMap(v)) = pWidth;
    }
 
    void setWidth(node v, double pWidth) {
        if (m_repG->hypernodeMap(v)) {
            setWidth(m_repG->hypernodeMap(v), pWidth);
        } else {
            m_repGA->width(v) = pWidth;
        }
    }
 
    const double& height(node v) { return m_repGA->height(v); }
 
    void setHeight(hypernode v, double pHeight) {
        m_height[v] = pHeight;
        m_repGA->height(m_repG->nodeMap(v)) = pHeight;
    }
 
    void setHeight(node v, double pHeight) {
        if (m_repG->hypernodeMap(v)) {
            setHeight(m_repG->hypernodeMap(v), pHeight);
        } else {
            m_repGA->height(v) = pHeight;
        }
    }
 
    DPolyline& bends(edge e) { return m_repGA->bends(e); }
 
#if 0
    void writeSVG(std::ostream &os, int fontSize, const string &fontColor) const
    {
        m_repGA->writeSVG(os, fontSize, fontColor);
    }
 
    void writeSVG(const char *fileName, int fontSize, const string &fontColor) const
    {
        m_repGA->writeSVG(fileName, fontSize, fontColor);
    }
#endif
 
    void clearAllBends() { m_repGA->clearAllBends(); }
 
    void removeUnnecessaryBendsHV() { m_repGA->removeUnnecessaryBendsHV(); }
 
    const DRect boundingBox() const { return m_repGA->boundingBox(); }
};
 
}