graphics.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Logger.h>
#include <ogdf/basic/basic.h>
 
#include <cstdint>
#include <iostream>
#include <limits>
#include <map>
#include <string>
#include <typeinfo>
 
namespace ogdf {
 
 
enum class StrokeType : unsigned char {
    None, 
    Solid, 
    Dash, 
    Dot, 
    Dashdot, 
    Dashdotdot 
};
 
OGDF_EXPORT std::ostream& operator<<(std::ostream& os, const StrokeType& st);
 
 
StrokeType intToStrokeType(int i);
 
 
enum class StrokeLineCap : unsigned char { Butt, Round, Square };
 
 
 
enum class StrokeLineJoin : unsigned char { Miter, Round, Bevel };
 
 
 
enum class FillPattern {
    None,
    Solid,
    Dense1,
    Dense2,
    Dense3,
    Dense4,
    Dense5,
    Dense6,
    Dense7,
    Horizontal,
    Vertical,
    Cross,
    BackwardDiagonal,
    ForwardDiagonal,
    DiagonalCross
};
 
void initFillPatternHashing();
 
OGDF_EXPORT std::ostream& operator<<(std::ostream& os, const FillPattern& fp);
 
 
FillPattern intToFillPattern(int i);
 
 
 
enum class Shape {
    Rect, 
    RoundedRect, 
    Ellipse, 
    Triangle, 
    Pentagon, 
    Hexagon, 
    Octagon, 
    Rhomb, 
    Trapeze, 
    Parallelogram, 
    InvTriangle, 
    InvTrapeze, 
    InvParallelogram, 
    Image
};
 
OGDF_EXPORT std::ostream& operator<<(std::ostream& os, const Shape& shape);
 
 
 
enum class EdgeArrow {
    None, 
    Last, 
    First, 
    Both, 
    Undefined
};
 
OGDF_EXPORT std::ostream& operator<<(std::ostream& os, const EdgeArrow& ea);
 
 
class OGDF_EXPORT Color {
    uint8_t m_red, m_green, m_blue, m_alpha;
 
public:
    enum class Name {
        Aliceblue,
        Antiquewhite,
        Aqua,
        Aquamarine,
        Azure,
        Beige,
        Bisque,
        Black,
        Blanchedalmond,
        Blue,
        Blueviolet,
        Brown,
        Burlywood,
        Cadetblue,
        Chartreuse,
        Chocolate,
        Coral,
        Cornflowerblue,
        Cornsilk,
        Crimson,
        Cyan,
        Darkblue,
        Darkcyan,
        Darkgoldenrod,
        Darkgray,
        Darkgreen,
        Darkgrey,
        Darkkhaki,
        Darkmagenta,
        Darkolivegreen,
        Darkorange,
        Darkorchid,
        Darkred,
        Darksalmon,
        Darkseagreen,
        Darkslateblue,
        Darkslategray,
        Darkslategrey,
        Darkturquoise,
        Darkviolet,
        Deeppink,
        Deepskyblue,
        Dimgray,
        Dimgrey,
        Dodgerblue,
        Firebrick,
        Floralwhite,
        Forestgreen,
        Fuchsia,
        Gainsboro,
        Ghostwhite,
        Gold,
        Goldenrod,
        Gray,
        Green,
        Greenyellow,
        Grey,
        Honeydew,
        Hotpink,
        Indianred,
        Indigo,
        Ivory,
        Khaki,
        Lavender,
        Lavenderblush,
        Lawngreen,
        Lemonchiffon,
        Lightblue,
        Lightcoral,
        Lightcyan,
        Lightgoldenrodyellow,
        Lightgray,
        Lightgreen,
        Lightgrey,
        Lightpink,
        Lightsalmon,
        Lightseagreen,
        Lightskyblue,
        Lightslategray,
        Lightslategrey,
        Lightsteelblue,
        Lightyellow,
        Lime,
        Limegreen,
        Linen,
        Magenta,
        Maroon,
        Mediumaquamarine,
        Mediumblue,
        Mediumorchid,
        Mediumpurple,
        Mediumseagreen,
        Mediumslateblue,
        Mediumspringgreen,
        Mediumturquoise,
        Mediumvioletred,
        Midnightblue,
        Mintcream,
        Mistyrose,
        Moccasin,
        Navajowhite,
        Navy,
        Oldlace,
        Olive,
        Olivedrab,
        Orange,
        Orangered,
        Orchid,
        Palegoldenrod,
        Palegreen,
        Paleturquoise,
        Palevioletred,
        Papayawhip,
        Peachpuff,
        Peru,
        Pink,
        Plum,
        Powderblue,
        Purple,
        Red,
        Rosybrown,
        Royalblue,
        Saddlebrown,
        Salmon,
        Sandybrown,
        Seagreen,
        Seashell,
        Sienna,
        Silver,
        Skyblue,
        Slateblue,
        Slategray,
        Slategrey,
        Snow,
        Springgreen,
        Steelblue,
        Tan,
        Teal,
        Thistle,
        Tomato,
        Turquoise,
        Violet,
        Wheat,
        White,
        Whitesmoke,
        Yellow,
        Yellowgreen
    };
 
    Color() : m_red(0), m_green(0), m_blue(0), m_alpha(255) { }
 
    Color(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
        : m_red(r), m_green(g), m_blue(b), m_alpha(a) { }
 
    Color(int r, int g, int b, int a = 255)
        : m_red((uint8_t)r), m_green((uint8_t)g), m_blue((uint8_t)b), m_alpha((uint8_t)a) { }
 
    Color(Color::Name name);
 
    Color(const string& str) { fromString(str); }
 
    Color(const char* str) { fromString(string(str)); }
 
    uint8_t red() const { return m_red; }
 
    uint8_t green() const { return m_green; }
 
    uint8_t blue() const { return m_blue; }
 
    uint8_t alpha() const { return m_alpha; }
 
    void red(uint8_t r) { m_red = r; }
 
    void green(uint8_t g) { m_green = g; }
 
    void blue(uint8_t b) { m_blue = b; }
 
    void alpha(uint8_t a) { m_alpha = a; }
 
 
    string toString() const;
 
 
    bool fromString(const string& str);
 
    bool operator==(const Color& c) const {
        return m_red == c.m_red && m_green == c.m_green && m_blue == c.m_blue && m_alpha == c.m_alpha;
    }
 
    bool operator!=(const Color& c) const { return !operator==(c); }
 
    friend std::ostream& operator<<(std::ostream& os, const Color& c) { return os << c.toString(); }
};
 
 
struct OGDF_EXPORT Stroke {
    Color m_color; 
    float m_width; 
    StrokeType m_type; 
    StrokeLineCap m_cap; 
    StrokeLineJoin m_join; 
 
    Stroke()
        : m_color(Color::Name::Black)
        , m_width(1.0f)
        , m_type(StrokeType::Solid)
        , m_cap(StrokeLineCap::Butt)
        , m_join(StrokeLineJoin::Miter) { }
 
    Stroke(Color c)
        : m_color(c)
        , m_width(1.0f)
        , m_type(StrokeType::Solid)
        , m_cap(StrokeLineCap::Butt)
        , m_join(StrokeLineJoin::Miter) { }
};
 
 
struct OGDF_EXPORT Fill {
    Color m_color; 
    Color m_bgColor; 
    FillPattern m_pattern; 
 
    Fill()
        : m_color(Color::Name::White), m_bgColor(Color::Name::Black), m_pattern(FillPattern::Solid) { }
 
    Fill(Color c) : m_color(c), m_bgColor(Color::Name::Black), m_pattern(FillPattern::Solid) { }
 
    Fill(Color c, FillPattern pattern)
        : m_color(c), m_bgColor(Color::Name::Black), m_pattern(pattern) { }
 
    Fill(Color c, Color bgColor, FillPattern pattern)
        : m_color(c), m_bgColor(bgColor), m_pattern(pattern) { }
};
 
namespace graphics {
extern OGDF_EXPORT std::map<Shape, string> fromShape;
extern OGDF_EXPORT std::map<string, Shape> toShape;
 
extern OGDF_EXPORT std::map<StrokeType, string> fromStrokeType;
extern OGDF_EXPORT std::map<string, StrokeType> toStrokeType;
 
extern OGDF_EXPORT std::map<FillPattern, string> fromFillPattern;
extern OGDF_EXPORT std::map<string, FillPattern> toFillPattern;
 
template<class Enum>
inline void init() {};
 
template<class Enum>
inline void initSecondMap(std::map<Enum, string>& fromMap, std::map<string, Enum>& toMap) {
    for (auto it : fromMap) {
        toMap.emplace(it.second, it.first);
    }
}
 
template<>
inline void init<StrokeType>() {
    fromStrokeType.emplace(StrokeType::None, "None");
    fromStrokeType.emplace(StrokeType::Solid, "Solid");
    fromStrokeType.emplace(StrokeType::Dash, "Dash");
    fromStrokeType.emplace(StrokeType::Dot, "Dot");
    fromStrokeType.emplace(StrokeType::Dashdot, "Dashdot");
    fromStrokeType.emplace(StrokeType::Dashdotdot, "Dashdotdot");
 
    initSecondMap<StrokeType>(fromStrokeType, toStrokeType);
}
 
template<>
inline void init<FillPattern>() {
    fromFillPattern.emplace(FillPattern::None, "None");
    fromFillPattern.emplace(FillPattern::Solid, "Solid");
    fromFillPattern.emplace(FillPattern::Dense1, "Dense1");
    fromFillPattern.emplace(FillPattern::Dense2, "Dense2");
    fromFillPattern.emplace(FillPattern::Dense3, "Dense3");
    fromFillPattern.emplace(FillPattern::Dense4, "Dense4");
    fromFillPattern.emplace(FillPattern::Dense5, "Dense5");
    fromFillPattern.emplace(FillPattern::Dense6, "Dense6");
    fromFillPattern.emplace(FillPattern::Dense7, "Dense7");
    fromFillPattern.emplace(FillPattern::Horizontal, "Horizontal");
    fromFillPattern.emplace(FillPattern::Vertical, "Vertical");
    fromFillPattern.emplace(FillPattern::Cross, "Cross");
    fromFillPattern.emplace(FillPattern::BackwardDiagonal, "BackwardDiagonal");
    fromFillPattern.emplace(FillPattern::ForwardDiagonal, "ForwardDiagonal");
    fromFillPattern.emplace(FillPattern::DiagonalCross, "DiagonalCross");
 
    initSecondMap<FillPattern>(fromFillPattern, toFillPattern);
}
 
template<>
inline void init<Shape>() {
    fromShape.emplace(Shape::Rect, "Rect");
    fromShape.emplace(Shape::RoundedRect, "RoundedRect");
    fromShape.emplace(Shape::Ellipse, "Ellipse");
    fromShape.emplace(Shape::Triangle, "Triangle");
    fromShape.emplace(Shape::Pentagon, "Pentagon");
    fromShape.emplace(Shape::Hexagon, "Hexagon");
    fromShape.emplace(Shape::Octagon, "Octagon");
    fromShape.emplace(Shape::Rhomb, "Rhomb");
    fromShape.emplace(Shape::Trapeze, "Trapeze");
    fromShape.emplace(Shape::Parallelogram, "Parallelogram");
    fromShape.emplace(Shape::InvTriangle, "InvTriangle");
    fromShape.emplace(Shape::InvTrapeze, "InvTrapeze");
    fromShape.emplace(Shape::InvParallelogram, "InvParallelogram");
    fromShape.emplace(Shape::Image, "Image");
 
    initSecondMap<Shape>(fromShape, toShape);
    toShape.emplace("rectangle", Shape::Rect);
    toShape.emplace("box", Shape::Image);
}
 
template<class ToClass>
inline std::map<string, ToClass>* getMapToEnum() {
    std::cout << "getMapToEnum was wrongly called\n";
    OGDF_ASSERT(false);
    return nullptr;
};
 
template<class FromClass>
inline std::map<FromClass, string>* getMapToString() {
    FromClass fc;
    std::cout << "getMapToString was wrongly called " << typeid(fc).name() << "\n";
    OGDF_ASSERT(false);
    return nullptr;
};
 
template<>
inline std::map<string, FillPattern>* getMapToEnum() {
    return &toFillPattern;
};
 
template<>
inline std::map<string, Shape>* getMapToEnum() {
    return &toShape;
};
 
template<>
inline std::map<string, StrokeType>* getMapToEnum() {
    return &toStrokeType;
};
 
template<>
inline std::map<FillPattern, string>* getMapToString() {
    return &fromFillPattern;
};
 
template<>
inline std::map<Shape, string>* getMapToString() {
    return &fromShape;
};
 
template<>
inline std::map<StrokeType, string>* getMapToString() {
    return &fromStrokeType;
};
}
 
template<class FromClass>
inline string toString(FromClass key) {
    auto* map = graphics::getMapToString<FromClass>();
    if (map->empty()) {
        graphics::init<FromClass>();
    }
    auto it = map->find(key);
    OGDF_ASSERT(it != map->end());
    return (*it).second;
};
 
template<class ToClass>
inline ToClass fromString(string key) {
    auto map = graphics::getMapToEnum<ToClass>();
    if (map->empty()) {
        graphics::init<ToClass>();
    }
    auto it = map->find(key);
    if (it != map->end()) {
        return (*it).second;
    } else {
        Logger::slout() << "Encountered invalid " << typeid((*map->begin()).second).name() << ": "
                        << key << " " << map->size() << " " << map->empty() << std::endl;
        return static_cast<ToClass>(std::numeric_limits<int>::min());
    }
};
}