开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > .net编程 > 查看源码
svm-toy.cpp
资源名称：svm.rar　[点击查看]
上传用户：xgw_05
上传日期：2014-12-08
资源大小：2726k
文件大小：11k
源码类别：

.net编程

开发平台：

Java

svm-toy.cpp：源码内容
  1. #include <windows.h>
  2. #include <windowsx.h>
  3. #include <stdio.h>
  4. #include <ctype.h>
  5. #include <list>
  6. #include "../../svm.h"
  7. #define DEFAULT_PARAM "-t 2 -c 100"
  8. #define XLEN 500
  9. #define YLEN 500
  10. #define DrawLine(dc,x1,y1,x2,y2,c) 
  11. do { 
  12. HPEN hpen = CreatePen(PS_SOLID,0,c); 
  13. HPEN horig = SelectPen(dc,hpen); 
  14. MoveToEx(dc,x1,y1,NULL); 
  15. LineTo(dc,x2,y2); 
  16. SelectPen(dc,horig); 
  17. DeletePen(hpen); 
  18. } while(0)
  20. using namespace std;
  22. COLORREF colors[] =
  23. {
  24. RGB(0,0,0),
  25. RGB(0,120,120),
  26. RGB(120,120,0),
  27. RGB(120,0,120),
  28. RGB(0,200,200),
  29. RGB(200,200,0),
  30. RGB(200,0,200)
  31. };
  33. HWND main_window;
  34. HBITMAP buffer;
  35. HDC window_dc;
  36. HDC buffer_dc;
  37. HBRUSH brush1, brush2, brush3;
  38. HWND edit;
  40. enum {
  41. ID_BUTTON_CHANGE, ID_BUTTON_RUN, ID_BUTTON_CLEAR,
  42. ID_BUTTON_LOAD, ID_BUTTON_SAVE, ID_EDIT
  43. };
  45. struct point {
  46. double x, y;
  47. signed char value;
  48. };
  50. list<point> point_list;
  51. int current_value = 1;
  53. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  55. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
  56.    PSTR szCmdLine, int iCmdShow)
  57. {
  58. static char szAppName[] = "SvmToy";
  59. MSG msg;
  60. WNDCLASSEX wndclass;
  62. wndclass.cbSize = sizeof(wndclass);
  63. wndclass.style = CS_HREDRAW | CS_VREDRAW;
  64. wndclass.lpfnWndProc = WndProc;
  65. wndclass.cbClsExtra = 0;
  66. wndclass.cbWndExtra = 0;
  67. wndclass.hInstance = hInstance;
  68. wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  69. wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  70. wndclass.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);
  71. wndclass.lpszMenuName = NULL;
  72. wndclass.lpszClassName = szAppName;
  73. wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
  75. RegisterClassEx(&wndclass);
  77. main_window = CreateWindow(szAppName, // window class name
  78.     "SVM Toy", // window caption
  79.     WS_OVERLAPPEDWINDOW,// window style
  80.     CW_USEDEFAULT, // initial x position
  81.     CW_USEDEFAULT, // initial y position
  82.     XLEN, // initial x size
  83.     YLEN+52, // initial y size
  84.     NULL, // parent window handle
  85.     NULL, // window menu handle
  86.     hInstance, // program instance handle
  87.     NULL); // creation parameters
  89. ShowWindow(main_window, iCmdShow);
  90. UpdateWindow(main_window);
  92. CreateWindow("button", "Change", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
  93.      0, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_CHANGE, hInstance, NULL);
  94. CreateWindow("button", "Run", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
  95.      50, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_RUN, hInstance, NULL);
  96. CreateWindow("button", "Clear", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
  97.      100, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_CLEAR, hInstance, NULL);
  98. CreateWindow("button", "Save", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
  99.      150, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_SAVE, hInstance, NULL);
  100. CreateWindow("button", "Load", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
  101.      200, YLEN, 50, 25, main_window, (HMENU) ID_BUTTON_LOAD, hInstance, NULL);
  103. edit = CreateWindow("edit", NULL, WS_CHILD | WS_VISIBLE,
  104.             250, YLEN, 250, 25, main_window, (HMENU) ID_EDIT, hInstance, NULL);
  106. Edit_SetText(edit,DEFAULT_PARAM);
  108. brush1 = CreateSolidBrush(colors[4]);
  109. brush2 = CreateSolidBrush(colors[5]);
  110. brush3 = CreateSolidBrush(colors[6]);
  112. window_dc = GetDC(main_window);
  113. buffer = CreateCompatibleBitmap(window_dc, XLEN, YLEN);
  114. buffer_dc = CreateCompatibleDC(window_dc);
  115. SelectObject(buffer_dc, buffer);
  116. PatBlt(buffer_dc, 0, 0, XLEN, YLEN, BLACKNESS);
  118. while (GetMessage(&msg, NULL, 0, 0)) {
  119. TranslateMessage(&msg);
  120. DispatchMessage(&msg);
  121. }
  122. return msg.wParam;
  123. }
  125. int getfilename( HWND hWnd , char *filename, int len, int save) 
  126. { 
  127. OPENFILENAME OpenFileName; 
  128. memset(&OpenFileName,0,sizeof(OpenFileName));
  129. filename[0]='';
  130.  
  131. OpenFileName.lStructSize       = sizeof(OPENFILENAME); 
  132. OpenFileName.hwndOwner         = hWnd; 
  133. OpenFileName.lpstrFile         = filename; 
  134. OpenFileName.nMaxFile          = len; 
  135. OpenFileName.Flags             = 0;
  136.  
  137. return save?GetSaveFileName(&OpenFileName):GetOpenFileName(&OpenFileName);
  138. }
  140. void clear_all()
  141. {
  142. point_list.clear();
  143. PatBlt(buffer_dc, 0, 0, XLEN, YLEN, BLACKNESS);
  144. InvalidateRect(main_window, 0, 0);
  145. }
  147. HBRUSH choose_brush(int v)
  148. {
  149. if(v==1) return brush1;
  150. else if(v==2) return brush2;
  151. else return brush3;
  152. }
  154. void draw_point(const point & p)
  155. {
  156. RECT rect;
  157. rect.left = int(p.x*XLEN);
  158. rect.top = int(p.y*YLEN);
  159. rect.right = int(p.x*XLEN) + 3;
  160. rect.bottom = int(p.y*YLEN) + 3;
  161. FillRect(window_dc, &rect, choose_brush(p.value));
  162. FillRect(buffer_dc, &rect, choose_brush(p.value));
  163. }
  165. void draw_all_points()
  166. {
  167. for(list<point>::iterator p = point_list.begin(); p != point_list.end(); p++)
  168. draw_point(*p);
  169. }
  171. void button_run_clicked()
  172. {
  173. // guard
  174. if(point_list.empty()) return;
  176. svm_parameter param;
  177. int i,j;
  179. // default values
  180. param.svm_type = C_SVC;
  181. param.kernel_type = RBF;
  182. param.degree = 3;
  183. param.gamma = 0;
  184. param.coef0 = 0;
  185. param.nu = 0.5;
  186. param.cache_size = 40;
  187. param.C = 1;
  188. param.eps = 1e-3;
  189. param.p = 0.1;
  190. param.shrinking = 1;
  191. param.nr_weight = 0;
  192. param.weight_label = NULL;
  193. param.weight = NULL;
  195. // parse options
  196. char str[1024];
  197. Edit_GetLine(edit, 0, str, sizeof(str));
  198. const char *p = str;
  200. while (1) {
  201. while (*p && *p != '-')
  202. p++;
  204. if (*p == '')
  205. break;
  207. p++;
  208. switch (*p++) {
  209. case 's':
  210. param.svm_type = atoi(p);
  211. break;
  212. case 't':
  213. param.kernel_type = atoi(p);
  214. break;
  215. case 'd':
  216. param.degree = atof(p);
  217. break;
  218. case 'g':
  219. param.gamma = atof(p);
  220. break;
  221. case 'r':
  222. param.coef0 = atof(p);
  223. break;
  224. case 'n':
  225. param.nu = atof(p);
  226. break;
  227. case 'm':
  228. param.cache_size = atof(p);
  229. break;
  230. case 'c':
  231. param.C = atof(p);
  232. break;
  233. case 'e':
  234. param.eps = atof(p);
  235. break;
  236. case 'p':
  237. param.p = atof(p);
  238. break;
  239. case 'h':
  240. param.shrinking = atoi(p);
  241. break;
  242. case 'w':
  243. ++param.nr_weight;
  244. param.weight_label = (int *)realloc(param.weight_label,sizeof(int)*param.nr_weight);
  245. param.weight = (double *)realloc(param.weight,sizeof(double)*param.nr_weight);
  246. param.weight_label[param.nr_weight-1] = atoi(p);
  247. while(*p && !isspace(*p)) ++p;
  248. param.weight[param.nr_weight-1] = atof(p);
  249. break;
  250. }
  251. }
  253. // build problem
  254. svm_problem prob;
  256. prob.l = point_list.size();
  257. prob.y = new double[prob.l];
  259. if(param.svm_type == EPSILON_SVR ||
  260.    param.svm_type == NU_SVR)
  261. {
  262. if(param.gamma == 0) param.gamma = 1;
  263. svm_node *x_space = new svm_node[2 * prob.l];
  264. prob.x = new svm_node *[prob.l];
  266. i = 0;
  267. for (list<point>::iterator q = point_list.begin(); q != point_list.end(); q++, i++)
  268. {
  269. x_space[2 * i].index = 1;
  270. x_space[2 * i].value = q->x;
  271. x_space[2 * i + 1].index = -1;
  272. prob.x[i] = &x_space[2 * i];
  273. prob.y[i] = q->y;
  274. }
  276. // build model & classify
  277. svm_model *model = svm_train(&prob, &param);
  278. svm_node x[2];
  279. x[0].index = 1;
  280. x[1].index = -1;
  281. int *j = new int[XLEN];
  283. for (i = 0; i < XLEN; i++)
  284. {
  285. x[0].value = (double) i / XLEN;
  286. j[i] = (int)(YLEN*svm_predict(model, x));
  287. }
  289. DrawLine(buffer_dc,0,0,0,YLEN,colors[0]);
  290. DrawLine(window_dc,0,0,0,YLEN,colors[0]);
  292. int p = (int)(param.p * YLEN);
  293. for(int i=1; i < XLEN; i++)
  294. {
  295. DrawLine(buffer_dc,i,0,i,YLEN,colors[0]);
  296. DrawLine(window_dc,i,0,i,YLEN,colors[0]);
  298. DrawLine(buffer_dc,i-1,j[i-1],i,j[i],colors[5]);
  299. DrawLine(window_dc,i-1,j[i-1],i,j[i],colors[5]);
  301. if(param.svm_type == EPSILON_SVR)
  302. {
  303. DrawLine(buffer_dc,i-1,j[i-1]+p,i,j[i]+p,colors[2]);
  304. DrawLine(window_dc,i-1,j[i-1]+p,i,j[i]+p,colors[2]);
  306. DrawLine(buffer_dc,i-1,j[i-1]-p,i,j[i]-p,colors[2]);
  307. DrawLine(window_dc,i-1,j[i-1]-p,i,j[i]-p,colors[2]);
  308. }
  309. }
  311. svm_destroy_model(model);
  312. delete[] j;
  313. delete[] x_space;
  314. delete[] prob.x;
  315. delete[] prob.y;
  316. }
  317. else
  318. {
  319. if(param.gamma == 0) param.gamma = 0.5;
  320. svm_node *x_space = new svm_node[3 * prob.l];
  321. prob.x = new svm_node *[prob.l];
  323. i = 0;
  324. for (list<point>::iterator q = point_list.begin(); q != point_list.end(); q++, i++)
  325. {
  326. x_space[3 * i].index = 1;
  327. x_space[3 * i].value = q->x;
  328. x_space[3 * i + 1].index = 2;
  329. x_space[3 * i + 1].value = q->y;
  330. x_space[3 * i + 2].index = -1;
  331. prob.x[i] = &x_space[3 * i];
  332. prob.y[i] = q->value;
  333. }
  335. // build model & classify
  336. svm_model *model = svm_train(&prob, &param);
  337. svm_node x[3];
  338. x[0].index = 1;
  339. x[1].index = 2;
  340. x[2].index = -1;
  342. for (i = 0; i < XLEN; i++)
  343. for (j = 0; j < YLEN; j++) {
  344. x[0].value = (double) i / XLEN;
  345. x[1].value = (double) j / YLEN;
  346. double d = svm_predict(model, x);
  347. SetPixel(window_dc, i, j, colors[(int)d]);
  348. SetPixel(buffer_dc, i, j, colors[(int)d]);
  349. }
  351. svm_destroy_model(model);
  352. delete[] x_space;
  353. delete[] prob.x;
  354. delete[] prob.y;
  355. }
  356. free(param.weight_label);
  357. free(param.weight);
  358. draw_all_points();
  359. }
  361. LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
  362. {
  363. HDC hdc;
  364. PAINTSTRUCT ps;
  366. switch (iMsg) {
  367. case WM_LBUTTONDOWN:
  368. {
  369. int x = LOWORD(lParam);
  370. int y = HIWORD(lParam);
  371. point p = {(double)x/XLEN, (double)y/YLEN, current_value};
  372. point_list.push_back(p);
  373. draw_point(p);
  374. }
  375. return 0;
  376. case WM_PAINT:
  377. {
  378. hdc = BeginPaint(hwnd, &ps);
  379. BitBlt(hdc, 0, 0, XLEN, YLEN, buffer_dc, 0, 0, SRCCOPY);
  380. EndPaint(hwnd, &ps);
  381. }
  382. return 0;
  383. case WM_COMMAND:
  384. {
  385. int id = LOWORD(wParam);
  386. switch (id) {
  387. case ID_BUTTON_CHANGE:
  388. ++current_value;
  389. if(current_value > 3) current_value = 1;
  390. break;
  391. case ID_BUTTON_RUN:
  392. button_run_clicked();
  393. break;
  394. case ID_BUTTON_CLEAR:
  395. clear_all();
  396. break;
  397. case ID_BUTTON_SAVE:
  398. {
  399. char filename[1024];
  400. if(getfilename(hwnd,filename,1024,1))
  401. {
  402. FILE *fp = fopen(filename,"w");
  403. if(fp)
  404. {
  405. for (list<point>::iterator p = point_list.begin(); p != point_list.end(); p++)
  406. fprintf(fp,"%d 1:%f 2:%fn",p->value,p->x,p->y);
  407. fclose(fp);
  408. }
  409. }
  410. }
  411. break;
  412. case ID_BUTTON_LOAD:
  413. {
  414. char filename[1024];
  415. if(getfilename(hwnd,filename,1024,0))
  416. {
  417. FILE *fp = fopen(filename,"r");
  418. if(fp)
  419. {
  420. clear_all();
  421. char buf[4096];
  422. while(fgets(buf,sizeof(buf),fp))
  423. {
  424. int v;
  425. double x,y;
  426. if(sscanf(buf,"%d%*d:%lf%*d:%lf",&v,&x,&y)!=3)
  427. break;
  428. point p = {x,y,v};
  429. point_list.push_back(p);
  430. }
  431. fclose(fp);
  432. draw_all_points();
  433. }
  434. }
  435. }
  436. break;
  437. }
  438. }
  439. return 0;
  440. case WM_DESTROY:
  441. PostQuitMessage(0);
  442. return 0;
  443. }
  445. return DefWindowProc(hwnd, iMsg, wParam, lParam);
  446. }