doxygen/openfpm/GoogleChart_8hpp_source.html

 /*
  * GoogleChart.hpp
  *
  *  Created on: Jan 9, 2016
  *      Author: i-bird
  */

 #ifndef OPENFPM_DATA_SRC_PLOT_GOOGLECHART_HPP_
 #define OPENFPM_DATA_SRC_PLOT_GOOGLECHART_HPP_

 #include <fstream>
 #include "Vector/map_vector.hpp"
 #include <cmath>

 #define GGRAPH_COLUMS 1
 #define GGRAPH_POINTS 2

 #define GC_ZOOM std::string("explorer: {actions: ['dragToZoom', 'rightClickToReset'],axis: 'horizontal,vertical',keepInBounds: true, maxZoomIn: 128.0}")
 #define GC_X_LOG std::string("hAxis: { logScale: true }")
 #define GC_Y_LOG std::string("vAxis: { logScale: true }")

 struct GCoptions
 {
     std::string title;
     std::string yAxis;
     std::string xAxis;

     std::string stype;

     std::string stypeext;

     size_t width=900;

     size_t heigh=500;

     bool isStacked = false;

     size_t lineWidth = 4;

     std::string intervalsext;

     std::string intervalext;

     std::string more;

     std::string curveType = "function";

     bool barWD = false;

     GCoptions & operator=(const GCoptions & opt)
     {
         title = opt.title;
         yAxis = opt.yAxis;
         xAxis = opt.xAxis;
         stype = opt.stype;
         stypeext = opt.stypeext;
         width=opt.width;
         heigh=opt.heigh;

         lineWidth = opt.lineWidth;
         intervalsext = opt.intervalsext;
         more = opt.more;

         return *this;
     }
 };

 struct GGraph
 {
     size_t type;

     std::string data;

     std::string option;

     std::string view;

     GCoptions opt;
 };


 const std::string begin_data ="<html>\n\
   <head>\n\
     <script type=\"text/javascript\" src=\"https://www.gstatic.com/charts/loader.js\"></script>\n\
     <script src=\"https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js\"></script>\n\
     <script type=\"text/javascript\">\n\
       google.charts.load('current', {'packages':['corechart']});\n\
       google.charts.setOnLoadCallback(drawVisualization);\n\
 \n\
 function exportToSVG(i)\n\
 {\n\
 var e = document.getElementById('chart_div'+i);\n\
 var svg = e.getElementsByTagName('svg')[0].parentNode.innerHTML;\n\
 var pos = svg.lastIndexOf(\"</svg>\");\n\
 pos += 6;\n\
 svg = svg.substring(0,4)  + \" xmlns='http://www.w3.org/2000/svg' xmlns:xlink= 'http://www.w3.org/1999/xlink' \" + svg.substring(4,pos);\n\
 svgData = 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(svg);\n\
 $(this).attr({'href': svgData,'target': '_blank'});\n\
 }\n\
 \n\
       function drawVisualization() {\n";

 const std::string end_data="]);\n\n";

 const std::string begin_div = "}</script>\n\
 </head>\n\
 <body>\n";

 const std::string div_end = "</body>\n\
 </html>\n";

 const std::string saving_javascript = "function save(i)\n\
                                         var e = document.getElementById('chart_')\n\
                                         e.getElementsByTagName('svg')[0].parentNode.innerHTML";

 template<typename T>
 struct check_nan
 {
     static bool check(const T & n)
     {
         return false;
     }
 };

 template<>
 struct check_nan<float>
 {
     static bool check(const float & n)
     {
         return std::isnan(n);
     }
 };

 template<>
 struct check_nan<double>
 {
     static bool check(const double & n)
     {
         return std::isnan(n);
     }
 };


 class GoogleChart
 {
     template<typename arg_0, typename ... args>
     struct get_value_type
     {
         typedef typename arg_0::value_type type;
     };

     openfpm::vector<GGraph> set_of_graphs;

     openfpm::vector<std::string> injectHTML;

     bool holes = false;

     template<typename X, typename ... Xs>
     void recursive_sort(X & x,X & y,Xs& ... xy)
     {
         struct srt_xy
         {
             typename X::value_type x;
             unsigned int id;

             bool operator<(const srt_xy & tmp) const
             {
                 return x < tmp.x;
             }
         };

         openfpm::vector<srt_xy> reord;
         X y_tmp;

         reord.resize(x.size());
         y_tmp.resize(x.size());

         for (size_t i = 0 ; i < x.size() ; i++)
         {
             reord.get(i).x = x.get(i);
             reord.get(i).id = i;
         }

         reord.sort();

         // reorder x and y

         for (size_t i = 0 ; i < x.size() ; i++)
         {
             x.get(i) = reord.get(i).x;
             y_tmp.get(i) = y.get(reord.get(i).id);
         }

         y_tmp.swap(y);

         // sort x

         recursive_sort(xy ...);
     }

     void recursive_sort()
     {}

     template<typename X, typename ... Xs>
     bool isNext(size_t * counters,X & x,X & y,Xs& ... xy)
     {
         if (counters[0] < x.size())
         {
             return true;
         }
         return isNext(&counters[1],xy ...);
     }

     bool isNext(size_t * counters)
     {
         return false;
     }


     template<typename T, typename X, typename ... Xs>
     T get_low(size_t * counters,X & x,X & y,Xs& ... xy)
     {
         if (sizeof...(Xs) != 0)
         {
             T low1;
             if (counters[0] >= x.size())
             {low1 = std::numeric_limits<typename X::value_type>::infinity();}
             else
             {low1 = x.get(counters[0]);}

             T low2 = get_low<T>(&counters[1],xy ...);
             return (low1 < low2)?low1:low2;
         }

         if (counters[0] >= x.size())
         {return std::numeric_limits<typename X::value_type>::infinity();}
         return x.get(counters[0]);
     }

     template<typename T>
     T get_low(size_t * counters)
     {
         return 0.0;
     }

     template<typename X, typename ... Xs>
     void get_point(typename X::value_type low,
                typename X::value_type * point,
                size_t * counters,
                X & x,
                X & y,
                Xs& ... xy)
     {
         if (counters[0] < x.size() && low == x.get(counters[0]))
         {
             point[0] = y.get(counters[0]);
             counters[0]++;
         }
         else
         {
             point[0] = std::numeric_limits<typename X::value_type>::quiet_NaN();
         }

         get_point(low,&point[1],&counters[1],xy...);
     }

     template<typename T>
     void get_point(T low,
                T * point,
                size_t * counters)
     {
         return;
     }

     template<typename ... Xs>
     bool get_v(typename get_value_type<Xs...>::type & x,
                typename get_value_type<Xs...>::type * point,
                size_t * counters,
                Xs& ... xy)
     {
         // if exist the next element
         if (isNext(counters,xy...) == false)
         {return false;}

         // get lowest x
         typename get_value_type<Xs...>::type low = get_low<typename get_value_type<Xs...>::type>(counters,xy...);

         x = low;

         get_point(low,point,counters,xy...);

         return true;
     }

     template<typename X, typename Y> std::string get_points_plot_data(const openfpm::vector<X> & x, const openfpm::vector<Y> & y, const openfpm::vector<std::string> & yn, const GCoptions & opt, size_t i)
     {
         std::stringstream data;

         size_t interval = 0;

         // we require that the number of x elements are the same as y elements

         if (x.size() != y.size())
         {std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " vector x and the vector y must have the same number of elements " << x.size() << "!=" << y.size() << "\n";}

         // Google chart visualization
         data << "var data" << i << " = new google.visualization.DataTable();\n";
         if (std::is_same<X,typename std::string>::value == true)
             data << "data" << i << ".addColumn("  << "'string'" << "," << "'" << opt.xAxis <<"');\n";
         else
             data << "data" << i << ".addColumn("  << "'number'" << "," << "'" << opt.xAxis <<"');\n";

         for (size_t j = 0 ; j < y.last().size() ; j++)
         {
             if (yn.get(j) == std::string("interval"))
             {
                 data << "data" << i << ".addColumn({id:'i" << interval/2 << "', type:'number', role:'interval'});\n";
                 interval++;
             }
             else
                 data << "data" << i << ".addColumn("  << "'number'" << "," << "'" << yn.get(j) <<"');\n";
         }

         data << "data" << i << ".addRows([\n";
         for (size_t i = 0 ; i < y.size() && x.size() ; i++)
         {

             for (size_t j = 0 ; j < y.get(i).size()+1 ; j++)
             {
                 // the first is x
                 if (j == 0)
                 {
                     if (std::is_same<X,typename std::string>::value == true)
                         data << "['"  << x.get(i) << "'";
                     else
                         data << "["  << x.get(i);
                 }
                 else
                 {
                     if (check_nan<typename Y::value_type>::check(y.get(i).get(j-1)) == false)
                     {
                         data << "," << y.get(i).get(j-1);
                     }
                     else
                     {
                         holes = true;
                         data << "," << "null";
                     }
                 }
             }
             data << "],\n";
         }

         return data.str();
     }

     std::string get_view_bar_option(const GCoptions & opt, size_t n_col)
     {
         if (opt.barWD == false)
             return std::string();

         std::stringstream str;

         str << "[0" << std::endl;

         for (size_t i = 1 ; i < n_col ; i++)
         {
             str << "," << i << ",{ calc: \"stringify\"," << std::endl;
             str << "sourceColumn: " << i << "," << std::endl;
             str << "type: \"string\"," << std::endl;
             str << "role: \"annotation\" }"<< std::endl;
         }

         str << "]" << std::endl;

         return str.str();
     }

     std::string get_colums_bar_option(const GCoptions & opt)
     {
         std::stringstream str;
         str << "title : '" << opt.title << "'";
         str << ",\nvAxis: {title: '" << opt.yAxis <<  "'}";
         str << ",\nhAxis: {title: '" << opt.xAxis << "'}";
         str << ",\nseriesType: '" << opt.stype << "'";
         if (opt.stypeext.size() != 0)
             str << ",\nseries: " << opt.stypeext;
         if (opt.more.size() != 0)
             str << ",\n" <<opt.more;

         return str.str();
     }

     std::string get_points_plot_option(const GCoptions & opt)
     {
         std::stringstream str;
         str << "title : '" << opt.title << "'";
         str << ",\nvAxis: {title: '" << opt.yAxis <<  "'}";
         str << ",\nhAxis: {title: '" << opt.xAxis << "'}";
         str << ",\ncurveType: '"<< opt.curveType << "'";

         str << ",\nlineWidth: " << opt.lineWidth;
         if (opt.intervalsext.size() != 0)
             str << ",\nintervals: " << opt.intervalsext;
         else
             str << ",\nintervals: " << "{ 'style':'area' }";

         if (opt.intervalext.size() != 0)
             str << ",\ninterval: " << opt.intervalext << "\n";

         if (opt.more.size() != 0)
             str << ",\n" << opt.more;

         return str.str();
     }

     void addData(std::ofstream & of, size_t i, const std::string & data)
     {

         of << data;
         of << "]);\n";
     }

     void addOption(std::ofstream & of, size_t i, const std::string & opt)
     {
         of << "var options";
         of << i;
         of << "= {\n";
         if (holes == true)
         {of << "interpolateNulls : true,\n";}
         of << opt;
         of << "};\n";
     }

     void addView(std::ofstream & of, size_t i, std::string view)
     {
         if (view.size() == 0)
             return;

         of << "var view" << i << " = new google.visualization.DataView(data" << i << ");" << std::endl;
         of << "view"<< i << ".setColumns(";
         of << view << ");" << std::endl;
     }

     void addDrawDiv(std::ofstream & of, size_t i, bool draw_view)
     {
         of << "$(\"#export_svg" << i << "\").on(\"click\", function (event) {exportToSVG.apply(this,[" << i << "]);});\n";
         of << "var chart = new google.visualization.ComboChart(document.getElementById('chart_div";
         of << i;
         of << "'));" << std::endl;
         if (draw_view == true)
         {
             of << "chart.draw(data";
             of << i;
         }
         else
         {
             of << "chart.draw(view";
             of << i;
         }
         of << ", options";
         of << i;
         of << ");\n";
     }

     void addDiv(std::ofstream & of, size_t i, const GCoptions & gc)
     {
         of << "<a href=\"#\" download=\"graph1.svg\" id=\"export_svg" << i << "\"><button>Export data into svg</button></a>";
         of << "<div id=\"chart_div";
         of << i;
         of << "\" style=\"width: ";
         of << gc.width;
         of << "px; height: ";
         of << gc.heigh;
         of << "px;\"></div>\n";
     }

 public:

     GoogleChart()
     {
         injectHTML.add();
     }

     template<typename Y> void AddHistGraph(openfpm::vector<Y> & y)
     {
         openfpm::vector<std::string> x;
         x.resize(y.size());

         AddHistGraph<std::string,Y>(x,y);
     }

     template<typename X, typename Y> void AddHistGraph(openfpm::vector<X> & x, openfpm::vector<Y> & y)
     {
         GCoptions opt;

         openfpm::vector<std::string> yn;

         if (y.size() != 0)
             yn.resize(y.get(0).size());

         AddHistGraph<X,Y,std::string>(x,y,yn,opt);
     }

     template<typename X, typename Y, typename Yn> void AddHistGraph(openfpm::vector<X> & x, openfpm::vector<Y> & y, openfpm::vector<Yn> & yn)
     {
         GCoptions opt;

         AddHistGraph(x,y,yn,opt);
     }

     template<typename X, typename Y, typename Yn> void AddHistGraph(openfpm::vector<X> & x, openfpm::vector<Y> & y, openfpm::vector<Yn> & yn , const GCoptions & opt)
     {
         set_of_graphs.add();
         injectHTML.add();

         // Check that all the internal vector has the same number of elements

         if (y.size() != 0)
         {
             size_t sz = y.get(0).size();
             for (size_t i = 0; i < y.size() ; i++)
             {
                 if (y.get(i).size() != sz)
                     std::cerr << __FILE__ << ":" << __LINE__ << " error all the elements in the y vector must have the same numbers, element " << i << ": " << y.get(i).size() << " " << " mismatch the numbers of elements at 0: " << sz << "/n";
             }
         }

         set_of_graphs.last().type = GGRAPH_COLUMS;
         set_of_graphs.last().data = get_points_plot_data(x,y,yn,opt,set_of_graphs.size()-1);
         set_of_graphs.last().option = get_colums_bar_option(opt);
         set_of_graphs.last().view = get_view_bar_option(opt,y.get(0).size());
         set_of_graphs.last().opt = opt;
     }


     template<typename ... X> void AddLines(const openfpm::vector<std::string> & yn,
                                            const GCoptions & opt,
                                            X ... xy)
     {
         // first we sort the vectors
         recursive_sort(xy ... );

         size_t counters[sizeof...(X)];
         memset(&counters,0,sizeof(counters));

         typename get_value_type<X...>::type point[sizeof...(X)];
         typename get_value_type<X...>::type xe;

         openfpm::vector<typename get_value_type<X...>::type> x;

         openfpm::vector<openfpm::vector<typename get_value_type<X...>::type>> y;


         while (get_v(xe,point,counters,xy...))
         {
             y.add();
             x.add(xe);

             for (size_t i = 0 ; i < sizeof...(X)/2 ; i++)
             {
                 y.last().add(point[i]);
             }
         }

         AddLinesGraph(x,y,yn,opt);
     }

     template<typename X, typename Y> void AddLinesGraphT(openfpm::vector<X> & x, openfpm::vector<Y> & y , const GCoptions & opt)
     {
         openfpm::vector<std::string> yn;

         if (y.size() == 0)
         {
             std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " vector y must be filled" << std::endl;
             return;
         }

         for (size_t i = 0 ; i < y.last().size() ; i++)
             yn.add(std::string("line") + std::to_string(i));

         if (y.size() == 0)
             return;

         // number of points
         size_t np = y.last().size();

         for (size_t j = 0 ; j < y.size() ; j++)
         {
             if (y.get(j).size() != np)
                 std::cerr << __FILE__ << ":" << __LINE__ << " Error all the graph must have the same number of points " << np << "!=" << y.get(j).size() << std::endl;
         }

         openfpm::vector<openfpm::vector<X>> swap;


         // swap the vector
         // Each vector is a graph
         // It is different from the other call where each vector
         // has multiple value for the same point
         for (size_t i = 0 ; i < np ; i++)
         {
             swap.add();
             for (size_t j = 0 ; j < y.size() ; j++)
             {
                 swap.last().add(y.get(j).get(i));
             }
         }

         AddLinesGraph(x,swap,yn,opt);
     }

     template<typename X, typename Y> void AddLinesGraph(openfpm::vector<X> & x, openfpm::vector<Y> & y , const GCoptions & opt)
     {
         openfpm::vector<std::string> yn;

         if (y.size() == 0)
         {
             std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " vector y must be filled";
             return;
         }

         for (size_t i = 0 ; i < y.last().size() ; i++)
             yn.add(std::string("line") + std::to_string(i));

         AddLinesGraph(x,y,yn,opt);
     }

     template<typename X, typename Y> void AddLinesGraph(openfpm::vector<X> & x, openfpm::vector<Y> & y , const openfpm::vector<std::string> & yn, const GCoptions & opt)
     {
         if (y.size() == 0)
         {
             std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " vector y must be filled\n";
             return;
         }

         set_of_graphs.add();
         injectHTML.add();

         // Check that all the internal vectors has the same number of elements

         if (y.size() != 0)
         {
             size_t sz = y.get(0).size();
             for (size_t i = 0; i < y.size() ; i++)
             {
                 if (y.get(i).size() != sz)
                     std::cerr << __FILE__ << ":" << __LINE__ << " error all the elements in the y vector must have the same numbers of elements " << y.get(i).size() << " != " << sz << "\n";
             }
         }

         set_of_graphs.last().type = GGRAPH_POINTS;
         set_of_graphs.last().data = get_points_plot_data(x,y,yn,opt,set_of_graphs.size()-1);
         set_of_graphs.last().option = get_points_plot_option(opt);
         set_of_graphs.last().opt = opt;
     }

     void addHTML(const std::string & html)
     {
         injectHTML.last() = html;
     }

     void write(std::string file)
     {
         // Open a file

         std::ofstream of(file);

         // Check if the file is open
         if (of.is_open() == false)
         {std::cerr << "Error cannot create the HTML file: " + file + "\n";}

         // write the file

         of << begin_data;

         for (size_t i = 0 ; i < set_of_graphs.size() ; i++)
             addData(of,i,set_of_graphs.get(i).data);

         for (size_t i = 0 ; i < set_of_graphs.size() ; i++)
             addOption(of,i,set_of_graphs.get(i).option);

         for (size_t i = 0 ; i < set_of_graphs.size() ; i++)
             addView(of,i,set_of_graphs.get(i).view);

         for (size_t i = 0 ; i < set_of_graphs.size() ; i++)
             addDrawDiv(of,i,set_of_graphs.get(i).view.size() == 0);

         of << begin_div;

         of << injectHTML.get(0);

         for (size_t i = 0 ; i < set_of_graphs.size() ; i++)
         {
             addDiv(of,i,set_of_graphs.get(i).opt);
             of << injectHTML.get(i+1);
         }

         of << div_end;

         of.close();
     }
 };

 #endif /* OPENFPM_DATA_SRC_PLOT_GOOGLECHART_HPP_ */
GCoptions::heigh
size_t heigh
height of the graph in pixels
Definition: GoogleChart.hpp:49

GGraph::opt
GCoptions opt
Google chart option.
Definition: GoogleChart.hpp:118

GoogleChart::get_low
T get_low(size_t *counters)
Recursively sort variadic template of vectors.
Definition: GoogleChart.hpp:349

GoogleChart::addDiv
void addDiv(std::ofstream &of, size_t i, const GCoptions &gc)
Add a div section.
Definition: GoogleChart.hpp:651

GCoptions::curveType
std::string curveType
curve type
Definition: GoogleChart.hpp:70

GoogleChart::addHTML
void addHTML(const std::string &html)
Add HTML text.
Definition: GoogleChart.hpp:949

GoogleChart::addOption
void addOption(std::ofstream &of, size_t i, const std::string &opt)
Add an option data variable.
Definition: GoogleChart.hpp:588

GoogleChart::AddLinesGraph
void AddLinesGraph(openfpm::vector< X > &x, openfpm::vector< Y > &y, const GCoptions &opt)
Add a simple lines graph.
Definition: GoogleChart.hpp:886

GoogleChart::injectHTML
openfpm::vector< std::string > injectHTML
set inject HTML;
Definition: GoogleChart.hpp:227

check_nan
Definition: GoogleChart.hpp:158

GCoptions::isStacked
bool isStacked
Definition: GoogleChart.hpp:53

GoogleChart::AddHistGraph
void AddHistGraph(openfpm::vector< X > &x, openfpm::vector< Y > &y, openfpm::vector< Yn > &yn)
Add an histogram graph.
Definition: GoogleChart.hpp:714

GCoptions::title
std::string title
Title of the chart.
Definition: GoogleChart.hpp:28

GoogleChart::AddHistGraph
void AddHistGraph(openfpm::vector< X > &x, openfpm::vector< Y > &y, openfpm::vector< Yn > &yn, const GCoptions &opt)
Add an histogram graph.
Definition: GoogleChart.hpp:733

GoogleChart::AddHistGraph
void AddHistGraph(openfpm::vector< X > &x, openfpm::vector< Y > &y)
Add an histogram graph.
Definition: GoogleChart.hpp:692

GoogleChart::get_point
void get_point(typename X::value_type low, typename X::value_type *point, size_t *counters, X &x, X &y, Xs &... xy)
Recursively sort variadic template of vectors.
Definition: GoogleChart.hpp:362

GGraph::data
std::string data
data
Definition: GoogleChart.hpp:109

GoogleChart::holes
bool holes
Data has holes.
Definition: GoogleChart.hpp:230

GCoptions::more
std::string more
more
Definition: GoogleChart.hpp:67

GGraph::view
std::string view
view in case we need a view
Definition: GoogleChart.hpp:115

GCoptions::stypeext
std::string stypeext
Definition: GoogleChart.hpp:43

GoogleChart::isNext
bool isNext(size_t *counters, X &x, X &y, Xs &... xy)
Recursively sort variadic template of vectors.
Definition: GoogleChart.hpp:295

openfpm::vector::size
size_t size()
Stub size.
Definition: map_vector.hpp:211

GoogleChart::addData
void addData(std::ofstream &of, size_t i, const std::string &data)
Add a graph data variable.
Definition: GoogleChart.hpp:574

GoogleChart::get_point
void get_point(T low, T *point, size_t *counters)
Recursively sort variadic template of vectors.
Definition: GoogleChart.hpp:390

GoogleChart::AddLinesGraphT
void AddLinesGraphT(openfpm::vector< X > &x, openfpm::vector< Y > &y, const GCoptions &opt)
Add lines graph.
Definition: GoogleChart.hpp:819

GCoptions::yAxis
std::string yAxis
Y axis name.
Definition: GoogleChart.hpp:30

GoogleChart::AddLines
void AddLines(const openfpm::vector< std::string > &yn, const GCoptions &opt, X ... xy)
Add lines graph.
Definition: GoogleChart.hpp:767

GoogleChart::get_value_type
Definition: GoogleChart.hpp:218

GoogleChart::set_of_graphs
openfpm::vector< GGraph > set_of_graphs
set of graphs
Definition: GoogleChart.hpp:224

GoogleChart
Small class to produce graph with Google chart in HTML.
Definition: GoogleChart.hpp:215

GCoptions::intervalext
std::string intervalext
Definition: GoogleChart.hpp:64

GGraph
Google Graph.
Definition: GoogleChart.hpp:103

GCoptions::operator=
GCoptions & operator=(const GCoptions &opt)
copy operator
Definition: GoogleChart.hpp:82

GoogleChart::recursive_sort
void recursive_sort(X &x, X &y, Xs &... xy)
Recursively sort variadic template of vectors.
Definition: GoogleChart.hpp:240

GoogleChart::get_v
bool get_v(typename get_value_type< Xs... >::type &x, typename get_value_type< Xs... >::type *point, size_t *counters, Xs &... xy)
Recursively sort variadic template of vectors.
Definition: GoogleChart.hpp:405

GCoptions::lineWidth
size_t lineWidth
Width of the line.
Definition: GoogleChart.hpp:56

GoogleChart::isNext
bool isNext(size_t *counters)
Recursively sort variadic template of vectors.
Definition: GoogleChart.hpp:309

GoogleChart::get_view_bar_option
std::string get_view_bar_option(const GCoptions &opt, size_t n_col)
Construct a view option.
Definition: GoogleChart.hpp:507

GGraph::type
size_t type
TypeOfGraph.
Definition: GoogleChart.hpp:106

GGraph::option
std::string option
option
Definition: GoogleChart.hpp:112

GCoptions::barWD
bool barWD
barWD
Definition: GoogleChart.hpp:73

GoogleChart::write
void write(std::string file)
It write the graphs on file in html format using Google charts.
Definition: GoogleChart.hpp:959

GoogleChart::get_low
T get_low(size_t *counters, X &x, X &y, Xs &... xy)
Recursively sort variadic template of vectors.
Definition: GoogleChart.hpp:324

GoogleChart::addDrawDiv
void addDrawDiv(std::ofstream &of, size_t i, bool draw_view)
Add a draw div section.
Definition: GoogleChart.hpp:623

GCoptions::width
size_t width
width of the graph in pixels
Definition: GoogleChart.hpp:46

GoogleChart::get_points_plot_data
std::string get_points_plot_data(const openfpm::vector< X > &x, const openfpm::vector< Y > &y, const openfpm::vector< std::string > &yn, const GCoptions &opt, size_t i)
Given X and Y vector return the string representing the data section of the Google Chart.
Definition: GoogleChart.hpp:438

GCoptions::stype
std::string stype
Definition: GoogleChart.hpp:38

GCoptions::intervalsext
std::string intervalsext
Definition: GoogleChart.hpp:60

GoogleChart::AddHistGraph
void AddHistGraph(openfpm::vector< Y > &y)
Add an histogram graph.
Definition: GoogleChart.hpp:676

GoogleChart::AddLinesGraph
void AddLinesGraph(openfpm::vector< X > &x, openfpm::vector< Y > &y, const openfpm::vector< std::string > &yn, const GCoptions &opt)
Add a simple plot graph.
Definition: GoogleChart.hpp:915

openfpm::vector< GGraph >

GoogleChart::recursive_sort
void recursive_sort()
terminator for recursive sort
Definition: GoogleChart.hpp:283

GCoptions::xAxis
std::string xAxis
X axis name.
Definition: GoogleChart.hpp:32

GCoptions
Google chart options.
Definition: GoogleChart.hpp:25

GoogleChart::addView
void addView(std::ofstream &of, size_t i, std::string view)
Add a view data variable.
Definition: GoogleChart.hpp:606