Revision 0:ded8a44ff71f, committed 2010-08-17

Comitter:

shintamainjp

Date:

Tue Aug 17 09:21:55 2010 +0000

Commit message:

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Axis.cpp	Tue Aug 17 09:21:55 2010 +0000
@@ -0,0 +1,40 @@
+/**
+ * GoogleChart API interface driver. (Version 0.0.1)
+ *
+ * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
+ * http://shinta.main.jp/
+ */
+
+#include "Axis.h"
+
+Axis::Axis(int number, Type type) : number(number), type(type), rangeStart(0), rangeEnd(100) {}
+
+Axis::~Axis() {}
+
+int Axis::getNumber() const {
+    return number;
+}
+
+void Axis::setType(Axis::Type type) {
+    Axis::type = type;
+}
+
+Axis::Type Axis::getType() const {
+    return type;
+}
+
+void Axis::setRangeStart(int rangeStart) {
+    Axis::rangeStart = rangeStart;
+}
+
+int Axis::getRangeStart() const {
+    return rangeStart;
+}
+
+void Axis::setRangeEnd(int rangeEnd) {
+    Axis::rangeEnd = rangeEnd;
+}
+
+int Axis::getRangeEnd() const {
+    return rangeEnd;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Axis.h	Tue Aug 17 09:21:55 2010 +0000
@@ -0,0 +1,39 @@
+/**
+ * GoogleChart API interface driver. (Version 0.0.1)
+ *
+ * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
+ * http://shinta.main.jp/
+ */
+
+#ifndef _AXIS_H_
+#define _AXIS_H_
+
+class Axis {
+public:
+    typedef enum {
+        Bottom,
+        Left,
+        Right,
+        Top
+    } Type;
+    
+    Axis(int number, Type type = Bottom);
+    ~Axis();
+    
+    int getNumber() const;
+    void setType(Type type);
+    Type getType() const;
+    void setRangeStart(int rangeStart);
+    int getRangeStart() const;
+    void setRangeEnd(int rangeEnd);
+    int getRangeEnd() const;
+    
+private:
+
+    const int number;
+    Type type;
+    int rangeStart;
+    int rangeEnd;
+};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DataSet.cpp	Tue Aug 17 09:21:55 2010 +0000
@@ -0,0 +1,54 @@
+/**
+ * GoogleChart API interface driver. (Version 0.0.1)
+ *
+ * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
+ * http://shinta.main.jp/
+ */
+
+#include "DataSet.h"
+
+DataSet::DataSet(std::string label, int number, int size, DataSet::EncodeType encodeType)
+        :
+        label(label), number(number), size(size), encodeType(encodeType), dataCount(0), min(0), max(100) {
+    datalist = new double[size];
+}
+
+DataSet::~DataSet() {
+    delete [] datalist;
+}
+
+std::string DataSet::getLabel() {
+    return label;
+}
+
+int DataSet::getNumber() {
+    return number;
+}
+
+int DataSet::getSize() {
+    return size;
+}
+
+void DataSet::setEncodeType(DataSet::EncodeType encodeType) {
+    DataSet::encodeType = encodeType;
+}
+
+DataSet::EncodeType DataSet::getEncodeType() {
+    return encodeType;
+}
+
+void DataSet::clearAllData() {
+    dataCount = 0;
+}
+
+void DataSet::addData(double data) {
+    datalist[dataCount++] = data;
+}
+
+int DataSet::getDataCount() {
+    return dataCount;
+}
+
+double DataSet::getData(int index) {
+    return datalist[index];
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DataSet.h	Tue Aug 17 09:21:55 2010 +0000
@@ -0,0 +1,54 @@
+/**
+ * GoogleChart API interface driver. (Version 0.0.1)
+ *
+ * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
+ * http://shinta.main.jp/
+ */
+
+#ifndef _DATA_SET_H_
+#define _DATA_SET_H_
+
+#include <string>
+
+class DataSet {
+public:
+    typedef enum {
+        Simple,
+        Extended,
+        Text
+    } EncodeType;
+    
+    DataSet(std::string label, int number, int size, EncodeType encodeType = Text);
+    ~DataSet();
+    
+    std::string getLabel();
+    int getNumber();
+    int getSize();
+    void setEncodeType(EncodeType encodeType);
+    EncodeType getEncodeType();
+    
+    void clearAllData();
+    void addData(double data);
+    int getDataCount();
+    double getData(int index);
+    
+    void setScale(double min, double max) {
+        DataSet::min = min;
+        DataSet::max = max;
+    }
+    double getMin() { return min; }
+    double getMax() { return max; }
+    
+private:
+
+    const std::string label;
+    const int number;
+    const int size;
+    EncodeType encodeType;
+    double *datalist;
+    int dataCount;
+    double min;
+    double max;
+};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GoogleChart.cpp	Tue Aug 17 09:21:55 2010 +0000
@@ -0,0 +1,339 @@
+/**
+ * GoogleChart API interface driver. (Version 0.0.1)
+ *
+ * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
+ * http://shinta.main.jp/
+ */
+
+#include "GoogleChart.h"
+
+const std::string GoogleChart::baseURL = "http://chart.apis.google.com/chart";
+
+GoogleChart::GoogleChart() : title(""), width(300), height(225) {
+    for (int i = 0; i < MAX_AXIS; i++) {
+        axislist[i] = 0;
+    }
+    for (int i = 0; i < MAX_DATA; i++) {
+        datalist[i] = 0;
+    }
+}
+
+GoogleChart::~GoogleChart() {}
+
+int GoogleChart::addNewAxis(Axis::Type type) {
+    /*
+     * Search maximum number of axis.
+     */
+    int max = 0;
+    for (int i = 0; i < MAX_AXIS; i++) {
+        if (0 != axislist[i]) {
+            if (axislist[i]->getNumber() > max) {
+                max = axislist[i]->getNumber();
+            }
+        }
+    }
+
+    /*
+     * Create a new axis.
+     */
+    for (int i = 0; i < MAX_AXIS; i++) {
+        if (0 == axislist[i]) {
+            axislist[i] = new Axis(max + 1, type);
+            return max + 1;
+        }
+    }
+    return -1;
+}
+
+int GoogleChart::setAxisType(const int number, Axis::Type type) {
+    for (int i = 0; i < MAX_AXIS; i++) {
+        if (0 != axislist[i]) {
+            if (axislist[i]->getNumber() == number) {
+                axislist[i]->setType(type);
+                return number;
+            }
+        }
+    }
+    return -1;
+}
+
+int GoogleChart::setAxisRange(const int number, int rangeStart, int rangeEnd) {
+    for (int i = 0; i < MAX_AXIS; i++) {
+        if (0 != axislist[i]) {
+            if (axislist[i]->getNumber() == number) {
+                axislist[i]->setRangeStart(rangeStart);
+                axislist[i]->setRangeEnd(rangeEnd);
+                return number;
+            }
+        }
+    }
+    return -1;
+}
+
+int GoogleChart::removeAxis(const int number) {
+    for (int i = 0; i < MAX_AXIS; i++) {
+        if (0 != axislist[i]) {
+            if (axislist[i]->getNumber() == number) {
+                delete axislist[i];
+                axislist[i] = 0;
+                return number;
+            }
+        }
+    }
+    return -1;
+}
+
+int GoogleChart::addNewDataSet(std::string label, const int size) {
+    /*
+     * Search maximum number of data set.
+     */
+    int max = 0;
+    for (int i = 0; i < MAX_DATA; i++) {
+        if (0 != datalist[i]) {
+            if (datalist[i]->getNumber() > max) {
+                max = datalist[i]->getNumber();
+            }
+        }
+    }
+
+    /*
+     * Create a new data set.
+     */
+    for (int i = 0; i < MAX_DATA; i++) {
+        if (0 == datalist[i]) {
+            datalist[i] = new DataSet(label, max + 1, size);
+            return max + 1;
+        }
+    }
+    return -1;
+}
+
+int GoogleChart::removeDataSet(const int number) {
+    for (int i = 0; i < MAX_DATA; i++) {
+        if (0 != datalist[i]) {
+            if (datalist[i]->getNumber() == number) {
+                delete datalist[i];
+                datalist[i] = 0;
+                return number;
+            }
+        }
+    }
+    return -1;
+}
+
+int GoogleChart::addData(const int number, double data) {
+    for (int i = 0; i < MAX_DATA; i++) {
+        if (0 != datalist[i]) {
+            if (datalist[i]->getNumber() == number) {
+                datalist[i]->addData(data);
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+
+int GoogleChart::clearAllData(const int number) {
+    for (int i = 0; i < MAX_DATA; i++) {
+        if (0 != datalist[i]) {
+            if (datalist[i]->getNumber() == number) {
+                datalist[i]->clearAllData();
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+
+    int GoogleChart::setDataScale(const int number, int min, int max) {
+    for (int i = 0; i < MAX_DATA; i++) {
+        if (0 != datalist[i]) {
+            if (datalist[i]->getNumber() == number) {
+                datalist[i]->setScale(min, max);
+                return i;
+            }
+        }
+    }
+    return -1;
+    }
+
+void GoogleChart::setTitle(std::string title) {
+    GoogleChart::title = title;
+}
+
+std::string GoogleChart::getTitle() const {
+    return title;
+}
+
+void GoogleChart::setWidth(int width) {
+    GoogleChart::width = width;
+}
+
+int GoogleChart::getWidth() const {
+    return width;
+}
+
+void GoogleChart::setHeight(int height) {
+    GoogleChart::height = height;
+}
+
+int GoogleChart::getHeight() const {
+    return height;
+}
+
+std::string GoogleChart::toURL(std::string text) {
+    static const char *unsafe_characters = " \"<>#%{}|\\^~[]`";
+    std::string s = "";
+    for (int i = 0; i < text.length(); i++) {
+        char c = text.at(i);
+        if (strchr(unsafe_characters, c) == NULL) {
+            s = s + c;
+        } else {
+            char buf[8];
+            snprintf(buf, sizeof(buf), "%%%02X", c & 0xff);
+            s = s + std::string(buf);
+        }
+    }
+    return s;
+}
+
+std::string GoogleChart::paramChartType(ChartType chartType) {
+    /*
+     * Chart Type.
+     */
+    std::string s = "cht=";
+    switch (chartType) {
+        case LineChart:
+            s = s + "lc";
+            break;
+        default:
+            s = s + "unknown";
+            break;
+    }
+    return s;
+}
+
+std::string GoogleChart::paramAxis(Axis **list, int size) {
+
+    char buf[64];
+    /*
+     * Axis type and range.
+     */
+    int cnt = 0;
+    std::string sType = "chxt=";
+    std::string sRange = "chxr=";
+    for (int i = 0; i < size; i++) {
+        Axis *p = list[i];
+        if (0 != p) {
+            /*
+             * Type.
+             */
+            if (0 < cnt) {
+                sType = sType + ",";
+            }
+            switch (p->getType()) {
+                case Axis::Bottom:
+                    sType = sType + "x";
+                    break;
+                case Axis::Left:
+                    sType = sType + "y";
+                    break;
+                case Axis::Right:
+                    sType = sType + "r";
+                    break;
+                case Axis::Top:
+                    sType = sType + "t";
+                    break;
+                default:
+                    sType = sType + "?";
+                    break;
+            }
+            /*
+             * Range.
+             */
+            if (0 < cnt) {
+                sRange = sRange + "|";
+            }
+            snprintf(buf, sizeof(buf), "%d,%d,%d", cnt, p->getRangeStart(), p->getRangeEnd());
+            sRange = sRange + std::string(buf);
+            /*
+             * Next.
+             */
+            cnt++;
+        }
+    }
+
+    return sRange + "&" + sType;
+}
+
+std::string GoogleChart::paramDataSet(DataSet **list, int size) {
+    char buf[64];
+    int cnt = 0;
+    std::string sData = "chd=t:";
+    std::string sScale = "chds=";
+    std::string sLabel = "chdl=";
+    for (int i = 0; i < size; i++) {
+        DataSet *p = list[i];
+        if (0 != p) {
+            /*
+             * Data.
+             */
+            if (0 < cnt) {
+                sData = sData + "|";
+            }
+            for (int i = 0; i < p->getDataCount(); i++) {
+                double d = p->getData(i);
+                snprintf(buf, sizeof(buf), "%.3f", d);
+                if (0 < i) {
+                    sData = sData + ",";
+                }
+                sData = sData + std::string(buf);
+            }
+            /*
+             * Range.
+             */
+            if (0 < cnt) {
+                sScale = sScale + ",";
+            }
+            snprintf(buf, sizeof(buf), "%.3f,%.3f", p->getMin(), p->getMax());
+            sScale = sScale + std::string(buf);
+            /*
+             * Label.
+             */
+            if (0 < cnt) {
+                sLabel = sLabel + "|";
+            }
+            sLabel = sLabel + p->getLabel();
+            /*
+             * Next.
+             */
+            cnt++;
+        }
+    }
+
+    return sScale + "&" + sData + "&" + sLabel;
+}
+
+std::string GoogleChart::paramTitle(std::string title, int color, double fontSize) {
+    char buf[64];
+    std::string s = "";
+    /*
+     * Chart Title Text.
+     */
+    s = s + "chtt=" + title;
+    /*
+     * Chart Title Specification.
+     */
+    snprintf(buf, sizeof(buf), "&chts=%06X,%.1f", color, fontSize);
+    s = s + std::string(buf);
+    return s;
+}
+
+std::string GoogleChart::paramSize(int width, int height) {
+    char buf[64];
+    /*
+     * Chart Size.
+     */
+    snprintf(buf, sizeof(buf), "chs=%dx%d", width, height);
+    return std::string(buf);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GoogleChart.h	Tue Aug 17 09:21:55 2010 +0000
@@ -0,0 +1,71 @@
+/**
+ * GoogleChart API interface driver. (Version 0.0.1)
+ *
+ * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
+ * http://shinta.main.jp/
+ */
+
+#ifndef _GOOGLE_CHART_H_
+#define _GOOGLE_CHART_H_
+
+#include <string.h>
+#include <string>
+#include <ctype.h>
+
+#include <mbed.h>
+
+#include "Axis.h"
+#include "DataSet.h"
+
+class GoogleChart {
+public:
+
+    GoogleChart();
+    virtual ~GoogleChart();
+
+    virtual std::string toString() = 0;
+
+    int addNewAxis(Axis::Type type = Axis::Bottom);
+    int setAxisType(const int number, Axis::Type type);
+    int setAxisRange(const int number, int rangeStart, int rangeEnd);
+    int removeAxis(const int number);
+    
+    int addNewDataSet(std::string label, const int size);
+    int removeDataSet(const int number);
+    int addData(const int number, double data);
+    int clearAllData(const int number);
+    int setDataScale(const int number, int min, int max);
+
+    void setTitle(std::string title);
+    std::string getTitle() const;
+    void setWidth(int width);
+    int getWidth() const;
+    void setHeight(int height);
+    int getHeight() const;
+
+protected:
+    static const std::string baseURL;
+    std::string title;
+    int width;
+    int height;
+    
+    static const int MAX_AXIS = 16;
+    Axis *axislist[MAX_AXIS];
+    
+    static const int MAX_DATA = 16;
+    DataSet *datalist[MAX_DATA];
+
+    typedef enum {
+        LineChart
+    } ChartType;
+
+    static std::string toURL(std::string text);
+
+    static std::string paramChartType(ChartType chartType);
+    static std::string paramAxis(Axis **list, int size);
+    static std::string paramDataSet(DataSet **list, int size);
+    static std::string paramTitle(std::string title, int color, double fontSize);
+    static std::string paramSize(int width, int height);
+};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GoogleChartLineChart.cpp	Tue Aug 17 09:21:55 2010 +0000
@@ -0,0 +1,34 @@
+/**
+ * GoogleChart API interface driver. (Version 0.0.1)
+ *
+ * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
+ * http://shinta.main.jp/
+ */
+
+#include "GoogleChartLineChart.h"
+
+GoogleChartLineChart::GoogleChartLineChart() : GoogleChart() {}
+GoogleChartLineChart::~GoogleChartLineChart() {}
+
+std::string GoogleChartLineChart::toString() {
+
+    std::string s = "";
+    s = s + baseURL;
+    s = s + "?";
+    s = s + toURL(paramAxis(axislist, MAX_AXIS));
+    s = s + "&";
+    s = s + toURL(paramSize(400, 320));
+    s = s + "&";
+    s = s + toURL(paramChartType(GoogleChart::LineChart));
+    s = s + "&";
+    s = s + toURL("chco=3D7930,FF9900");
+    s = s + "&";
+    s = s + toURL(paramDataSet(datalist, MAX_DATA));
+    s = s + "&";
+    s = s + toURL(paramTitle(title, 0x0000FF, 12.0));
+    s = s + "&";
+    s = s + toURL("chg=5,5,1,1");
+    s = s + "&";
+    s = s + toURL("chm=B,3D793022,0,0,0,1|B,FF990022,1,0,0,1");
+    return s;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GoogleChartLineChart.h	Tue Aug 17 09:21:55 2010 +0000
@@ -0,0 +1,24 @@
+/**
+ * GoogleChart API interface driver. (Version 0.0.1)
+ *
+ * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
+ * http://shinta.main.jp/
+ */
+
+#ifndef _GOOGLE_CHART_LINE_CHART_H_
+#define _GOOGLE_CHART_LINE_CHART_H_
+
+#include <stdio.h>
+#include <string.h>
+
+#include "GoogleChart.h"
+
+class GoogleChartLineChart : public GoogleChart {
+public:
+    GoogleChartLineChart();
+    virtual ~GoogleChartLineChart();
+
+    virtual std::string toString();
+};
+
+#endif