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;
                unordered_map<string, int> line_width; // indexed by data series name
 
            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 setLineWidth(string series, int w) {
                    line_width[series] = w;
                }
 
                int getLineWidth(string series) {
                    return line_width[series];
                }
 
                void setDataSeries(string seriesName, vector<double> xdata, vector<double> ydata) {
                    setXData(seriesName, xdata);
                    setYData(seriesName, ydata);
                    line_width[seriesName] = 1;  // default is lines on at size of 1 pixel
                }
 
                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);
 
                    // get line width of each series into JSON
                    string lw_json = JSONencode("linewidth") + COLON + OPEN_CURLY;
                    for (auto k: line_width) {
                        lw_json +=  QUOTE + k.first + QUOTE + COLON + std::to_string(k.second) + COMMA;
                    }
                    lw_json = lw_json.erase(lw_json.length()-1);
                    lw_json += CLOSE_CURLY;
 
                    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 + COMMA + 
                                lw_json + 
                        CLOSE_CURLY;
 
                    return json_str;
                }
        };
    }
}
#endif