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 {
 
            private:
 
                virtual string getShapeType()  const override {
                    return "polyline";
                }
 
            protected:
                // points of the polyline
                vector<float> points;
 
            public:
                Polyline () {
                    points.clear();
                }
 
                Polyline (vector<float> pts) {
                    setPolyline(pts);
                }
 
                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;
                }
 
                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.;
                }
 
                const string getSymbolRepresentation() const override {
 
                    string shape_json = getSymbolAttributeRepresentation();
                    string shape = getShapeType();
 
                    // 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