Symbol.h

Go to the documentation of this file.

 
#ifndef SYMBOL_H
 
#define SYMBOL_H
 
#include <string>
#include <vector>
#include <cmath>
 
using namespace std;
 
#include "DataStructure.h"
#include "Color.h"
 
namespace bridges {
    namespace datastructure {
        class Symbol {
 
            private:
 
                static int ids;
 
                int identifier;
 
                string name = string();
 
                // maintain ids for symbols
 
                // symbol attributes
 
                Color *fillColor = nullptr;
                Color *strokeColor = nullptr;
                float *strokeWidth = nullptr;
                int* strokeDash = nullptr;
                float *opacity = nullptr;
                int   *layer = nullptr;
 
                // use this flag to refrain from putting it into the JSON
                // as its the default
                bool xform_flag = false;
 
                // 2D affine transform matrix for the symbol
                float xform[3][3] = {
                    {1., 0., 0.},
                    {0., 1., 0.},
                    {0., 0., 1.}
                };
 
                // matrix methods used for affine transformations on symbols
                void matMult (float m1[][3], float m2[][3], float result[][3])
                const {
                    for (int i = 0; i < 3; ++i) {
                        for (int j = 0; j < 3; ++j) {
                            result[i][j] = 0.;
                            for (int k = 0; k < 3; ++k) {
                                result[i][j] += m1[i][k] * m2[k][j];
                            }
                        }
                    }
                }
                void identity(float m[][3]) {
                    for (int i = 0; i < 3; ++i)
                        for (int j = 0; j < 3; ++j)
                            m[i][j] = (i == j) ? 1. : 0.;
                }
 
                void copyMat(float m[][3], float copy[][3]) {
                    for (int i = 0; i < 3; ++i)
                        for (int j = 0; j < 3; ++j)
                            copy[i][j] = m[i][j];
                }
                void printMat(float m[][3]) {
                    for (int i = 0; i < 3; ++i) {
                        for (int j = 0; j < 3; ++j)
                            cout <<  m[i][j] << ", ";
                        cout << "\n";
                    }
                }
 
                void clear_optional() {
                    if (fillColor)  {
                        delete fillColor;
                        fillColor = nullptr;
                    }
                    if (strokeColor) {
                        delete strokeColor;
                        strokeColor = nullptr;
                    }
                    if (strokeWidth) {
                        delete strokeWidth;
                        strokeWidth = nullptr;
                    }
                    if (strokeDash) {
                        delete strokeDash;
                        strokeDash = nullptr;
                    }
                    if (opacity) {
                        delete opacity;
                        opacity = nullptr;
                    }
                    if (layer) {
                        delete layer;
                        layer = nullptr;
                    }
                }
 
            public:
 
                Symbol() :
                    fillColor(nullptr),
                    strokeColor(nullptr),
                    strokeWidth(nullptr),
                    strokeDash(nullptr),
                    opacity(nullptr),
                    layer(nullptr) {
 
                    identifier = ids;
                    xform_flag = false;
 
                    // set id for symbol
                    ids++;
                }
 
                Symbol(const Symbol& s)
                    : identifier(s.identifier), name(s.name), xform_flag (s.xform_flag) {
                    xform[0][0] = s.xform[0][0];
                    xform[0][1] = s.xform[0][1];
                    xform[0][2] = s.xform[0][2];
                    xform[1][0] = s.xform[1][0];
                    xform[1][1] = s.xform[1][1];
                    xform[1][2] = s.xform[1][2];
                    xform[2][0] = s.xform[2][0];
                    xform[2][1] = s.xform[2][1];
                    xform[2][2] = s.xform[2][2];
 
                    if (s.fillColor)
                        this->fillColor = new Color(*(s.fillColor));
                    if (s.strokeColor)
                        this->strokeColor = new Color(*(s.strokeColor));
                    if (s.strokeWidth)
                        this->strokeWidth = new float(*(s.strokeWidth));
                    if (s.strokeDash)
                        this->strokeDash = new int(*(s.strokeDash));
                    if (s.opacity)
                        this->opacity = new float(*(s.opacity));
                    if (s.layer)
                        this->layer = new int(*(s.layer));
 
                }
 
                Symbol& operator= (const Symbol& s) {
                    clear_optional();
 
                    this->identifier = s.identifier;
                    this->name = s.name;
                    this->xform_flag = s.xform_flag;
                    xform[0][0] = s.xform[0][0];
                    xform[0][1] = s.xform[0][1];
                    xform[0][2] = s.xform[0][2];
                    xform[1][0] = s.xform[1][0];
                    xform[1][1] = s.xform[1][1];
                    xform[1][2] = s.xform[1][2];
                    xform[2][0] = s.xform[2][0];
                    xform[2][1] = s.xform[2][1];
                    xform[2][2] = s.xform[2][2];
 
                    if (s.fillColor)
                        this->fillColor = new Color(*(s.fillColor));
                    if (s.strokeColor)
                        this->strokeColor = new Color(*(s.strokeColor));
                    if (s.strokeWidth)
                        this->strokeWidth = new float(*(s.strokeWidth));
                    if (s.strokeDash)
                        this->strokeDash = new int(*(s.strokeDash));
                    if (s.opacity)
                        this->opacity = new float(*(s.opacity));
                    if (s.layer)
                        this->layer = new int(*(s.layer));
 
                    return *this;
                }
 
                ~Symbol() {
                    clear_optional();
                }
 
                virtual const string getSymbolRepresentation() const  = 0;
 
                int getIdentifier() const {
                    return identifier;
                }
 
                Symbol& setFillColor(Color c) {
                    if (!fillColor)
                        fillColor = new Color;
 
                    *fillColor = c;
 
                    return *this;
                }
                Symbol& setFillColor(string c) {
                    if (!fillColor)
                        fillColor = new Color;
 
                    *fillColor = Color(c);
 
                    return *this;
                }
                Color getFillColor() const {
                    if (!fillColor)
                        throw "Fill color was not set!";
                    else
                        return *fillColor;
                }
 
                Symbol& setStrokeColor(Color c) {
                    if (!strokeColor)
                        strokeColor = new Color;
 
                    *strokeColor = c;
 
                    return *this;
                }
 
                Symbol& setStrokeColor(string c) {
                    if (!strokeColor)
                        strokeColor = new Color;
 
                    *strokeColor = Color(c);
 
                    return *this;
                }
 
                Color getStrokeColor() {
                    if (!strokeColor)
                        throw "Stroke color was not set!";
                    else
                        return *strokeColor;
                }
 
                Symbol& setStrokeWidth(float strk_width) {
                    if (!strokeWidth)
                        strokeWidth = new float;
 
                    if (strk_width < 0.0f)
                        throw "Stroke width must be positive or null";
                    else
                        *strokeWidth = strk_width;
 
                    return *this;
                }
 
                float getStrokeWidth() const {
                    if (!strokeWidth)
                        throw "Stroke width not set!";
 
                    return *strokeWidth;
                }
 
                Symbol& setOpacity(float op) {
                    if (!opacity)
                        opacity = new float;
 
                    if (op < 0.0f || op > 1.0f)
                        throw "Opacity must be between 0 and 1";
                    else
                        *opacity = op;
 
                    return *this;
                }
 
                float getOpacity() const {
                    if (!opacity)
                        throw "Opacity not set!";
 
                    return *opacity;
                }
 
                Symbol& setStrokeDash(int dash) {
                    if (!strokeDash)
                        strokeDash = new int;
 
                    if (dash < 0 || dash > 10)
                        throw "Dash must be between 0 and 10 (inclusive)";
                    else
                        *strokeDash = dash;
 
                    return *this;
                }
 
                int getStrokeDash() const {
                    if (!strokeDash)
                        throw "Stroke dash  not set!";
 
                    return *strokeDash;
                }
 
                Symbol& setLayer(int l) {
                    if (!layer)
                        layer = new int;
 
                    *layer = l;
 
                    return *this;
                }
 
                int getLayer() const {
                    return *layer;
                }
 
            protected:
                virtual string getShapeType() const  = 0;
 
            public:
                Symbol& translate (float tx, float ty) {
                    float result[3][3];
                    float transl[3][3] = {
                        {1., 0., tx}, {0., 1., ty}, {0., 0., 1.}
                    };
 
                    // update current transform matrix
                    matMult (transl, xform, result);
                    copyMat (result, xform);
 
                    xform_flag = true;
 
                    return *this;
                }
 
                Symbol& scale(float sx, float sy) {
                    float result[3][3];
                    float scale[3][3] = {
                        {sx, 0., 0.}, {0., sy, 0.}, {0., 0., 1.}
                    };
 
                    // update current transform matrix
                    matMult (scale, xform, result);
                    copyMat (result, xform);
 
                    xform_flag = true;
 
                    return *this;
                }
 
                Symbol& scale(float scalefactor) {
                    return scale(scalefactor, scalefactor);
                }
 
                Symbol& rotate(float angle) {
                    // compute sin, cos
                    float angle_r = angle * M_PI / 180.;
                    float c = cos(angle_r);
                    float s = sin(angle_r);
 
                    // form the rotation matrix
                    float result[3][3];
                    float rotation[3][3] = {
                        {c, -s, 0.}, {s, c, 0.}, {0., 0., 1.}
                    };
 
                    // update current transform matrix
                    matMult (rotation, xform, result);
                    copyMat (result, xform);
 
                    xform_flag = true;
 
                    return *this;
                }
 
                Symbol& scale(float sx, float sy, float px, float py) {
                    float result[3][3], result2[3][3];
                    float scale[3][3] = {
                        {sx, 0., 0.}, {0., sy, 0.}, {0., 0., 1.}
                    };
                    float transl1[3][3] =
                    { {1., 0., -px}, {0., 1., -py}, {0., 0., 1.} };
                    float transl2[3][3] =
                    { {1., 0., px}, {0., 1., py}, {0., 0., 1.} };
 
                    // form the composite transform
                    matMult (scale, transl1, result);
                    matMult (transl2, result, result2);
 
                    // update current transform matrix
                    matMult (result2, xform, result);
                    copyMat (result, xform);
 
                    xform_flag = true;
 
                    return *this;
                }
 
                Symbol& rotate(float angle, float px, float py) {
                    // compute sin, cos
                    float angle_r = angle * M_PI / 180.;
                    float c = cos(angle_r);
                    float s = sin(angle_r);
 
                    // form the rotation matrix
                    float result[3][3], result2[3][3];
                    float rotation[3][3] = {
                        {c, -s, 0.}, {s, c, 0.}, {0., 0., 1.}
                    };
                    float transl1[3][3] =  {
                        {1., 0., -px}, {0., 1., -py}, {0., 0., 1.}
                    };
                    float transl2[3][3] =  {
                        {1., 0., px}, {0., 1., py}, {0., 0., 1.}
                    };
 
                    // form the composite transform
                    matMult (rotation, transl1, result);
                    matMult (transl2, result, result2);
 
                    // update current transform matrix
                    matMult (result2, xform, result);
                    copyMat (result, xform);
 
                    xform_flag = true;
 
                    return *this;
                }
                Symbol& setTransform(float a, float b, float c,
                    float d, float e, float f) {
                    xform[0][0] = a;
                    xform[1][0] = b;
                    xform[0][1] = c;
                    xform[1][1] = d;
                    xform[0][2] = e;
                    xform[2][2] = f;
                    xform[2][0] = 0.0f;
                    xform[2][1] = 0.0f;
                    xform[2][2] = 1.0f;
 
                    xform_flag = true;
 
                    return *this;
                }
 
            protected:
 
                const string getSymbolAttributeRepresentation() const {
 
                    // first get all the non-geometric attributes
 
                    using bridges::JSONUtil::JSONencode;
 
                    string symbol_attr_json = OPEN_CURLY;
 
                    symbol_attr_json += QUOTE + "type" + QUOTE + COLON +
                        QUOTE + getShapeType() + QUOTE + COMMA +
                        QUOTE + "ID" + QUOTE + COLON +
                        QUOTE + to_string(identifier) + QUOTE + COMMA;
 
                    // check transform, if it is not set, ignore
                    if (this->xform_flag) {
                        symbol_attr_json +=
                            QUOTE + "transform" + QUOTE + COLON +
                            OPEN_BOX +
                            JSONencode(this->xform[0][0]) + COMMA +
                            JSONencode(this->xform[1][0]) + COMMA +
                            JSONencode(this->xform[0][1]) + COMMA +
                            JSONencode(this->xform[1][1]) + COMMA +
                            JSONencode(this->xform[0][2]) + COMMA +
                            JSONencode(this->xform[1][2]) +
                            CLOSE_BOX + COMMA;
                    }
                    if (layer) {
                        symbol_attr_json += QUOTE + "layer" + QUOTE +
                            COLON + to_string(*layer) + COMMA;
                    }
 
                    // the above attributes are all that is needed for 'group'
                    // type, rest also include the following
                    if (getShapeType() == "group") {
                        // remove the last comma
                        symbol_attr_json.erase (symbol_attr_json.size() - 1);
                        symbol_attr_json += CLOSE_CURLY;
                    }
                    else {
 
                        if (fillColor) {
                            symbol_attr_json += QUOTE + "fill-color" +
                                QUOTE + COLON + fillColor->getCSSRepresentation()
                                + COMMA;
                        }
 
                        if (opacity) {
                            symbol_attr_json += QUOTE + "opacity" + QUOTE + COLON +
                                to_string(*opacity) + COMMA;
                        }
 
                        if (strokeColor) {
                            symbol_attr_json += QUOTE + "stroke-color" + QUOTE +
                                COLON + strokeColor->getCSSRepresentation() + COMMA;
                        }
 
                        if (strokeWidth) {
                            symbol_attr_json += QUOTE + "stroke-width" + QUOTE +
                                COLON + to_string(*strokeWidth) + COMMA;
                        }
 
                        if (strokeDash) {
                            symbol_attr_json += QUOTE + "stroke-dasharray" + QUOTE +
                                COLON + to_string(*strokeDash) + COMMA;
                        }
                    }
 
                    return symbol_attr_json;
                }
        };
 
        // initialize the id to start at zero
        int Symbol::ids = 0;
    }
} // namespace bridges
 
#endif