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

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

.net编程

开发平台：

Java

callbacks.cpp：源码内容
  1. #include <gtk/gtk.h>
  2. #include <stdio.h>
  3. #include <ctype.h>
  4. #include <list>
  5. #include "callbacks.h"
  6. #include "interface.h"
  7. #include "../../svm.h"
  9. #define DEFAULT_PARAM "-t 2 -c 100"
  10. #define XLEN 500
  11. #define YLEN 500
  13. GdkColor colors[] = 
  14. {
  15. {0,0,0,0},
  16. {0,0,120<<8,120<<8},
  17. {0,120<<8,120<<8,0},
  18. {0,120<<8,0,120<<8},
  19. {0,0,200<<8,200<<8},
  20. {0,200<<8,200<<8,0},
  21. {0,200<<8,0,200<<8},
  22. };
  24. GdkGC *gc;
  25. GdkPixmap *pixmap;
  26. extern "C" GtkWidget *draw_main;
  27. GtkWidget *draw_main;
  28. extern "C" GtkWidget *entry_option;
  29. GtkWidget *entry_option;
  31. typedef struct {
  32. double x, y;
  33. signed char value;
  34. } point;
  36. list<point> point_list;
  37. int current_value = 1;
  39. extern "C" void svm_toy_initialize()
  40. {
  41. gboolean success[7];
  43. gdk_colormap_alloc_colors(
  44. gdk_colormap_get_system(),
  45. colors,
  46. 7,
  47. FALSE,
  48. TRUE,
  49. success);
  51. gc = gdk_gc_new(draw_main->window);
  52. pixmap = gdk_pixmap_new(draw_main->window,XLEN,YLEN,-1);
  53. gdk_gc_set_foreground(gc,&colors[0]);
  54. gdk_draw_rectangle(pixmap,gc,TRUE,0,0,XLEN,YLEN);
  55. gtk_entry_set_text(GTK_ENTRY(entry_option),DEFAULT_PARAM);
  56. }
  58. void redraw_area(GtkWidget* widget, int x, int y, int w, int h)
  59. {
  60. gdk_draw_pixmap(widget->window,
  61. gc,
  62. pixmap,
  63. x,y,x,y,w,h);
  64. }
  66. void draw_point(const point& p)
  67. {
  68. gdk_gc_set_foreground(gc,&colors[p.value+3]);
  69. gdk_draw_rectangle(pixmap, gc, TRUE,int(p.x*XLEN),int(p.y*YLEN),4,4);
  70. gdk_draw_rectangle(draw_main->window, gc, TRUE,int(p.x*XLEN),int(p.y*YLEN),4,4);
  71. }
  73. void draw_all_points()
  74. {
  75. for(list<point>::iterator p = point_list.begin(); p != point_list.end();p++)
  76. draw_point(*p);
  77. }
  79. void clear_all()
  80. {
  81. point_list.clear();
  82. gdk_gc_set_foreground(gc,&colors[0]);
  83. gdk_draw_rectangle(pixmap,gc,TRUE,0,0,XLEN,YLEN);
  84. redraw_area(draw_main,0,0,XLEN,YLEN);
  85. }
  87. void
  88. on_button_change_clicked               (GtkButton       *button,
  89.                                         gpointer         user_data)
  90. {
  91. ++current_value;
  92. if(current_value > 3) current_value = 1;
  93. }
  95. void
  96. on_button_run_clicked                  (GtkButton       *button,
  97.                                         gpointer         user_data)
  98. {
  99. // guard
  100. if(point_list.empty()) return;
  102. svm_parameter param;
  103. int i,j;
  105. // default values
  106. param.svm_type = C_SVC;
  107. param.kernel_type = RBF;
  108. param.degree = 3;
  109. param.gamma = 0;
  110. param.coef0 = 0;
  111. param.nu = 0.5;
  112. param.cache_size = 40;
  113. param.C = 1;
  114. param.eps = 1e-3;
  115. param.p = 0.1;
  116. param.shrinking = 1;
  117. param.nr_weight = 0;
  118. param.weight_label = NULL;
  119. param.weight = NULL;
  121. // parse options
  122. const char *p = gtk_entry_get_text(GTK_ENTRY(entry_option));
  124. while (1) {
  125. while (*p && *p != '-')
  126. p++;
  128. if (*p == '')
  129. break;
  131. p++;
  132. switch (*p++) {
  133. case 's':
  134. param.svm_type = atoi(p);
  135. break;
  136. case 't':
  137. param.kernel_type = atoi(p);
  138. break;
  139. case 'd':
  140. param.degree = atof(p);
  141. break;
  142. case 'g':
  143. param.gamma = atof(p);
  144. break;
  145. case 'r':
  146. param.coef0 = atof(p);
  147. break;
  148. case 'n':
  149. param.nu = atof(p);
  150. break;
  151. case 'm':
  152. param.cache_size = atof(p);
  153. break;
  154. case 'c':
  155. param.C = atof(p);
  156. break;
  157. case 'e':
  158. param.eps = atof(p);
  159. break;
  160. case 'p':
  161. param.p = atof(p);
  162. break;
  163. case 'h':
  164. param.shrinking = atoi(p);
  165. break;
  166. case 'w':
  167. ++param.nr_weight;
  168. param.weight_label = (int *)realloc(param.weight_label,sizeof(int)*param.nr_weight);
  169. param.weight = (double *)realloc(param.weight,sizeof(double)*param.nr_weight);
  170. param.weight_label[param.nr_weight-1] = atoi(p);
  171. while(*p && !isspace(*p)) ++p;
  172. param.weight[param.nr_weight-1] = atof(p);
  173. break;
  174. }
  175. }
  177. // build problem
  178. svm_problem prob;
  180. prob.l = point_list.size();
  181. prob.y = new double[prob.l];
  183. if(param.svm_type == EPSILON_SVR ||
  184.    param.svm_type == NU_SVR)
  185. {
  186. if(param.gamma == 0) param.gamma = 1;
  187. svm_node *x_space = new svm_node[2 * prob.l];
  188. prob.x = new svm_node *[prob.l];
  190. i = 0;
  191. for (list <point>::iterator q = point_list.begin(); q != point_list.end(); q++, i++)
  192. {
  193. x_space[2 * i].index = 1;
  194. x_space[2 * i].value = q->x;
  195. x_space[2 * i + 1].index = -1;
  196. prob.x[i] = &x_space[2 * i];
  197. prob.y[i] = q->y;
  198. }
  200. // build model & classify
  201. svm_model *model = svm_train(&prob, &param);
  202. svm_node x[2];
  203. x[0].index = 1;
  204. x[1].index = -1;
  205. int *j = new int[XLEN];
  207. for (i = 0; i < XLEN; i++) 
  208. {
  209. x[0].value = (double) i / XLEN;
  210. j[i] = (int)(YLEN*svm_predict(model, x));
  211. }
  213. gdk_gc_set_foreground(gc,&colors[0]);
  214. gdk_draw_line(pixmap,gc,0,0,0,YLEN-1);
  215. gdk_draw_line(draw_main->window,gc,0,0,0,YLEN-1);
  217. int p = (int)(param.p * YLEN);
  218. for(i = 1; i < XLEN; i++)
  219. {
  220. gdk_gc_set_foreground(gc,&colors[0]);
  221. gdk_draw_line(pixmap,gc,i,0,i,YLEN-1);
  222. gdk_draw_line(draw_main->window,gc,i,0,i,YLEN-1);
  224. gdk_gc_set_foreground(gc,&colors[5]);
  225. gdk_draw_line(pixmap,gc,i-1,j[i-1],i,j[i]);
  226. gdk_draw_line(draw_main->window,gc,i-1,j[i-1],i,j[i]);
  228. if(param.svm_type == EPSILON_SVR)
  229. {
  230. gdk_gc_set_foreground(gc,&colors[2]);
  231. gdk_draw_line(pixmap,gc,i-1,j[i-1]+p,i,j[i]+p);
  232. gdk_draw_line(draw_main->window,gc,i-1,j[i-1]+p,i,j[i]+p);
  234. gdk_gc_set_foreground(gc,&colors[2]);
  235. gdk_draw_line(pixmap,gc,i-1,j[i-1]-p,i,j[i]-p);
  236. gdk_draw_line(draw_main->window,gc,i-1,j[i-1]-p,i,j[i]-p);
  237. }
  238. }
  240. svm_destroy_model(model);
  241. delete[] j;
  242. delete[] x_space;
  243. delete[] prob.x;
  244. delete[] prob.y;
  245. }
  246. else
  247. {
  248. if(param.gamma == 0) param.gamma = 0.5;
  249. svm_node *x_space = new svm_node[3 * prob.l];
  250. prob.x = new svm_node *[prob.l];
  252. i = 0;
  253. for (list <point>::iterator q = point_list.begin(); q != point_list.end(); q++, i++)
  254. {
  255. x_space[3 * i].index = 1;
  256. x_space[3 * i].value = q->x;
  257. x_space[3 * i + 1].index = 2;
  258. x_space[3 * i + 1].value = q->y;
  259. x_space[3 * i + 2].index = -1;
  260. prob.x[i] = &x_space[3 * i];
  261. prob.y[i] = q->value;
  262. }
  264. // build model & classify
  265. svm_model *model = svm_train(&prob, &param);
  266. svm_node x[3];
  267. x[0].index = 1;
  268. x[1].index = 2;
  269. x[2].index = -1;
  271. for (i = 0; i < XLEN; i++) 
  272. for (j = 0; j < YLEN; j++) {
  273. x[0].value = (double) i / XLEN;
  274. x[1].value = (double) j / YLEN;
  275. double d = svm_predict(model, x);
  276. gdk_gc_set_foreground(gc,&colors[(int)d]);
  277. gdk_draw_point(pixmap,gc,i,j);
  278. gdk_draw_point(draw_main->window,gc,i,j);
  279. }
  281. svm_destroy_model(model);
  282. delete[] x_space;
  283. delete[] prob.x;
  284. delete[] prob.y;
  285. }
  286. free(param.weight_label);
  287. free(param.weight);
  288. draw_all_points();
  289. }
  291. void
  292. on_button_clear_clicked                (GtkButton       *button,
  293.                                         gpointer         user_data)
  294. {
  295. clear_all();
  296. }
  298. void
  299. on_window1_destroy                     (GtkObject       *object,
  300.                                         gpointer         user_data)
  301. {
  302. gtk_exit(0);
  303. }
  305. gboolean
  306. on_draw_main_button_press_event        (GtkWidget       *widget,
  307.                                         GdkEventButton  *event,
  308.                                         gpointer         user_data)
  309. {
  310. point p = {(double)event->x/XLEN, (double)event->y/YLEN, current_value};
  311. point_list.push_back(p);
  312. draw_point(p);
  313. return FALSE;
  314. }
  316. gboolean
  317. on_draw_main_expose_event              (GtkWidget       *widget,
  318.                                         GdkEventExpose  *event,
  319.                                         gpointer         user_data)
  320. {
  321. redraw_area(widget,
  322.     event->area.x, event->area.y,
  323.     event->area.width, event->area.height);
  324. return FALSE;
  325. }
  327. GtkWidget *fileselection;
  328. enum { SAVE, LOAD } fileselection_flag;
  330. void show_fileselection()
  331. {
  332. fileselection = create_fileselection();
  333. gtk_signal_connect_object(
  334. GTK_OBJECT(GTK_FILE_SELECTION(fileselection)->ok_button),
  335. "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
  336. (GtkObject *) fileselection);
  338. gtk_signal_connect_object (GTK_OBJECT
  339. (GTK_FILE_SELECTION(fileselection)->cancel_button),
  340. "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
  341. (GtkObject *) fileselection);
  343. gtk_widget_show(fileselection);
  344. }
  346. void
  347. on_button_save_clicked                 (GtkButton       *button,
  348.                                         gpointer         user_data)
  349. {
  350. fileselection_flag = SAVE;
  351. show_fileselection();
  352. }
  355. void
  356. on_button_load_clicked                 (GtkButton       *button,
  357.                                         gpointer         user_data)
  358. {
  359. fileselection_flag = LOAD;
  360. show_fileselection();
  361. }
  363. void
  364. on_filesel_ok_clicked                  (GtkButton       *button,
  365.                                         gpointer         user_data)
  366. {
  367. gtk_widget_hide(fileselection);
  368. const char *filename = gtk_file_selection_get_filename(GTK_FILE_SELECTION(fileselection));
  370. if(fileselection_flag == SAVE)
  371. {
  372. FILE *fp = fopen(filename,"w");
  373. if(fp)
  374. {
  375. for(list<point>::iterator p = point_list.begin(); p != point_list.end();p++)
  376. fprintf(fp,"%d 1:%f 2:%fn", p->value, p->x, p->y);
  377. fclose(fp);
  378. }
  380. }
  381. else if(fileselection_flag == LOAD)
  382. {
  383. FILE *fp = fopen(filename,"r");
  384. if(fp)
  385. {
  386. clear_all();
  387. char buf[4096];
  388. while(fgets(buf,sizeof(buf),fp))
  389. {
  390. int v;
  391. double x,y;
  392. if(sscanf(buf,"%d%*d:%lf%*d:%lf",&v,&x,&y)!=3)
  393. break;
  394. point p = {x,y,v};
  395. point_list.push_back(p);
  396. }
  397. fclose(fp);
  398. draw_all_points();
  399. }
  400. }
  401. }
  403. void
  404. on_fileselection_destroy               (GtkObject       *object,
  405.                                         gpointer         user_data)
  406. {
  407. }
  409. void
  410. on_filesel_cancel_clicked              (GtkButton       *button,
  411.                                         gpointer         user_data)
  412. {
  413. }