Polyline.h

Go to the documentation of this file.

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

using namespace std;


#ifndef  POLYLINE_H

#define POLYLINE_H

namespace bridges {
    namespace datastructure {
        class Polyline : public Symbol {
            protected:
                // points of the polyline
                vector<float> points;

            public:
                Polyline () {
                    points.clear();
                    setShapeType("polyline");
                }

                Polyline (vector<float> pts) {
                    setPolyline(pts);
                }

                string getDataStructType() {
                    return "polyline";
                }

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

                void addPoint(float x, float y) {
                    if  ((x > -INFINITY) && (x < INFINITY) &&
                        (y > -INFINITY) && (y < INFINITY)) {
                        points.push_back(x);
                        points.push_back(y);
                    }
                    else {
                        throw "Invalid points for polyline!";
                    }
                }
                vector<float> getPoints() {
                    return points;
                }

                void setPolyline (vector<float> pts) {
                    points = pts;
                    setShapeType("polyline");
                }

                void translate(float tx, float ty) {
                    // translate the points
                    for (int k = 0; k < points.size(); k += 2) {
                        points[k]   += tx;
                        points[k + 1] += ty;
                    }
                }

                void rotate(float angle) {
                    // get center of polyline
                    float center[2];
                    getCenter(center);
                    // translate the center to the origin
                    float transl[] = {-center[0], -center[1]};
                    translate (transl[0], transl[1]);
                    // rotate the points
                    for (int k = 0; k < points.size(); k += 2) {
                        float tmp[] = { points[k], points[k + 1] };
                        rotatePoint (tmp,  angle);
                        points[k] = tmp[0];
                        points[k + 1] = tmp[1];
                    }
                    // translate back
                    transl[0] = center[0];
                    transl[1] = center[1];
                    translate (transl[0], transl[1]);
                }

                void scale(float sx, float sy) {
                    // get center of polyline
                    float center[2];
                    getCenter(center);
                    // translate the center to the origin
                    float transl[] = {-center[0], -center[1]};
                    translate (transl[0], transl[1]);
                    // scale the points
                    for (int k = 0; k < points.size(); k += 2) {
                        points[k]   *= sx;
                        points[k + 1] *= sy;
                    }
                    // translate back
                    transl[0] = center[0];
                    transl[1] = center[1];
                    translate(transl[0], transl[1]);
                }

                void getCenter(float *center) {
                    float bbox[4];
                    bbox[0] = bbox[1] = INFINITY;
                    bbox[2] = bbox[3] = -INFINITY;
                    for (int k = 0; k < points.size(); k += 2) {
                        if (points[k] < bbox[0])
                            bbox[0] = points[k];
                        if (points[k] > bbox[2])
                            bbox[2] = points[k];
                        if (points[k + 1] < bbox[1])
                            bbox[1] = points[k + 1];
                        if (points[k + 1] > bbox[3])
                            bbox[3] = points[k + 1];
                    }
                    center[0] = bbox[0] + (bbox[2] - bbox[0]) / 2.;
                    center[1] = bbox[1] + (bbox[3] - bbox[1]) / 2.;
                }

                vector<float> getDimensions() const {

                    vector<float> dims(4);
                    dims[0] = dims[2] = INFINITY;
                    dims[1] = dims[3] = -INFINITY;
                    float x, y;
                    for (std::size_t i = 0, size = points.size();
                        i < size; i += 2) {
                        x = points.at(i);
                        y = points.at(i + 1);
                        if (x < dims[0])
                            dims[0] = x;
                        if (x > dims[1])
                            dims[1] = x;
                        if (y < dims[2])
                            dims[2] = y;
                        if (y > dims[3])
                            dims[3] = y;
                    }
                    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;

                    // add point list to polygons
                    shape_json += QUOTE + "points" + QUOTE + COLON + OPEN_BOX;
                    vector<float>::iterator it;
                    for (int k = 0; k < points.size(); k++) {
                        shape_json += to_string(points[k]) + COMMA;
                    }

                    // remove last comma
                    if (points.size())
                        shape_json.erase(shape_json.size() - 1);
                    shape_json += CLOSE_BOX + CLOSE_CURLY;

                    return shape_json;
                }
        };
    }
} // namespace bridges

#endif