volmetrics: eb87d4a12bd3 src/main.cc

volmetrics

view src/main.cc @ 34:eb87d4a12bd3

histogram

author	Eleni Maria Stea <elene.mst@gmail.com>
date	Mon, 18 Aug 2014 10:44:11 +0300
parents	3e4eb9a0d999
children	df4a277adb82

line source

1 #include <GL/glew.h>

2 #include <GL/glut.h>

3 #include <GL/glui.h>

5 #include <math.h>

6 #include <stdio.h>

7 #include <assert.h>

9 #include <vector>

11 #include "mesh.h"

12 #include "sdr.h"

13 #include "volume.h"

15 static bool init(void);

16 static GLUI *create_ui(void);

17 static void display(void);

18 static void reshape(int x, int y);

19 static void keyboard(unsigned char key, int x, int y);

20 static void keyboard_up(unsigned char key, int x, int y);

21 static void mouse(int button, int state, int x, int y);

22 static void motion(int x, int y);

23 static bool init_xfer(void);

24 static void display_xfer(void);

25 static void reshape_xfer(int x, int y);

26 static void mouse_xfer(int button, int state, int x, int y);

27 static void motion_xfer(int x, int y);

28 static void volume_preview();

29 static void draw_iso();

30 static void draw_volume();

32 static int mainwin_id, xferwin_id;

33 //todo keyb esc

35 static int win_xsz, win_ysz;

36 static float cam_phi, cam_theta, cam_dist = 6;

37 static std::vector<bool> key_state(256);

39 static const char *vol_fname = "data/test1.vol";

40 static const char *vsdr_path = "data/shaders/transfer.v.glsl";

41 static const char *fsdr_path = "data/shaders/transfer.f.glsl";

42 static const char *vsdr_vol_path = "data/shaders/vol.v.glsl";

43 static const char *fsdr_vol_path = "data/shaders/vol.f.glsl";

45 static unsigned int sprog;

46 static unsigned int sprog_vol;

48 static Volume *vol;

49 static Mesh *mesh;

50 static float cur_z, thres = 0.5, thres2 = 1.0;

51 static float slice_z = 0.5;

53 static int use_orig_vol_res = 1;

54 static int vol_res[3]; // volume sampling resolution x/y/z

55 static float bound_scale = 1.42;

57 static GLUI *ui;

59 static int num_poly = 128;

61 int main(int argc, char **argv)

62 {

63 glutInitWindowSize(512, 512);

64 glutInit(&argc, argv);

65 if(argv[1])

66 vol_fname = argv[1];

68 if(!init()) {

69 fprintf(stderr, "Failed to initialize program.\n");

70 return 1;

71 }

73 init_xfer();

75 glutMainLoop();

76 return 0;

77 }

79 static bool init()

80 {

81 glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);

83 mainwin_id = glutCreateWindow("CT scan");

84 glutDisplayFunc(display);

85 glutReshapeFunc(reshape);

86 glutKeyboardFunc(keyboard);

87 glutKeyboardUpFunc(keyboard_up);

88 glutMouseFunc(mouse);

89 glutMotionFunc(motion);

91 glewInit();

93 glEnable(GL_DEPTH_TEST);

94 glEnable(GL_NORMALIZE);

96 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

98 //FIXME shaders setup

99 if(!(sprog = sdr_getprog(vsdr_path, fsdr_path)))

100 {

101 fprintf(stderr, "Failed to create shader program!\n");

102 return false;

103 }

104

105 if(!(sprog_vol = sdr_getprog(vsdr_vol_path, fsdr_vol_path)))

106 {

107 fprintf(stderr, "Failed to create shader program!\n");

108 return false;

109 }

110

111 vol = new Volume;

112 if(!vol->load(vol_fname)) {

113 fprintf(stderr, "Failed to load %s", vol_fname);

114 return false;

115 }

116 mesh = new Mesh;

117 cur_z = 0.5;

118

119 vol_res[0] = vol->get_slice(0)->get_width();

120 vol_res[1] = vol->get_slice(0)->get_height();

121 vol_res[2] = vol->get_slice_count();

122

123 num_poly = std::max(vol_res[0], std::max(vol_res[1], vol_res[2])) * bound_scale;

124

125 if(!(ui = create_ui())) {

126 return false;

127 }

128

129 return true;

130 }

131

132 static GLUI_Spinner *res_spin[3];

133 static void toggle_use_orig(int id)

134 {

135 for(int i=0; i<3; i++) {

136 if(use_orig_vol_res) {

137 res_spin[i]->disable();

138 } else {

139 res_spin[i]->enable();

140 }

141 }

142 }

143 static void thres_change(int id)

144 {

145 static float prev_thres = thres;

146 static float prev_thres2 = thres2;

147

148 if(prev_thres != thres || prev_thres2 != thres2) {

149 prev_thres = thres;

150 prev_thres2 = thres2;

151

152 mesh->clear();

153

154 glutSetWindow(xferwin_id);

155 glutPostRedisplay();

156 glutSetWindow(mainwin_id);

157 glutPostRedisplay();

158 }

159 }

160

161 static void res_change(int id)

162 {

163 static float prev_resx = vol_res[0];

164 static float prev_resy = vol_res[1];

165 static float prev_resz = vol_res[2];

166

167 if(prev_resx != vol_res[0] || prev_resy != vol_res[1] || prev_resz != vol_res[2]) {

168 prev_resx = vol_res[0];

169 prev_resy = vol_res[1];

170 prev_resz = vol_res[2];

171 mesh->clear();

172 }

173 }

174 static GLUI *create_ui()

175 {

176 GLUI *ui = GLUI_Master.create_glui("ui");

177 assert(ui);

178

179 ui->set_main_gfx_window(glutGetWindow());

180

181 GLUI_Panel *thres_panel = ui->add_panel("iso thresholds");

182

183 GLUI_Spinner *thres_spin = ui->add_spinner_to_panel(thres_panel, "T1", GLUI_SPINNER_FLOAT, &thres, 0, thres_change);

184 thres_spin->set_float_limits(0, 1);

185

186 GLUI_Spinner *thres2_spin = ui->add_spinner_to_panel(thres_panel, "T2", GLUI_SPINNER_FLOAT, &thres2, 0, thres_change);

187 thres2_spin->set_float_limits(0, 1);

188

189 #ifdef ISO

190 GLUI_Panel *res_panel = ui->add_panel("volume resolution");

191

192 ui->add_checkbox_to_panel(res_panel, "original resolution", &use_orig_vol_res, 0, toggle_use_orig);

193

194 static const char *res_spin_name[] = {"x", "y", "z"};

195 for(int i=0; i<3; i++) {

196 res_spin[i] = ui->add_spinner_to_panel(res_panel, res_spin_name[i], GLUI_SPINNER_INT, vol_res + i, 0, res_change);

197 res_spin[i]->set_int_limits(8, 256); // TODO limits as arguments or config

198 res_spin[i]->disable();

199 }

200 #endif

201 GLUI_Panel *preview_panel = ui->add_panel("volume preview");

202

203 GLUI_Spinner *preview_spin = ui->add_spinner_to_panel(preview_panel, "slice z", GLUI_SPINNER_FLOAT, &slice_z, 0);

204 preview_spin->set_float_limits(0, 1);

205

206 return ui;

207 }

208

209 static void volume_preview ()

210 {

211 float aspect = win_xsz / win_ysz;

212

213 glDisable(GL_DEPTH_TEST);

214

215 glUseProgram(sprog);

216 int tmin_loc = glGetUniformLocation(sprog, "tmin");

217 if(tmin_loc != -1)

218 glUniform1f(tmin_loc, std::min(thres, thres2));

219 int tmax_loc = glGetUniformLocation(sprog, "tmax");

220 if(tmax_loc != -1)

221 glUniform1f(tmax_loc, std::max(thres, thres2));

222

223 glMatrixMode(GL_MODELVIEW);

224 glPushMatrix();

225 glLoadIdentity();

226

227 glMatrixMode(GL_PROJECTION);

228 glPushMatrix();

229 glLoadIdentity();

230 glOrtho(0, aspect, 0, 1, -1, 1);

231

232 glBindTexture(GL_TEXTURE_3D, vol->get_texture());

233 glEnable(GL_TEXTURE_3D);

234 glBegin(GL_QUADS);

235 glColor3f(1.0, 1.0, 1.0);

236 glTexCoord3f(0, 0, slice_z); glVertex3f(0, 1, 0);

237 glTexCoord3f(0, 1, slice_z); glVertex3f(0, 0.75, 0);

238 glTexCoord3f(1, 1, slice_z); glVertex3f(0.25, 0.75, 0);

239 glTexCoord3f(1, 0, slice_z); glVertex3f(0.25, 1, 0);

240 glEnd();

241 glDisable(GL_TEXTURE_3D);

242

243 glUseProgram(0);

244

245 glLineWidth(2);

246 glBegin(GL_LINE_LOOP);

247 glColor3f(0.8, 0.3, 0.8);

248 glVertex3f(0, 1, 0);

249 glVertex3f(0, 0.75, 0);

250 glVertex3f(0.25, 0.75, 0);

251 glVertex3f(0.25, 1, 0);

252 glEnd();

253

254 glMatrixMode(GL_PROJECTION);

255 glPopMatrix();

256

257 glMatrixMode(GL_MODELVIEW);

258 glPopMatrix();

259

260 glEnable(GL_DEPTH_TEST);

261 }

262

263 static void draw_iso()

264 {

265 if(mesh->is_empty()) {

266 printf("recalculating isosurface ... ");

267 fflush(stdout);

268 vol->create_mesh(mesh, thres, thres2, vol_res[0], vol_res[1], vol_res[2]);

269 printf("done.\n");

270 }

271 mesh->draw();

272 }

273

274 static void draw_volume()

275 {

276 glUseProgram(sprog_vol);

277

278 int tmin_loc = glGetUniformLocation(sprog_vol, "tmin");

279 if(tmin_loc != -1)

280 glUniform1f(tmin_loc, std::min(thres, thres2));

281 int tmax_loc = glGetUniformLocation(sprog_vol, "tmax");

282 if(tmax_loc != -1)

283 glUniform1f(tmax_loc, std::max(thres, thres2));

284

285 int res_loc = glGetUniformLocation(sprog_vol, "res");

286 if(res_loc != -1)

287 glUniform3f(res_loc, (float)vol_res[0], (float)vol_res[1], (float)vol_res[2]);

288

289 glRotatef(-vol->get_volume_rotation(), 1, 0, 0);

290

291 glDisable(GL_DEPTH_TEST);

292 glBindTexture(GL_TEXTURE_3D, vol->get_texture());

293 glEnable(GL_TEXTURE_3D);

294 glEnable(GL_BLEND);

295 glBegin(GL_QUADS);

296 for(int i=0; i<num_poly; i++)

297 {

298 float tex_z = (float)i / (float)num_poly;

299 float z = 2 * tex_z - 1;

300

301 glTexCoord3f(0, 0, tex_z); glVertex3f(-bound_scale, -bound_scale, z * bound_scale);

302 glTexCoord3f(0, 1, tex_z); glVertex3f(-bound_scale, bound_scale, z * bound_scale);

303 glTexCoord3f(1, 1, tex_z); glVertex3f(bound_scale, bound_scale, z * bound_scale);

304 glTexCoord3f(1, 0, tex_z); glVertex3f(bound_scale, -bound_scale, z * bound_scale);

305 }

306 glEnd();

307 glDisable(GL_BLEND);

308 glDisable(GL_TEXTURE_3D);

309 glEnable(GL_DEPTH_TEST);

310

311 glUseProgram(0);

312 }

313

314 static void display(void)

315 {

316 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

317

318 glMatrixMode(GL_MODELVIEW);

319 glLoadIdentity();

320 glTranslatef(0, 0, -cam_dist);

321 glRotatef(cam_phi, 1, 0, 0);

322 glRotatef(cam_theta, 0, 1, 0);

323

324 //draw_slices();

325 //draw_iso();

326 draw_volume();

327

328 volume_preview();

329 glutSwapBuffers();

330 assert(glGetError() == GL_NO_ERROR);

331 }

332

333 static void reshape(int x, int y)

334 {

335 glViewport(0, 0, x, y);

336 glMatrixMode(GL_PROJECTION);

337 glLoadIdentity();

338 gluPerspective(45, (float)x / (float)y, 0.5, 500);

339

340 win_xsz = x;

341 win_ysz = y;

342 }

343

344 static void keyboard(unsigned char key, int x, int y)

345 {

346 key_state[(int)key] = true;

347

348 switch(key) {

349 case 27:

350 exit(0);

351 case 'w':

352 {

353 static bool wire;

354 wire = !wire;

355 glPolygonMode(GL_FRONT_AND_BACK, wire ? GL_LINE : GL_FILL);

356 }

357 break;

358 default:

359 break;

360 }

361 }

362

363 static void keyboard_up(unsigned char key, int x, int y)

364 {

365 key_state[(int) key] = false;

366 }

367

368 static int prev_x, prev_y;

369 static bool bn_state[32];

370 static float prev_thres, prev_thres2;

371

372 static void mouse(int bn, int state, int x, int y)

373 {

374 prev_x = x;

375 prev_y = y;

376

377 bn_state[bn - GLUT_LEFT_BUTTON] = (state == GLUT_DOWN);

378

379 if(state == GLUT_DOWN) {

380 prev_thres = thres;

381 prev_thres2 = thres2;

382 }

383 else {

384 if(thres != prev_thres || thres2 != prev_thres2) {

385 mesh->clear();

386 }

387 }

388 }

389

390 static void motion(int x, int y)

391 {

392 int dx = x - prev_x;

393 int dy = y - prev_y;

394

395 if(!dx && !dy)

396 return;

397

398 prev_x = x;

399 prev_y = y;

400

401 if(key_state[(int)'t']) {

402 thres = (float)x / (float)win_xsz;

403 printf("threshold: %f\n", thres);

404

405 glutPostRedisplay();

406 return;

407 }

408

409 // camera

410 if(bn_state[0]) {

411 if(key_state[(int)'z']) {

412 //zoom the camera

413

414 cam_dist += dy * 0.1;

415

416 if(cam_dist < 0)

417 cam_dist = 0;

418 }

419 else {

420 //rotate the camera

421

422 cam_phi += dy * 0.5;

423 cam_theta += dx * 0.5;

424

425 if(cam_phi > 90)

426 cam_phi = 90;

427 if(cam_phi < -90)

428 cam_phi = -90;

429 }

430

431 glutPostRedisplay();

432 }

433 }

434

435 static bool init_xfer(void)

436 {

437 glutSetWindow(mainwin_id);

438 int x = glutGet(GLUT_WINDOW_X);

439 int y = glutGet(GLUT_WINDOW_Y) + glutGet(GLUT_WINDOW_HEIGHT);

440

441 glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

442 glutInitWindowSize(512, 100);

443 glutInitWindowPosition(x, y);

444

445 xferwin_id = glutCreateWindow("Transfer Function");

446 glutDisplayFunc(display_xfer);

447 glutReshapeFunc(reshape_xfer);

448 glutMouseFunc(mouse_xfer);

449 glutMotionFunc(motion_xfer);

450

451 return true;

452 }

453

454 static void display_xfer(void)

455 {

456 glClear(GL_COLOR_BUFFER_BIT);

457

458 int num_val = glutGet(GLUT_WINDOW_WIDTH) / 4.0;

459 float x = 0;

460 float dx = 1.0 / num_val;

461 float low, high;

462 if(thres < thres2) {

463 low = thres;

464 high = thres2;

465 }

466 else {

467 low = thres2;

468 high = thres;

469 }

470

471

472 //drawing the histogram

473 float hmax = 1 / (float)vol->max_histogram_value;

474

475 glBegin(GL_QUADS);

476 for (int i=0; i<HIST_SIZE; i++) {

477 float x0 = (float)i / HIST_SIZE;

478 float x1 = (float)(i + 1) / HIST_SIZE;

479

480 glColor3f(0.3, 0.3, 0.3);

481 glVertex3f(x0, 0, 0);

482 glVertex3f(x1, 0, 0);

483 glVertex3f(x1, hmax * vol->histogram[i + 1], 0);

484 glVertex3f(x0, hmax * vol->histogram[i], 0);

485 }

486 glEnd();

487

488 //drawing the transfer function curve

489

490 glLineWidth(3);

491 glBegin(GL_LINE_STRIP);

492 glColor3f(0.8, 0.3, 0.8);

493 for(int i=0; i<num_val; i++) {

494 float val = transfer_function(x, low, high);

495 glVertex2f(x, val);

496 x += dx;

497 }

498 glEnd();

499

500 //threshold bars

501

502 glLineWidth(2);

503 glBegin(GL_LINES);

504 glColor3f(0.4, 0.4, 0.8);

505 glVertex2f(low, 0);

506 glVertex2f(low, 1);

507 glColor3f(0.4, 0.8, 0.4);

508 glVertex2f(high, 0);

509 glVertex2f(high, 1);

510 glEnd();

511

512 /*

513 * gradient

514 */

515 /* glBegin(GL_QUADS);

516 for(int i=0; i<num_val; i++) {

517 float val = transfer_function(x, low, high);

518 glColor3f(val, val, val);

519 glVertex3f(x, 1.0, 0.0);

520 glVertex3f(x, 0.0, 0.0);

521

522 val = transfer_function(x + dx, low, high);

523 glColor3f(val, val, val);

524 glVertex3f(x + dx, 0.0, 0.0);

525 glVertex3f(x + dx, 1.0, 0.0);

526 x += dx;

527 }

528 glEnd(); */

529

530 glutSwapBuffers();

531 assert(glGetError() == GL_NO_ERROR);

532 }

533

534 static void reshape_xfer(int x, int y)

535 {

536 glViewport(0.0, 0.0, x, y);

537 glMatrixMode(GL_PROJECTION);

538 glLoadIdentity();

539 glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

540 }

541

542 static float *select_thres;

543 static float prev_select_thres;

544 static void mouse_xfer(int button, int state, int x, int y)

545 {

546 if(button == GLUT_LEFT_BUTTON) {

547 if(state == GLUT_DOWN) {

548 int width = glutGet(GLUT_WINDOW_WIDTH);

549 float xpos = (float)x / (float)width;

550 if(fabs(xpos - thres) <= fabs(xpos - thres2) && fabs(xpos - thres) < 0.1) {

551 select_thres = &thres;

552 }

553 else if (fabs(xpos - thres2) < 0.1) {

554 select_thres = &thres2;

555 }

556 else

557 select_thres = 0;

558

559 if (select_thres)

560 prev_select_thres = *select_thres;

561 }

562 else {

563 if(!prev_select_thres || !select_thres) {

564 select_thres = 0;

565 return;

566 }

567 if(fabs(*select_thres - prev_select_thres) > 0.001) {

568 mesh->clear();

569 ui->sync_live();

570 }

571 select_thres = 0;

572 }

573 }

574 }

575

576 static void motion_xfer(int x, int y)

577 {

578 if(!select_thres)

579 return;

580

581 int width = glutGet(GLUT_WINDOW_WIDTH);

582 float xpos = (float)x / (float)width;

583

584 *select_thres = xpos;

585 thres_change(0);

586

587 glutPostRedisplay();

588 glutSetWindow(mainwin_id);

589 glutPostRedisplay();

590 }