Circle.h

Go to the documentation of this file.

#include "DataStructure.h"
#include "Symbol.h"
#include <vector>

using namespace std;


#ifndef  CIRCLE_H

#define CIRCLE_H

namespace bridges {
    namespace datastructure {
        class Circle : public Symbol {
            private:

                int radius = 1.;

            public:

                Circle () {
                    setCircle(0., 0., 1.);
                }

                Circle (int r) {
                    setCircle (0., 0., r);
                }

                Circle (int locx, int locy, int r) {
                    setLocation ((float)locx, (float)locy);
                    if (r < 0)
                        throw "Illegal value for radius. Must be positive";
                    radius = r;
                }

                string getDataStructType() {
                    return "circle";
                }

                string getName()  const {
                    return "circle";
                }

                void setRadius(int r) {
                    if (r < 0)
                        throw "Illegal value for radius. Must be positive";
                    radius = r;
                }

                void setCircle (int locx, int locy, int r) {
                    setLocation (locx, locy);
                    if (r < 0)
                        throw "Illegal value for radius. Must be positive";
                    radius = r;
                    setShapeType("circle");
                }

                void translate(float tx, float ty) {
                    const float *center = getLocation();
                    float ncenter[2];
                    ncenter[0] = center[0];
                    ncenter[1] = center[1];
                    translatePoint (ncenter, tx, ty);
                    setLocation(ncenter[0], ncenter[1]);
                }
                void scale(float scale) {
                    // scale only the radius,
                    // center stays the same
                    radius  *= scale;
                }
                vector<float> getDimensions() const {

                    vector<float> dims(4);
                    const float *location = getLocation();

                    dims[0] = location[0] - radius;
                    dims[1] = location[0] + radius;
                    dims[2] = location[1] - radius;
                    dims[3] = location[1] + radius;

                    return dims;
                }

                const string getSymbolRepresentation() const {

                    string shape_json = getSymbolAttributeRepresentation();
                    string shape = getShapeType();

                    shape_json +=
                        QUOTE + "name" + QUOTE + COLON +  QUOTE + getLabel() + QUOTE + COMMA +
                        QUOTE + "shape" + QUOTE + COLON + QUOTE + shape + QUOTE + COMMA;

                    if (shape == "circle")
                        shape_json += QUOTE + "r" + QUOTE + COLON + to_string(radius)
                            + CLOSE_CURLY;

                    return shape_json;

                }
        };
    }
} // namespace bridges

#endif