483 lines
11 KiB
C++
483 lines
11 KiB
C++
#include <windows.h>
|
|
#include <windowsx.h>
|
|
#include <stdio.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
|
|
#define DrawLine(dc,x1,y1,x2,y2,c) \
|
|
do { \
|
|
HPEN hpen = CreatePen(PS_SOLID,0,c); \
|
|
HPEN horig = SelectPen(dc,hpen); \
|
|
MoveToEx(dc,x1,y1,NULL); \
|
|
LineTo(dc,x2,y2); \
|
|
SelectPen(dc,horig); \
|
|
DeletePen(hpen); \
|
|
} while(0)
|
|
|
|
using namespace std;
|
|
|
|
COLORREF colors[] =
|
|
{
|
|
RGB(0,0,0),
|
|
RGB(0,120,120),
|
|
RGB(120,120,0),
|
|
RGB(120,0,120),
|
|
RGB(0,200,200),
|
|
RGB(200,200,0),
|
|
RGB(200,0,200)
|
|
};
|
|
|
|
HWND main_window;
|
|
HBITMAP buffer;
|
|
HDC window_dc;
|
|
HDC buffer_dc;
|
|
HBRUSH brush1, brush2, brush3;
|
|
HWND edit;
|
|
|
|
enum {
|
|
ID_BUTTON_CHANGE, ID_BUTTON_RUN, ID_BUTTON_CLEAR,
|
|
ID_BUTTON_LOAD, ID_BUTTON_SAVE, ID_EDIT
|
|
};
|
|
|
|
struct point {
|
|
double x, y;
|
|
signed char value;
|
|
};
|
|
|
|
list<point> point_list;
|
|
int current_value = 1;
|
|
|
|
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
|
|
PSTR szCmdLine, int iCmdShow)
|
|
{
|
|
static char szAppName[] = "SvmToy";
|
|
MSG msg;
|
|
WNDCLASSEX wndclass;
|
|
|
|
wndclass.cbSize = sizeof(wndclass);
|
|
wndclass.style = CS_HREDRAW | CS_VREDRAW;
|
|
wndclass.lpfnWndProc = WndProc;
|
|
wndclass.cbClsExtra = 0;
|
|
wndclass.cbWndExtra = 0;
|
|
wndclass.hInstance = hInstance;
|
|
wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
|
|
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wndclass.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);
|
|
wndclass.lpszMenuName = NULL;
|
|
wndclass.lpszClassName = szAppName;
|
|
wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
|
|
|
|
RegisterClassEx(&wndclass);
|
|
|
|
main_window = CreateWindow(szAppName, // window class name
|
|
"SVM Toy", // window caption
|
|
WS_OVERLAPPEDWINDOW,// window style
|
|
CW_USEDEFAULT, // initial x position
|
|
CW_USEDEFAULT, // initial y position
|
|
XLEN, // initial x size
|
|
YLEN+52, // initial y size
|
|
NULL, // parent window handle
|
|
NULL, // window menu handle
|
|
hInstance, // program instance handle
|
|
NULL); // creation parameters
|
|
|
|
ShowWindow(main_window, iCmdShow);
|
|
UpdateWindow(main_window);
|
|
|
|
CreateWindow("button", "Change", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
|
|
0, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_CHANGE, hInstance, NULL);
|
|
CreateWindow("button", "Run", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
|
|
50, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_RUN, hInstance, NULL);
|
|
CreateWindow("button", "Clear", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
|
|
100, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_CLEAR, hInstance, NULL);
|
|
CreateWindow("button", "Save", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
|
|
150, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_SAVE, hInstance, NULL);
|
|
CreateWindow("button", "Load", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
|
|
200, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_LOAD, hInstance, NULL);
|
|
|
|
edit = CreateWindow("edit", NULL, WS_CHILD | WS_VISIBLE,
|
|
250, YLEN, 250, 25, main_window, (HMENU) ID_EDIT, hInstance, NULL);
|
|
|
|
Edit_SetText(edit,DEFAULT_PARAM);
|
|
|
|
brush1 = CreateSolidBrush(colors[4]);
|
|
brush2 = CreateSolidBrush(colors[5]);
|
|
brush3 = CreateSolidBrush(colors[6]);
|
|
|
|
window_dc = GetDC(main_window);
|
|
buffer = CreateCompatibleBitmap(window_dc, XLEN, YLEN);
|
|
buffer_dc = CreateCompatibleDC(window_dc);
|
|
SelectObject(buffer_dc, buffer);
|
|
PatBlt(buffer_dc, 0, 0, XLEN, YLEN, BLACKNESS);
|
|
|
|
while (GetMessage(&msg, NULL, 0, 0)) {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
return msg.wParam;
|
|
}
|
|
|
|
int getfilename( HWND hWnd , char *filename, int len, int save)
|
|
{
|
|
OPENFILENAME OpenFileName;
|
|
memset(&OpenFileName,0,sizeof(OpenFileName));
|
|
filename[0]='\0';
|
|
|
|
OpenFileName.lStructSize = sizeof(OPENFILENAME);
|
|
OpenFileName.hwndOwner = hWnd;
|
|
OpenFileName.lpstrFile = filename;
|
|
OpenFileName.nMaxFile = len;
|
|
OpenFileName.Flags = 0;
|
|
|
|
return save?GetSaveFileName(&OpenFileName):GetOpenFileName(&OpenFileName);
|
|
}
|
|
|
|
void clear_all()
|
|
{
|
|
point_list.clear();
|
|
PatBlt(buffer_dc, 0, 0, XLEN, YLEN, BLACKNESS);
|
|
InvalidateRect(main_window, 0, 0);
|
|
}
|
|
|
|
HBRUSH choose_brush(int v)
|
|
{
|
|
if(v==1) return brush1;
|
|
else if(v==2) return brush2;
|
|
else return brush3;
|
|
}
|
|
|
|
void draw_point(const point & p)
|
|
{
|
|
RECT rect;
|
|
rect.left = int(p.x*XLEN);
|
|
rect.top = int(p.y*YLEN);
|
|
rect.right = int(p.x*XLEN) + 3;
|
|
rect.bottom = int(p.y*YLEN) + 3;
|
|
FillRect(window_dc, &rect, choose_brush(p.value));
|
|
FillRect(buffer_dc, &rect, choose_brush(p.value));
|
|
}
|
|
|
|
void draw_all_points()
|
|
{
|
|
for(list<point>::iterator p = point_list.begin(); p != point_list.end(); p++)
|
|
draw_point(*p);
|
|
}
|
|
|
|
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
|
|
char str[1024];
|
|
Edit_GetLine(edit, 0, str, sizeof(str));
|
|
const char *p = str;
|
|
|
|
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, ¶m);
|
|
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));
|
|
}
|
|
|
|
DrawLine(buffer_dc,0,0,0,YLEN,colors[0]);
|
|
DrawLine(window_dc,0,0,0,YLEN,colors[0]);
|
|
|
|
int p = (int)(param.p * YLEN);
|
|
for(int i=1; i < XLEN; i++)
|
|
{
|
|
DrawLine(buffer_dc,i,0,i,YLEN,colors[0]);
|
|
DrawLine(window_dc,i,0,i,YLEN,colors[0]);
|
|
|
|
DrawLine(buffer_dc,i-1,j[i-1],i,j[i],colors[5]);
|
|
DrawLine(window_dc,i-1,j[i-1],i,j[i],colors[5]);
|
|
|
|
if(param.svm_type == EPSILON_SVR)
|
|
{
|
|
DrawLine(buffer_dc,i-1,j[i-1]+p,i,j[i]+p,colors[2]);
|
|
DrawLine(window_dc,i-1,j[i-1]+p,i,j[i]+p,colors[2]);
|
|
|
|
DrawLine(buffer_dc,i-1,j[i-1]-p,i,j[i]-p,colors[2]);
|
|
DrawLine(window_dc,i-1,j[i-1]-p,i,j[i]-p,colors[2]);
|
|
}
|
|
}
|
|
|
|
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, ¶m);
|
|
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;
|
|
SetPixel(window_dc, i, j, colors[(int)d]);
|
|
SetPixel(buffer_dc, i, j, colors[(int)d]);
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HDC hdc;
|
|
PAINTSTRUCT ps;
|
|
|
|
switch (iMsg) {
|
|
case WM_LBUTTONDOWN:
|
|
{
|
|
int x = LOWORD(lParam);
|
|
int y = HIWORD(lParam);
|
|
point p = {(double)x/XLEN, (double)y/YLEN, current_value};
|
|
point_list.push_back(p);
|
|
draw_point(p);
|
|
}
|
|
return 0;
|
|
case WM_PAINT:
|
|
{
|
|
hdc = BeginPaint(hwnd, &ps);
|
|
BitBlt(hdc, 0, 0, XLEN, YLEN, buffer_dc, 0, 0, SRCCOPY);
|
|
EndPaint(hwnd, &ps);
|
|
}
|
|
return 0;
|
|
case WM_COMMAND:
|
|
{
|
|
int id = LOWORD(wParam);
|
|
switch (id) {
|
|
case ID_BUTTON_CHANGE:
|
|
++current_value;
|
|
if(current_value > 3) current_value = 1;
|
|
break;
|
|
case ID_BUTTON_RUN:
|
|
button_run_clicked();
|
|
break;
|
|
case ID_BUTTON_CLEAR:
|
|
clear_all();
|
|
break;
|
|
case ID_BUTTON_SAVE:
|
|
{
|
|
char filename[1024];
|
|
if(getfilename(hwnd,filename,1024,1))
|
|
{
|
|
FILE *fp = fopen(filename,"w");
|
|
|
|
char str[1024];
|
|
Edit_GetLine(edit, 0, str, sizeof(str));
|
|
const char *p = str;
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case ID_BUTTON_LOAD:
|
|
{
|
|
char filename[1024];
|
|
if(getfilename(hwnd,filename,1024,0))
|
|
{
|
|
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();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
case WM_DESTROY:
|
|
PostQuitMessage(0);
|
|
return 0;
|
|
}
|
|
|
|
return DefWindowProc(hwnd, iMsg, wParam, lParam);
|
|
}
|