Symbol.h

Go to the documentation of this file.

#include <string>
#include <vector>
#include <cmath>

using namespace std;

#include "DataStructure.h"
#include "Color.h"

#ifndef SYMBOL_H

#define SYMBOL_H


namespace bridges {
    namespace datastructure {

        class Symbol {

            private:

                int identifier;
                string name = string();

                string shape_type = "circle";   // rect, circle, polygon, label

                // specify default attributes
                // defaults are not sent through JSON

                float   default_location[2] = {0.0f, 0.0f};
                Color   default_fill_color{"blue"};
                Color   default_stroke_color{"white"};
                int     default_stroke_dash = 1;
                float   default_opacity = 1.0f;
                float   default_stroke_width = 1.0f;
                string  default_symbol = "circle";
                int     default_font_size = 12;

                // symbol attributes

                string label = string();
                Color fillColor{"blue"},
                      strokeColor{"white"};
                float opacity = 1.0f;
                float strokeWidth = 1.0f;
                int strokeDash = 1;
                int fontSize = 12;
                int textWidth = 100;
                int textHeight = 50;
                // symbol location
                float location[2] = {0.0f, 0.0f};

            private:
                int getNewIdentifier() {
                    static int ids = 0;
                    ids++;

                    return ids - 1;
                }

            protected:
                void setShapeType (string s) {
                    shape_type = s;
                }
                string getShapeType() const {
                    return shape_type;
                }

            public:

                Symbol() {
                    identifier = getNewIdentifier();
                }

                virtual const string getSymbolRepresentation() const  = 0;

                virtual vector<float> getDimensions() const = 0;

                Symbol(string symb) {
                    identifier = getNewIdentifier();
                }

                int getIdentifier() {
                    return identifier;
                }

                void setLabel(string lbl) {
                    label = lbl;
                }

                string getLabel() const {
                    return label;
                }


                void setFillColor(Color c) {
                    fillColor = c;
                }
                void setFillColor(string c) {
                    fillColor = Color(c);
                }
                Color getFillColor() {
                    return fillColor;
                }

                void setStrokeColor(Color c) {
                    strokeColor = c;
                }

                void setStrokeColor(string c) {
                    strokeColor = Color(c);
                }

                Color getStrokeColor() {
                    return strokeColor;
                }

                void setStrokeWidth(float strk_width) {
                    if (strokeWidth < 0.0f)
                        throw "Stroke width must be positive or null";
                    else
                        strokeWidth = strk_width;
                }

                float getStrokeWidth() {
                    return strokeWidth;
                }

                void setOpacity(float op) {
                    if (op < 0.0f || op > 1.0f)
                        throw "Opacity must be between 0 and 1";
                    else
                        opacity = op;
                }

                float getOpacity() {
                    return opacity;
                }

                void setStrokeDash(int dash) {
                    if (dash < 0 || dash > 10)
                        throw "Dash must be between 0 and 10 (inclusive)";
                    else
                        strokeDash = dash;
                }

                int getStrokeDash() {
                    return strokeDash;
                }

                void setLocation(int x, int y) {
                    setLocation(float(x), float(y));
                }

                void setLocation(double x, double y) {
                    setLocation(float(x), float(y));
                }


                void setCenter(float x, float y) {
                    setLocation(x, y);
                }

                void setLocation(float x, float y) {
                    if ((x > -INFINITY && x < INFINITY) &&
                        (y > -INFINITY && y < INFINITY)) {
                        location[0] = x;
                        location[1] = y;
                    }
                    else
                        throw "Coordinates must be real numbers";
                }
                const float *getLocation() const {
                    return location;
                }

                string getName()  const {
                    return name;
                }

            protected:
                void translatePoint (float *pt, float tx, float ty) {
                    pt[0] += tx;
                    pt[1] += ty;
                }

                void scalePoint (float *pt, float sx, float sy) {
                    pt[0] *= sx;
                    pt[1] *= sy;
                }

                void rotatePoint (float *pt, float angle) {
                    // compute sin, cos
                    float angle_r = angle * M_PI / 180.;
                    float c = cos(angle_r);
                    float s = sin(angle_r);

                    // rotate the point
                    float tmp[] = { pt[0]*c - pt[1]*s, tmp[1] = pt[0] * s + pt[1] * c};

                    // assign to point
                    pt[0] = tmp[0];
                    pt[1] = tmp[1];
                }

                const string getSymbolAttributeRepresentation() const {

                    // first get all the non-geometric attributes

                    string symbol_attr_json = OPEN_CURLY;

                    if (fillColor.getRepresentation() !=
                        default_fill_color.getRepresentation()) {
                        symbol_attr_json += QUOTE + "fill" + QUOTE + COLON +
                            fillColor.getCSSRepresentation() + COMMA;
                    }

                    if (opacity != default_opacity) {
                        symbol_attr_json += QUOTE + "opacity" + QUOTE + COLON +
                            to_string(opacity) + COMMA;
                    }

                    if (strokeColor.getRepresentation() !=
                        default_stroke_color.getRepresentation()) {
                        symbol_attr_json += QUOTE + "stroke" + QUOTE + COLON +
                            strokeColor.getCSSRepresentation() + COMMA;
                    }

                    if (strokeWidth != default_stroke_width) {
                        symbol_attr_json += QUOTE + "stroke-width" + QUOTE + COLON +
                            to_string(strokeWidth) + COMMA;
                    }

                    if (strokeDash != default_stroke_dash) {
                        symbol_attr_json += QUOTE + "stroke-dasharray" + QUOTE + COLON +
                            to_string(strokeDash) + COMMA;
                    }

                    if (location[0] != default_location[0] ||
                        location[1] != default_location[1]) {
                        symbol_attr_json += QUOTE + "location" + QUOTE + COLON +
                            OPEN_CURLY +
                            QUOTE + "x" + QUOTE + COLON  +
                            to_string(location[0]) + COMMA +
                            QUOTE + "y" + QUOTE + COLON +
                            to_string(location[1]) +
                            CLOSE_CURLY   + COMMA;
                    }

                    return symbol_attr_json;
                }
        };
    }
} // namespace bridges

#endif