callbacks.cpp

Go to the documentation of this file.

#include <gtk/gtk.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <list>
#include "callbacks.h"
#include "interface.h"
#include "../../svm.h"
using namespace std;
 
#define DEFAULT_PARAM "-t 2 -c 100"
#define XLEN 500
#define YLEN 500
 
GdkColor colors[] = 
{
        {0,0,0,0},
        {0,0,120<<8,120<<8},
        {0,120<<8,120<<8,0},
        {0,120<<8,0,120<<8},
        {0,0,200<<8,200<<8},
        {0,200<<8,200<<8,0},
        {0,200<<8,0,200<<8},
};
 
GdkGC *gc;
GdkPixmap *pixmap;
extern "C" GtkWidget *draw_main;
GtkWidget *draw_main;
extern "C" GtkWidget *entry_option;
GtkWidget *entry_option;
 
typedef struct {
        double x, y;
        signed char value;
} point;
 
list<point> point_list;
int current_value = 1;
 
extern "C" void svm_toy_initialize()
{
        gboolean success[7];
 
        gdk_colormap_alloc_colors(
                gdk_colormap_get_system(),
                colors,
                7,
                FALSE,
                TRUE,
                success);
 
        gc = gdk_gc_new(draw_main->window);
        pixmap = gdk_pixmap_new(draw_main->window,XLEN,YLEN,-1);
        gdk_gc_set_foreground(gc,&colors[0]);
        gdk_draw_rectangle(pixmap,gc,TRUE,0,0,XLEN,YLEN);
        gtk_entry_set_text(GTK_ENTRY(entry_option),DEFAULT_PARAM);
}
 
void redraw_area(GtkWidget* widget, int x, int y, int w, int h)
{
        gdk_draw_pixmap(widget->window,
                        gc,
                        pixmap,
                        x,y,x,y,w,h);
}
 
void draw_point(const point& p)
{
        gdk_gc_set_foreground(gc,&colors[p.value+3]);
        gdk_draw_rectangle(pixmap, gc, TRUE,int(p.x*XLEN),int(p.y*YLEN),4,4);
        gdk_draw_rectangle(draw_main->window, gc, TRUE,int(p.x*XLEN),int(p.y*YLEN),4,4);
}
 
void draw_all_points()
{
        for(list<point>::iterator p = point_list.begin(); p != point_list.end();p++)
                draw_point(*p);
}
 
void clear_all()
{
        point_list.clear();
        gdk_gc_set_foreground(gc,&colors[0]);
        gdk_draw_rectangle(pixmap,gc,TRUE,0,0,XLEN,YLEN);
        redraw_area(draw_main,0,0,XLEN,YLEN);
}
 
void
on_button_change_clicked               (GtkButton       *button,
                                        gpointer         user_data)
{
        ++current_value;
        if(current_value > 3) current_value = 1;
}
 
void
on_button_run_clicked                  (GtkButton       *button,
                                        gpointer         user_data)
{
        // 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 = gtk_entry_get_text(GTK_ENTRY(entry_option));
 
        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));
                }
 
                gdk_gc_set_foreground(gc,&colors[0]);
                gdk_draw_line(pixmap,gc,0,0,0,YLEN-1);
                gdk_draw_line(draw_main->window,gc,0,0,0,YLEN-1);
                
                int p = (int)(param.p * YLEN);
                for(i = 1; i < XLEN; i++)
                {
                        gdk_gc_set_foreground(gc,&colors[0]);
                        gdk_draw_line(pixmap,gc,i,0,i,YLEN-1);
                        gdk_draw_line(draw_main->window,gc,i,0,i,YLEN-1);
                        
                        gdk_gc_set_foreground(gc,&colors[5]);
                        gdk_draw_line(pixmap,gc,i-1,j[i-1],i,j[i]);
                        gdk_draw_line(draw_main->window,gc,i-1,j[i-1],i,j[i]);
                        
                        if(param.svm_type == EPSILON_SVR)
                        {
                                gdk_gc_set_foreground(gc,&colors[2]);
                                gdk_draw_line(pixmap,gc,i-1,j[i-1]+p,i,j[i]+p);
                                gdk_draw_line(draw_main->window,gc,i-1,j[i-1]+p,i,j[i]+p);
                        
                                gdk_gc_set_foreground(gc,&colors[2]);
                                gdk_draw_line(pixmap,gc,i-1,j[i-1]-p,i,j[i]-p);
                                gdk_draw_line(draw_main->window,gc,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;
                                gdk_gc_set_foreground(gc,&colors[(int)d]);
                                gdk_draw_point(pixmap,gc,i,j);
                                gdk_draw_point(draw_main->window,gc,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
on_button_clear_clicked                (GtkButton       *button,
                                        gpointer         user_data)
{
        clear_all();
}
 
void
on_window1_destroy                     (GtkObject       *object,
                                        gpointer         user_data)
{
        gtk_exit(0);
}
 
gboolean
on_draw_main_button_press_event        (GtkWidget       *widget,
                                        GdkEventButton  *event,
                                        gpointer         user_data)
{
        point p = {(double)event->x/XLEN, (double)event->y/YLEN, current_value};
        point_list.push_back(p);
        draw_point(p);
        return FALSE;
}
 
gboolean
on_draw_main_expose_event              (GtkWidget       *widget,
                                        GdkEventExpose  *event,
                                        gpointer         user_data)
{
        redraw_area(widget,
                    event->area.x, event->area.y,
                    event->area.width, event->area.height);
        return FALSE;
}
 
GtkWidget *fileselection;
static enum { SAVE, LOAD } fileselection_flag;
 
void show_fileselection()
{
        fileselection = create_fileselection();
        gtk_signal_connect_object(
                GTK_OBJECT(GTK_FILE_SELECTION(fileselection)->ok_button),
                "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
                (GtkObject *) fileselection);
        
        gtk_signal_connect_object (GTK_OBJECT
                (GTK_FILE_SELECTION(fileselection)->cancel_button),
                "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
                (GtkObject *) fileselection);
 
        gtk_widget_show(fileselection);
}
 
void
on_button_save_clicked                 (GtkButton       *button,
                                        gpointer         user_data)
{
        fileselection_flag = SAVE;
        show_fileselection();
}
 
 
void
on_button_load_clicked                 (GtkButton       *button,
                                        gpointer         user_data)
{
        fileselection_flag = LOAD;
        show_fileselection();
}
 
void
on_filesel_ok_clicked                  (GtkButton       *button,
                                        gpointer         user_data)
{
        gtk_widget_hide(fileselection);
        const char *filename = gtk_file_selection_get_filename(GTK_FILE_SELECTION(fileselection));
 
        if(fileselection_flag == SAVE)
        {
                FILE *fp = fopen(filename,"w");
                
                const char *p = gtk_entry_get_text(GTK_ENTRY(entry_option));
                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);
                }
 
        }
        else if(fileselection_flag == LOAD)
        {
                FILE *fp = fopen(filename,"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();
                }                               
        }
}
 
void
on_fileselection_destroy               (GtkObject       *object,
                                        gpointer         user_data)
{
}
 
void
on_filesel_cancel_clicked              (GtkButton       *button,
                                        gpointer         user_data)
{
}