windows/svm-toy.cpp

Go to the documentation of this file.

#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, &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));
    }

    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, &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;
        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);
}