LineChart.h

Go to the documentation of this file.

#ifndef LINE_CHART_H
#define LINE_CHART_H
 
#include <unordered_map>
#include <vector>
#include <string>
#include <DataStructure.h>
#include <JSONutil.h>
 
namespace bridges {
    namespace datastructure {
        class LineChart : public DataStructure {
 
            private:
                string plotTitle;
                string plotSubtitle;
                string xLabel;
                string yLabel;
                bool mouseTrack;
                bool dataLabel;
                bool logarithmicx;
                bool logarithmicy;
 
                unordered_map<string, vector<double >> xaxisData;
                unordered_map<string, vector<double >> yaxisData;
 
            public:
                LineChart() {
                    plotTitle = "";
                    plotSubtitle = "";
                    yLabel = "";
                    xLabel = "";
                    mouseTrack = false;
                    dataLabel = true;
                    logarithmicx = false;
                    logarithmicy = false;
                }
 
                virtual const string getDStype() const override {
                    return "LineChart";
                }
 
                void toggleMouseTrack(bool val) {
                    mouseTrack = val;
                }
 
                void toggleSeriesLabel(bool val) {
                    dataLabel = val;
                }
 
                void toggleLogarithmicX(bool val) {
                    logarithmicx = val;
                }
 
                void toggleLogarithmicY(bool val) {
                    logarithmicy = val;
                }
 
                void setTitle(string t) {
                    plotTitle = t;
                }
 
                string getTitle() const {
                    return plotTitle;
                }
 
                void setSubTitle(string s) {
                    plotSubtitle = s;
                }
 
                string getSubTitle() const {
                    return plotSubtitle;
                }
 
                void setYLabel(string yaxisName) {
                    yLabel = yaxisName;
                }
 
                string getYLabel() const {
                    return yLabel;
                }
 
                void setXLabel(string xaxisName) {
                    xLabel = xaxisName;
                }
 
                string getXLabel() const {
                    return xLabel;
                }
 
                void setDataSeries(string seriesName, vector<double> xdata, vector<double> ydata) {
                    setXData(seriesName, xdata);
                    setYData(seriesName, ydata);
                }
 
                void setXData(string series, vector<double> xdata) {
                    xaxisData[series] =  xdata;
                }
 
                vector<double> getXData(string series) {
                    return  xaxisData[series];
                }
 
                void setYData(string series, vector<double> ydata) {
                    yaxisData[series]  = ydata;
                }
 
                vector<double> getYData(string series) {
                    return yaxisData[series];
                }
 
            private:
                bool check() const {
                    bool correct = true;
                    for (auto& entry : xaxisData) {
                        string series = entry.first;
                        vector<double> xdata = entry.second;
                        vector<double> ydata = yaxisData.at(series);
                        if (!ydata.size()) {
                            cout << "Series \"" + series + "\" has xdata but no ydata";
                            correct = false;
                        }
                        if (xdata.size() != ydata.size()) {
                            cout << "Series \"" + series + "\" has xdata and ydata of different sizes";
                            correct = false;
                        }
                        if (logarithmicx) {
                            for (int i = 0; i < xdata.size(); ++i) {
                                if (xdata[i] == 0) {
                                    cout << "Xaxis scale is logarithmic but series \"" + series
                                        + "\" has xdata[" << i << "] = " <<  xdata[i]  <<
                                        " (should be stricly positive)";
                                }
                            }
                        }
                        if (logarithmicy) {
                            for (int i = 0; i <  ydata.size(); ++i) {
                                if (ydata[i] == 0) {
                                    cout << "Yaxis scale is logarithmic but series \"" +
                                        series + "\" has ydata[" <<  i <<  "] = "  <<  ydata[i] <<
                                        " (should be stricly positive)";
                                }
                            }
                        }
                    }
                    for (auto& entry : yaxisData) {
                        string series = entry.first;
                        vector<double> ydata = entry.second;
                        vector<double> xdata = xaxisData.at(series);
                        if (!xdata.size()) {
                            cout << "Series: " + series + " has ydata but no xdata";
                            correct = false;
                        }
                        //Everything else already checked.
                    }
                    return correct;
                }
 
            public:
                virtual const string getDataStructureRepresentation() const override {
                    using bridges::JSONUtil::JSONencode;
                    check();
                    string xaxis_json = "";
                    for (auto& entry : xaxisData) {
                        string key = entry.first;
                        vector<double> value = entry.second;
 
                        xaxis_json += OPEN_CURLY + JSONencode("Plot_Name")
                            + COLON + JSONencode( key ) + COMMA +
                            JSONencode("xaxis_data") + COLON + OPEN_BOX;
                        for ( int i = 0; i < value.size() ; i++) {
                            xaxis_json += JSONencode(value[i]) + COMMA;
                        }
                        xaxis_json = xaxis_json.erase(xaxis_json.size() - 1);
                        xaxis_json += CLOSE_BOX + CLOSE_CURLY + COMMA;
                    }
                    xaxis_json = xaxis_json.erase(xaxis_json.length() - 1);
 
                    string yaxis_json = "";
                    for (auto& entry : yaxisData) {
                        string key = entry.first;
                        vector<double> value = entry.second;
                        yaxis_json += OPEN_CURLY + JSONencode("Plot_Name")
                            + COLON + JSONencode( key) + COMMA +
                            JSONencode("yaxis_data") + COLON + OPEN_BOX;
                        for ( int i = 0; i <  value.size() ; i++) {
                            yaxis_json +=  JSONencode(value[i])  + COMMA;
                        }
                        yaxis_json = yaxis_json.erase(yaxis_json.length() - 1);
                        yaxis_json += CLOSE_BOX + CLOSE_CURLY + COMMA;
                    }
                    yaxis_json = yaxis_json.erase(yaxis_json.length() - 1);
 
                    string json_str = JSONencode("plot_title") + COLON +  JSONencode(getTitle()) + COMMA +
                        JSONencode("subtitle") + COLON + JSONencode(getSubTitle())  + COMMA +
                        JSONencode("xLabel") + COLON + JSONencode(getXLabel()) +  COMMA +
                        JSONencode("yLabel") + COLON + JSONencode(getYLabel()) + COMMA +
                        JSONencode("xaxisType") + COLON + JSONencode(logarithmicx) + COMMA +
                        JSONencode("yaxisType") + COLON + JSONencode(logarithmicy) + COMMA +
                        JSONencode("options") + COLON + OPEN_CURLY + JSONencode("mouseTracking") + COLON +
                        JSONencode(mouseTrack) + COMMA + JSONencode("dataLabels") + COLON + JSONencode(dataLabel) + CLOSE_CURLY + COMMA +
                        JSONencode("xaxis_data") + COLON + OPEN_BOX + xaxis_json + CLOSE_BOX + COMMA +
                        JSONencode("yaxis_data") + COLON + OPEN_BOX + yaxis_json + CLOSE_BOX +
                        CLOSE_CURLY;
 
                    return json_str;
                }
                /*
                                virtual void getDataStructureRepresentation(rapidjson::Document& d)
                                                                         const override {
                                    using namespace rapidjson;
                                    check();
                                    Document::AllocatorType& allocator = d.GetAllocator();
                                    Value xdata_charts(kArrayType);
                                    for (auto& entry : xaxisData) {
                                        Value key, value, obj;
 
                                        obj.SetObject();
                                        key.SetString("Plot_Name", allocator);
                                        value.SetString(entry.first.c_str(), allocator);
                                        obj.AddMember(key, value, allocator);
 
                                        Value xaxis_arr(kArrayType);
                                        for (auto val : entry.second) {
                                            Value v; v.SetDouble(val);
                                            xaxis_arr.PushBack(v, allocator);
                                        }
                                        obj.AddMember("xaxis_data", xaxis_arr, allocator);
                                        xdata_charts.PushBack(obj, allocator);
                                    }
                                    d.AddMember("xaxis_data", xdata_charts, allocator);
 
                                    Value yaxis_arr(kArrayType);
                                    for (auto& entry : yaxisData) {
                                        Value key, value, obj;
 
                                        obj.SetObject();
                                        key.SetString("Plot_Name", allocator);
                                        value.SetString(entry.first.c_str(), allocator);
                                        obj.AddMember(key, value, allocator);
 
                                        key.SetString("yaxis_data", allocator);
                                        Value plot_arr(kArrayType);
                                        for (auto val : entry.second) {
                                            Value v; v.SetDouble(val);
                                            plot_arr.PushBack(v, allocator);
                                        }
                                        obj.AddMember("yaxis_data", plot_arr, allocator);
                                        yaxis_arr.PushBack(obj, allocator);
                                    }
                                    d.AddMember("yaxis_data", yaxis_arr, allocator);
                                    Value v;
                                    v.SetString(getTitle().c_str(), allocator);
                                    d.AddMember("plot_title", v, allocator);
                                    v.SetString(getXLabel().c_str(), allocator);
                                    d.AddMember("xLabel", v, allocator);
                                    v.SetString(getYLabel().c_str(), allocator);
                                    d.AddMember("yLabel", v, allocator);
                                    d.AddMember("xaxisType", v.SetBool(logarithmicx), allocator);
                                    d.AddMember("yaxisType", v.SetBool(logarithmicy), allocator);
 
                                    Value obj;
                                    obj.SetObject();
                                    obj.AddMember("mouseTracking", v.SetBool(mouseTrack), allocator);
                                    obj.AddMember("dataLabels", v.SetBool(dataLabel), allocator);
                                    d.AddMember("options", obj, allocator);
 
                                    StringBuffer sb;
                                    Writer<StringBuffer> writer(sb);
                                    d.Accept(writer);
                                };
                */
        };
    }
}
#endif