svm-toy.cpp

Go to the documentation of this file.

#include <QtGui>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <list>
#include "../../svm.h"
using namespace std;

#define DEFAULT_PARAM "-t 2 -c 100"
#define XLEN 500
#define YLEN 500

QRgb colors[] =
{
        qRgb(0,0,0),
        qRgb(0,120,120),
        qRgb(120,120,0),
        qRgb(120,0,120),
        qRgb(0,200,200),
        qRgb(200,200,0),
        qRgb(200,0,200)
};

class SvmToyWindow : public QWidget
{

Q_OBJECT

public:
        SvmToyWindow();
        ~SvmToyWindow();
protected:
        virtual void mousePressEvent( QMouseEvent* );
        virtual void paintEvent( QPaintEvent* );

private:
        QPixmap buffer;
        QPixmap icon1;
        QPixmap icon2;
        QPixmap icon3;
        QPushButton button_change_icon;
        QPushButton button_run;
        QPushButton button_clear;
        QPushButton button_save;
        QPushButton button_load;
        QLineEdit input_line;
        QPainter buffer_painter;
        struct point {
                double x, y;
                signed char value;
        };
        list<point> point_list;
        int current_value;
        const QPixmap& choose_icon(int v)
        {
                if(v==1) return icon1;
                else if(v==2) return icon2;
                else return icon3;
        }
        void clear_all()
        {
                point_list.clear();
                buffer.fill(Qt::black);
                repaint();
        }
        void draw_point(const point& p)
        {
                const QPixmap& icon = choose_icon(p.value);
                buffer_painter.drawPixmap((int)(p.x*XLEN),(int)(p.y*YLEN),icon);
                repaint();
        }
        void draw_all_points()
        {
                for(list<point>::iterator p = point_list.begin(); p != point_list.end();p++)
                        draw_point(*p); 
        }
private slots: 
        void button_change_icon_clicked()
        {
                ++current_value;
                if(current_value > 3) current_value = 1;
                button_change_icon.setIcon(choose_icon(current_value));
        }
        void button_run_clicked()
        {
                // guard
                if(point_list.empty()) return;

                svm_parameter param;
                int i,j;        

                // default values
                param.svm_type = C_SVC;
                param.kernel_type = RBF;
                param.degree = 3;
                param.gamma = 0;
                param.coef0 = 0;
                param.nu = 0.5;
                param.cache_size = 100;
                param.C = 1;
                param.eps = 1e-3;
                param.p = 0.1;
                param.shrinking = 1;
                param.probability = 0;
                param.nr_weight = 0;
                param.weight_label = NULL;
                param.weight = NULL;

                // parse options
                const char *p = input_line.text().toAscii().constData();

                while (1) {
                        while (*p && *p != '-')
                                p++;

                        if (*p == '\0')
                                break;

                        p++;
                        switch (*p++) {
                                case 's':
                                        param.svm_type = atoi(p);
                                        break;
                                case 't':
                                        param.kernel_type = atoi(p);
                                        break;
                                case 'd':
                                        param.degree = atoi(p);
                                        break;
                                case 'g':
                                        param.gamma = atof(p);
                                        break;
                                case 'r':
                                        param.coef0 = atof(p);
                                        break;
                                case 'n':
                                        param.nu = atof(p);
                                        break;
                                case 'm':
                                        param.cache_size = atof(p);
                                        break;
                                case 'c':
                                        param.C = atof(p);
                                        break;
                                case 'e':
                                        param.eps = atof(p);
                                        break;
                                case 'p':
                                        param.p = atof(p);
                                        break;
                                case 'h':
                                        param.shrinking = atoi(p);
                                        break;
                                case 'b':
                                        param.probability = atoi(p);
                                        break;
                                case 'w':
                                        ++param.nr_weight;
                                        param.weight_label = (int *)realloc(param.weight_label,sizeof(int)*param.nr_weight);
                                        param.weight = (double *)realloc(param.weight,sizeof(double)*param.nr_weight);
                                        param.weight_label[param.nr_weight-1] = atoi(p);
                                        while(*p && !isspace(*p)) ++p;
                                        param.weight[param.nr_weight-1] = atof(p);
                                        break;
                        }
                }
        
                // build problem
                svm_problem prob;

                prob.l = point_list.size();
                prob.y = new double[prob.l];

                if(param.kernel_type == PRECOMPUTED)
                {
                }
                else if(param.svm_type == EPSILON_SVR ||
                        param.svm_type == NU_SVR)
                {
                        if(param.gamma == 0) param.gamma = 1;
                        svm_node *x_space = new svm_node[2 * prob.l];
                        prob.x = new svm_node *[prob.l];

                        i = 0;
                        for (list <point>::iterator q = point_list.begin(); q != point_list.end(); q++, i++)
                        {
                                x_space[2 * i].index = 1;
                                x_space[2 * i].value = q->x;
                                x_space[2 * i + 1].index = -1;
                                prob.x[i] = &x_space[2 * i];
                                prob.y[i] = q->y;
                        }

                        // build model & classify
                        svm_model *model = svm_train(&prob, &param);
                        svm_node x[2];
                        x[0].index = 1;
                        x[1].index = -1;
                        int *j = new int[XLEN];

                        for (i = 0; i < XLEN; i++)
                        {
                                x[0].value = (double) i / XLEN;
                                j[i] = (int)(YLEN*svm_predict(model, x));
                        }
                        
                        buffer_painter.setPen(colors[0]);
                        buffer_painter.drawLine(0,0,0,YLEN-1);

                        int p = (int)(param.p * YLEN);
                        for(i = 1; i < XLEN; i++)
                        {
                                buffer_painter.setPen(colors[0]);
                                buffer_painter.drawLine(i,0,i,YLEN-1);
                        
                                buffer_painter.setPen(colors[5]);
                                buffer_painter.drawLine(i-1,j[i-1],i,j[i]);
                                
                                if(param.svm_type == EPSILON_SVR)
                                {
                                        buffer_painter.setPen(colors[2]);
                                        buffer_painter.drawLine(i-1,j[i-1]+p,i,j[i]+p);

                                        buffer_painter.setPen(colors[2]);
                                        buffer_painter.drawLine(i-1,j[i-1]-p,i,j[i]-p);
                                }
                        }

                        svm_free_and_destroy_model(&model);
                        delete[] j;
                        delete[] x_space;
                        delete[] prob.x;
                        delete[] prob.y;
                }
                else
                {
                        if(param.gamma == 0) param.gamma = 0.5;
                        svm_node *x_space = new svm_node[3 * prob.l];
                        prob.x = new svm_node *[prob.l];

                        i = 0;
                        for (list <point>::iterator q = point_list.begin(); q != point_list.end(); q++, i++)
                        {
                                x_space[3 * i].index = 1;
                                x_space[3 * i].value = q->x;
                                x_space[3 * i + 1].index = 2;
                                x_space[3 * i + 1].value = q->y;
                                x_space[3 * i + 2].index = -1;
                                prob.x[i] = &x_space[3 * i];
                                prob.y[i] = q->value;
                        }

                        // build model & classify
                        svm_model *model = svm_train(&prob, &param);
                        svm_node x[3];
                        x[0].index = 1;
                        x[1].index = 2;
                        x[2].index = -1;

                        for (i = 0; i < XLEN; i++)
                                for (j = 0; j < YLEN ; j++) {
                                        x[0].value = (double) i / XLEN;
                                        x[1].value = (double) j / YLEN;
                                        double d = svm_predict(model, x);
                                        if (param.svm_type == ONE_CLASS && d<0) d=2;
                                        buffer_painter.setPen(colors[(int)d]);
                                        buffer_painter.drawPoint(i,j);
                        }

                        svm_free_and_destroy_model(&model);
                        delete[] x_space;
                        delete[] prob.x;
                        delete[] prob.y;
                }
                free(param.weight_label);
                free(param.weight);
                draw_all_points();
        }
        void button_clear_clicked()
        {
                clear_all();
        }
        void button_save_clicked()
        {
                QString filename = QFileDialog::getSaveFileName();
                if(!filename.isNull())
                {
                        FILE *fp = fopen(filename.toAscii().constData(),"w");
                        
                        const char *p = input_line.text().toAscii().constData();
                        const char* svm_type_str = strstr(p, "-s ");
                        int svm_type = C_SVC;
                        if(svm_type_str != NULL)
                                sscanf(svm_type_str, "-s %d", &svm_type);
                
                        if(fp)
                        {
                                if(svm_type == EPSILON_SVR || svm_type == NU_SVR)
                                {
                                        for(list<point>::iterator p = point_list.begin(); p != point_list.end();p++)
                                                fprintf(fp,"%f 1:%f\n", p->y, p->x);
                                }
                                else
                                {
                                        for(list<point>::iterator p = point_list.begin(); p != point_list.end();p++)
                                                fprintf(fp,"%d 1:%f 2:%f\n", p->value, p->x, p->y);
                                }
                                fclose(fp);
                        }
                }
        }
        void button_load_clicked()
        {
                QString filename = QFileDialog::getOpenFileName();
                if(!filename.isNull())
                {
                        FILE *fp = fopen(filename.toAscii().constData(),"r");
                        if(fp)
                        {
                                clear_all();
                                char buf[4096];
                                while(fgets(buf,sizeof(buf),fp))
                                {
                                        int v;
                                        double x,y;
                                        if(sscanf(buf,"%d%*d:%lf%*d:%lf",&v,&x,&y)==3)
                                        {
                                                point p = {x,y,v};
                                                point_list.push_back(p);
                                        }
                                        else if(sscanf(buf,"%lf%*d:%lf",&y,&x)==2)
                                        {
                                                point p = {x,y,current_value};
                                                point_list.push_back(p);
                                        }
                                        else
                                                break;
                                }
                                fclose(fp);
                                draw_all_points();
                        }                               
                }
                
        }
};

#include "svm-toy.moc"

SvmToyWindow::SvmToyWindow()
:button_change_icon(this)
,button_run("Run",this)
,button_clear("Clear",this)
,button_save("Save",this)
,button_load("Load",this)
,input_line(this)
,current_value(1)
{
        buffer = QPixmap(XLEN,YLEN);
        buffer.fill(Qt::black);

        buffer_painter.begin(&buffer);

        QObject::connect(&button_change_icon, SIGNAL(clicked()), this,
                         SLOT(button_change_icon_clicked()));
        QObject::connect(&button_run, SIGNAL(clicked()), this,
                         SLOT(button_run_clicked()));
        QObject::connect(&button_clear, SIGNAL(clicked()), this,
                         SLOT(button_clear_clicked()));
        QObject::connect(&button_save, SIGNAL(clicked()), this,
                         SLOT(button_save_clicked()));
        QObject::connect(&button_load, SIGNAL(clicked()), this,
                         SLOT(button_load_clicked()));
        QObject::connect(&input_line, SIGNAL(returnPressed()), this,
                         SLOT(button_run_clicked()));

        // don't blank the window before repainting
        setAttribute(Qt::WA_NoBackground);
  
        icon1 = QPixmap(4,4);
        icon2 = QPixmap(4,4);
        icon3 = QPixmap(4,4);
        
        
        QPainter painter;
        painter.begin(&icon1);
        painter.fillRect(0,0,4,4,QBrush(colors[4]));
        painter.end();

        painter.begin(&icon2);
        painter.fillRect(0,0,4,4,QBrush(colors[5]));
        painter.end();

        painter.begin(&icon3);
        painter.fillRect(0,0,4,4,QBrush(colors[6]));
        painter.end();

        button_change_icon.setGeometry( 0, YLEN, 50, 25 );
        button_run.setGeometry( 50, YLEN, 50, 25 );
        button_clear.setGeometry( 100, YLEN, 50, 25 );
        button_save.setGeometry( 150, YLEN, 50, 25);
        button_load.setGeometry( 200, YLEN, 50, 25);
        input_line.setGeometry( 250, YLEN, 250, 25);
        
        input_line.setText(DEFAULT_PARAM);
        button_change_icon.setIcon(icon1);
}

SvmToyWindow::~SvmToyWindow()
{
        buffer_painter.end();
}

void SvmToyWindow::mousePressEvent( QMouseEvent* event )
{
        point p = {(double)event->x()/XLEN, (double)event->y()/YLEN, current_value};
        point_list.push_back(p);
        draw_point(p);
}

void SvmToyWindow::paintEvent( QPaintEvent* )
{
        // copy the image from the buffer pixmap to the window
        QPainter p(this);
        p.drawPixmap(0, 0, buffer);
}

int main( int argc, char* argv[] )
{
        QApplication myapp( argc, argv );

        SvmToyWindow* mywidget = new SvmToyWindow();
        mywidget->setGeometry( 100, 100, XLEN, YLEN+25 );

        mywidget->show();
        return myapp.exec();
}