1 #include "bwm_tableau_img.h"
2 #include "bwm_tableau_text.h"
3 #include "bwm_command_macros.h"
4 #include "bwm_observer_mgr.h"
5 #include "bwm_tableau_mgr.h"
6 #include "bwm_popup_menu.h"
7 #include "vsl/vsl_binary_io.h"
8 #include "vsl/vsl_vector_io.h"
9 #include "vil/vil_save.h"
10 #include <vsol/vsol_point_2d.h>
11 #include <vsol/vsol_line_2d.h>
12 #include <vsol/vsol_box_2d.h>
13 #include <vsol/vsol_curve_2d.h>
14 #include <vsol/vsol_digital_curve_2d.h>
15 #include <vsol/vsol_polygon_2d.h>
16 #include "vgl/vgl_box_2d.h"
17 #include "vgl/vgl_oriented_box_2d.h"
18 #include "vgui/vgui_dialog.h"
19 #include "vgui/vgui_style.h"
20 #include "vgui/vgui_viewer2D_tableau.h"
21 #include "vgui/vgui_shell_tableau.h"
22 #include "vgui/vgui_command.h"
23
24
get_popup(vgui_popup_params const & params,vgui_menu & menu)25 void bwm_tableau_img::get_popup(vgui_popup_params const ¶ms, vgui_menu &menu)
26 {
27 menu.clear();
28
29 bwm_popup_menu pop(this);
30 pop.get_menu(menu);
31 }
32
lock()33 void bwm_tableau_img::lock()
34 {
35 my_observer_->image_tableau()->lock_linenum(true);
36 my_observer_->lock_vgui_status(true);
37 }
38
unlock()39 void bwm_tableau_img::unlock()
40 {
41 my_observer_->lock_vgui_status(false);
42 if (!my_observer_->vgui_status_on())
43 my_observer_->image_tableau()->lock_linenum(false);
44 }
45
create_box()46 void bwm_tableau_img::create_box()
47 {
48 // first lock the bgui_image _tableau
49 this->lock();
50 set_color(1, 0, 0);
51 float x1, y1, x2, y2;
52 pick_box(&x1, &y1, &x2, &y2);
53 vsol_box_2d_sptr box2d = new vsol_box_2d();
54 box2d->add_point(x1, y1);
55 box2d->add_point(x2, y2);
56 this->unlock();
57 // add the box to the list
58 my_observer_->create_box(box2d);
59 }
60
create_polygon()61 void bwm_tableau_img::create_polygon()
62 {
63 // first lock the bgui_image _tableau
64 bwm_observer_mgr::instance()->stop_corr();
65 this->lock();
66 vsol_polygon_2d_sptr poly2d;
67 set_color(1, 0, 0);
68 pick_polygon(poly2d);
69 if (!poly2d)
70 {
71 std::cerr << "In bwm_tableau_img::create_polygon() - picking failed\n";
72 return;
73 }
74 this->unlock();
75
76 // add the polygon to the list
77 my_observer_->create_polygon(poly2d);
78 }
79
create_polyline()80 void bwm_tableau_img::create_polyline()
81 {
82 // first lock the bgui_image _tableau
83 this->lock();
84 bwm_observer_mgr::instance()->stop_corr();
85
86 vsol_polyline_2d_sptr poly2d;
87 set_color(1, 0, 0);
88 this->pick_polyline(poly2d);
89 if (!poly2d)
90 {
91 std::cerr << "In bwm_tableau_img::create_polyline() - picking failed\n";
92 return;
93 }
94
95 this->unlock();
96 // add the polygon to the list
97 my_observer_->create_polyline(poly2d);
98 }
99
create_point()100 void bwm_tableau_img::create_point()
101 {
102 float x, y;
103
104 set_color(1, 0, 0);
105 this->pick_point(&x, &y);
106 my_observer_->create_point(new vsol_point_2d(x, y));
107 }
108
create_pointset()109 void bwm_tableau_img::create_pointset()
110 {
111 std::vector<vsol_point_2d_sptr> pts;
112
113 bool picked = this->pick_point_set(pts, 1000);
114 if (!picked) return; // failed!
115
116 for (std::vector<vsol_point_2d_sptr>::iterator pit = pts.begin();
117 pit != pts.end(); ++pit)
118 my_observer_->create_point(*pit);
119 this->post_redraw();
120 }
121
create_vsol_spatial_object(vsol_spatial_object_2d_sptr sos)122 void bwm_tableau_img::create_vsol_spatial_object(vsol_spatial_object_2d_sptr sos)
123 {
124 if (sos->cast_to_point()) {
125 vsol_point_2d_sptr p = sos->cast_to_point();
126 my_observer_->create_point(p);
127 }
128 else if (sos->cast_to_curve())
129 {
130 if (sos->cast_to_curve()->cast_to_digital_curve())
131 {
132 //std::cerr << "bwm_observer does not have support to add digital curve!! skipping this object!\n";
133 // just for display purposes, maybe later actually "create" an interactive view (JLM)
134 vsol_digital_curve_2d_sptr dc = sos->cast_to_curve()->cast_to_digital_curve();
135 my_observer_->add_digital_curve(dc);
136 }
137 else if (sos->cast_to_curve()->cast_to_vdgl_digital_curve())
138 {
139 std::cerr << "bwm_observer does not have support to add vdgl digital curve!! skipping this object!\n";
140 }
141 else if (sos->cast_to_curve()->cast_to_line())
142 {
143 //vsol_line_2d_sptr line =
144 // sos->cast_to_curve()->cast_to_line();
145 std::cerr << "bwm_observer does not have support to add vsol_line_2d !! skipping this object!\n";
146 }
147 else if (sos->cast_to_curve()->cast_to_polyline())
148 {
149 vsol_polyline_2d_sptr pline =
150 sos->cast_to_curve()->cast_to_polyline();
151 my_observer_->create_polyline(pline);
152 }
153 else if (sos->cast_to_curve()->cast_to_conic())
154 {
155 //vsol_conic_2d_sptr conic = sos->cast_to_curve()->cast_to_conic();
156 // make sure the endpoints are already defined
157 //assert(conic->p0() && conic->p1());
158 //this->add_vsol_conic_2d(conic, style);
159 std::cerr << "bwm_observer does not have support to add vsol_conic_2d_sptr !! skipping this object!\n";
160 }
161 else
162 assert(!"unknown curve type in bgui_vsol2D_tableau::add_spatial_object()");
163 }
164 else if (sos->cast_to_region()) {
165 if (sos->cast_to_region()->cast_to_polygon())
166 {
167 vsol_polygon_2d_sptr pline =
168 sos->cast_to_region()->cast_to_polygon();
169 my_observer_->create_polygon(pline);
170 }
171 else
172 assert(!"unknown region type in bgui_vsol2D_tableau::add_spatial_object()");
173 }
174 else
175 assert(!"unknown spatial object type in bgui_vsol2D_tableau::add_spatial_object()");
176 return;
177
178 }
179
copy()180 void bwm_tableau_img::copy()
181 {
182 my_observer_->copy();
183 }
184
paste()185 void bwm_tableau_img::paste()
186 {
187 float x, y;
188 this->pick_point(&x, &y);
189 my_observer_->paste(x, y);
190 }
191
deselect_all()192 void bwm_tableau_img::deselect_all()
193 {
194 my_observer_->deselect_all();
195 }
196
clear_poly()197 void bwm_tableau_img::clear_poly()
198 {
199 my_observer_->delete_selected();
200 }
201
clear_box()202 void bwm_tableau_img::clear_box()
203 {
204 my_observer_->clear_box();
205 }
206
clear_all()207 void bwm_tableau_img::clear_all()
208 {
209 my_observer_->delete_all();
210 }
211
212 //if only an image tableau is loaded this will effectively
213 //be the same command. Only to be overridden when a video tableau is loaded.
clear_all_frames()214 void bwm_tableau_img::clear_all_frames()
215 {
216 my_observer_->delete_all();
217 }
218
intensity_profile()219 void bwm_tableau_img::intensity_profile()
220 {
221 float x1, y1, x2, y2;
222 this->lock();
223 pick_line(&x1, &y1, &x2, &y2);
224 std::cout << x1 << ',' << y1 << "-->" << x2 << ',' << y2 << std::endl;
225 my_observer_->intensity_profile(x1, y1, x2, y2);
226 this->unlock();
227 this->post_redraw();
228 }
229
range_map()230 void bwm_tableau_img::range_map()
231 {
232 my_observer_->range_map();
233 }
234
toggle_show_image_path()235 void bwm_tableau_img::toggle_show_image_path()
236 {
237 my_observer_->toggle_show_image_path();
238 }
239
zoom_to_fit()240 void bwm_tableau_img::zoom_to_fit()
241 {
242 my_observer_->zoom_to_fit();
243 }
244
scroll_to_point()245 void bwm_tableau_img::scroll_to_point()
246 {
247 my_observer_->scroll_to_point();
248 }
249
save_mask()250 void bwm_tableau_img::save_mask()
251 {
252 vil_image_view_base_sptr mask = my_observer_->mask();
253 if (!mask)
254 return;
255 vgui_dialog save_dlg("Save Mask");
256 std::string ext, file_path;
257 save_dlg.file("Mask Filename", ext, file_path);
258 if (!save_dlg.ask())
259 return;
260 if (file_path =="")
261 return;
262 bool result = vil_save(*mask,file_path.c_str());
263 if ( !result ) {
264 std::cerr << "Failed to save image to " << file_path << '\n';
265 }
266 }
267
save_spatial_objects_2d()268 void bwm_tableau_img::save_spatial_objects_2d()
269 {
270 std::vector<vsol_spatial_object_2d_sptr> sos =
271 my_observer_->get_spatial_objects_2d();
272 if (sos.size() == 0)
273 return;
274 vgui_dialog save_dlg("Save Spatial Objects 2d");
275 std::string ext, binary_filename;
276 save_dlg.file("Binary Filename", ext, binary_filename);
277 if (!save_dlg.ask())
278 return;
279 if (binary_filename == "")
280 return;
281 vsl_b_ofstream ostr(binary_filename);
282 if (!ostr) {
283 std::cerr << "Failed to open output stream "
284 << binary_filename << std::endl;
285 return;
286 }
287 vsl_b_write(ostr, sos);
288 }
load_spatial_objects_2d()289 void bwm_tableau_img::load_spatial_objects_2d(){
290 vgui_dialog save_dlg("Load Spatial Objects 2d");
291 std::string ext, binary_filename;
292 save_dlg.file("Binary Filename", ext, binary_filename);
293 if (!save_dlg.ask())
294 return;
295 if (binary_filename == "")
296 return;
297 vsl_b_ifstream istr(binary_filename);
298 if (!istr) {
299 std::cerr << "Failed to open inputt stream "
300 << binary_filename << std::endl;
301 return;
302 }
303 std::vector<vsol_spatial_object_2d_sptr> sos;
304 vsl_b_read(istr, sos);
305 //my_observer_->add_spatial_objects(sos);
306 for (unsigned i = 0; i < sos.size(); i++)
307 this->create_vsol_spatial_object(sos[i]);
308 my_observer_->post_redraw();
309 }
310
save_lines_vgl_ascii()311 void bwm_tableau_img::save_lines_vgl_ascii(){
312 std::vector<vsol_spatial_object_2d_sptr> sos =
313 my_observer_->get_spatial_objects_2d();
314 if (sos.size() == 0)
315 return;
316 std::vector<vsol_line_2d*> lines;
317 for (unsigned i=0; i<sos.size(); ++i) {
318 vsol_spatial_object_2d_sptr so = sos[i];
319 if(!so)
320 continue;
321 vsol_curve_2d * curve = so->cast_to_curve();
322 if(!curve)
323 continue;
324 vsol_line_2d* line = curve->cast_to_line();
325 if (line)
326 lines.push_back(line);
327 }
328 vgui_dialog save_dlg("Save 2d lines as vgl");
329 std::string ext, line_filename;
330 save_dlg.file("Line Filename", ext, line_filename);
331 if (!save_dlg.ask())
332 return;
333 std::ofstream os(line_filename.c_str());
334 if (os.is_open()) {
335 os << lines.size()<< '\n';
336 for (unsigned i=0; i<lines.size(); ++i){
337 vgl_point_2d<double> p0(lines[i]->p0()->x(), lines[i]->p0()->y()), p1(lines[i]->p1()->x(), lines[i]->p1()->y());
338 vgl_line_segment_2d<double> seg(p0, p1);
339 os << seg << '\n';
340 }
341 os.close();
342 }
343 }
344
load_lines_vgl_ascii()345 void bwm_tableau_img::load_lines_vgl_ascii(){
346 // the style toggling is just to
347 // allow comparison of two or three point sets
348 static float r = 0.0;
349 if(r == 1.5f)
350 r = 0.0f;
351 vgui_style_sptr sty = vgui_style::new_style( r, 1.0f, 0.0f, 3.0, 2.0);
352
353 vgui_dialog load_dlg("Load 2d vgl lines ");
354 std::string ext, pt_filename;
355 load_dlg.file("Line Filename", ext, pt_filename);
356 if (!load_dlg.ask())
357 return;
358 std::ifstream istr(pt_filename.c_str());
359 if (istr.is_open()) {
360 unsigned n;
361 istr >> n; //number of lines
362 for(unsigned i = 0; i<n; ++i){
363 vgl_line_segment_2d<double> gline;
364 istr >> gline;
365 vgl_point_2d<double> gp0 = gline.point1(), gp1 = gline.point2();
366 vsol_point_2d_sptr p0 = new vsol_point_2d(gp0);
367 vsol_point_2d_sptr p1 = new vsol_point_2d(gp1);
368 vsol_line_2d_sptr line = new vsol_line_2d(p0, p1);
369 bgui_vsol_soview2D* soview = my_observer_->add_vsol_line_2d(line, sty);
370 my_observer_->add_obj(soview);
371 }
372 my_observer_->post_redraw();
373 istr.close();
374 }
375 r = r+0.5f;
376 }
save_pointset_2d_ascii()377 void bwm_tableau_img::save_pointset_2d_ascii()
378 {
379 std::vector<vsol_spatial_object_2d_sptr> sos =
380 my_observer_->get_spatial_objects_2d();
381 if (sos.size() == 0)
382 return;
383 std::vector<vsol_point_2d_sptr> pts;
384 for (unsigned i=0; i<sos.size(); ++i) {
385 vsol_spatial_object_2d_sptr so = sos[i];
386 vsol_point_2d_sptr pt = so->cast_to_point();
387 if (pt)
388 pts.push_back(pt);
389 }
390 vgui_dialog save_dlg("Save Pointset");
391 std::string ext, pt_filename;
392 save_dlg.file("Point Filename", ext, pt_filename);
393 if (!save_dlg.ask())
394 return;
395 std::ofstream os(pt_filename.c_str());
396 if (os.is_open()) {
397 os << pts.size()<< '\n';
398 for (unsigned i=0; i<pts.size(); ++i)
399 os << pts[i]->x() << ' ' << pts[i]->y() << '\n';
400 os.close();
401 }
402 }
load_pointset_2d_ascii()403 void bwm_tableau_img::load_pointset_2d_ascii()
404 {
405 // the style toggling is just to
406 // allow comparison of two or three point sets
407 static float r = 0.0;
408 if(r == 1.5f)
409 r = 0.0f;
410 vgui_style_sptr sty = vgui_style::new_style( r, 1.0f, 0.0f, 3.0, 2.0);
411
412 vgui_dialog load_dlg("Load Pointset");
413 std::string ext, pt_filename;
414 load_dlg.file("Point Filename", ext, pt_filename);
415 if (!load_dlg.ask())
416 return;
417 std::ifstream istr(pt_filename.c_str());
418 if (istr.is_open()) {
419 unsigned n;
420 istr >> n; //number of pts
421 double x, y;
422 for(unsigned i = 0; i<n; ++i){
423 istr >> x >> y;
424 vsol_point_2d_sptr pt = new vsol_point_2d(x, y);
425 my_observer_->add_vsol_point_2d(pt, sty);
426 }
427 istr.close();
428 }
429 r = r+0.5f;
430 }
print_selected_line()431 void bwm_tableau_img::print_selected_line(){
432 my_observer_->print_selected_line();
433 }
434
load_bounding_boxes_2d_ascii()435 void bwm_tableau_img::load_bounding_boxes_2d_ascii()
436 {
437 // the style toggling is just to
438 // allow comparison of two or three oriented boxes
439 static float r = 0.0;
440 if(r == 1.5f)
441 r = 0.0f;
442 vgui_style_sptr sty = vgui_style::new_style( r, 1.0f, 0.0f, 3.0, 2.0);
443
444 vgui_dialog load_dlg("Load Axis-aligned Boxes");
445 std::string ext, pt_filename;
446 load_dlg.file("bbox Filename", ext, pt_filename);
447 if (!load_dlg.ask())
448 return;
449 std::ifstream istr(pt_filename.c_str());
450 if(!istr.is_open()){
451 std::cout << "Failed to open " << pt_filename << std::endl;
452 return;
453 }
454 while(!istr.eof()){
455 vgl_box_2d<double> bbox;
456 bbox.read(istr);
457 if(istr.eof())
458 continue;
459 if(bbox.is_empty())
460 continue;
461 vgl_point_2d<double> pmin = bbox.min_point();
462 vgl_point_2d<double> pmax = bbox.max_point();
463 std::vector<vsol_point_2d_sptr> verts;
464 verts.push_back(new vsol_point_2d(pmin.x(), pmin.y()));
465 verts.push_back(new vsol_point_2d(pmax.x(), pmin.y()));
466 verts.push_back(new vsol_point_2d(pmax.x(), pmax.y()));
467 verts.push_back(new vsol_point_2d(pmin.x(), pmax.y()));
468 vsol_polygon_2d_sptr poly = new vsol_polygon_2d(verts);
469 my_observer_->add_vsol_polygon_2d(poly, sty);
470 }
471 istr.close();
472 r = r+0.5f;
473 }
load_oriented_boxes_2d_ascii()474 void bwm_tableau_img::load_oriented_boxes_2d_ascii()
475 {
476 // the style toggling is just to
477 // allow comparison of two or three oriented boxes
478 static float r = 0.0;
479 if(r == 1.5f)
480 r = 0.0f;
481 vgui_style_sptr sty = vgui_style::new_style( r, 1.0f, 0.0f, 3.0, 2.0);
482
483 vgui_dialog load_dlg("Load Oriented Boxes");
484 std::string ext, pt_filename;
485 load_dlg.file("Obox Filename", ext, pt_filename);
486 if (!load_dlg.ask())
487 return;
488 std::ifstream istr(pt_filename.c_str());
489 if(!istr.is_open()){
490 std::cout << "Failed to open " << pt_filename << std::endl;
491 return;
492 }
493 while(!istr.eof()){
494 vgl_oriented_box_2d<float> obox;
495 istr >> obox;
496 if(istr.eof())
497 continue;
498 std::vector<vgl_point_2d<float> > corns = obox.corners();
499 if(!corns.size())
500 continue;
501 std::vector<vsol_point_2d_sptr> verts;
502 for(std::vector<vgl_point_2d<float> >::iterator cit = corns.begin();
503 cit != corns.end(); ++cit){
504 verts.push_back(new vsol_point_2d(cit->x(), cit->y()));
505 }
506 vsol_polygon_2d_sptr poly = new vsol_polygon_2d(verts);
507 my_observer_->add_vsol_polygon_2d(poly, sty);
508 }
509 istr.close();
510 r = r+0.5f;
511 }
help_pop()512 void bwm_tableau_img::help_pop()
513 {
514 bwm_tableau_text* text = new bwm_tableau_text(500, 500);
515
516 text->set_text("C:/lems/lemsvxlsrc/contrib/bwm/doc/HELP_cam.txt");
517 vgui_tableau_sptr v = vgui_viewer2D_tableau_new(text);
518 vgui_tableau_sptr s = vgui_shell_tableau_new(v);
519 vgui_dialog popup("CAMERA TABLEAU HELP");
520 popup.inline_tableau(s, 550, 550);
521 if (!popup.ask())
522 return;
523 }
524
step_edges_vd()525 void bwm_tableau_img::step_edges_vd()
526 {
527 my_observer_->step_edges_vd();
528 }
529
lines_vd()530 void bwm_tableau_img::lines_vd()
531 {
532 my_observer_->lines_vd();
533 }
534
recover_edges()535 void bwm_tableau_img::recover_edges()
536 {
537 my_observer_->recover_edges();
538 }
539
recover_lines()540 void bwm_tableau_img::recover_lines()
541 {
542 my_observer_->recover_lines();
543 }
544
crop_image()545 void bwm_tableau_img::crop_image()
546 {
547 vgui_dialog crop_dlg("Crop Image Path");
548 std::string ext = "tiff";
549 std::string filename;
550 crop_dlg.file("Point Filename", ext, filename);
551 if (!crop_dlg.ask())
552 return;
553 vil_image_resource_sptr chip;
554 if (!my_observer_->crop_image(chip))
555 return;
556 vil_save_image_resource(chip, filename.c_str());
557 }
558
handle(const vgui_event & e)559 bool bwm_tableau_img::handle(const vgui_event& e)
560 {
561 return bgui_picker_tableau::handle(e);
562 }
563
init_mask()564 void bwm_tableau_img::init_mask()
565 {
566 my_observer_->init_mask();
567 }
568
add_poly_to_mask()569 void bwm_tableau_img::add_poly_to_mask()
570 {
571 my_observer_->add_poly_to_mask();
572 }
573
574 #if 0
575 void bwm_tableau_img::add_dontcare_poly_to_mask()
576 {
577 my_observer_->add_dontcare_poly_to_mask();
578 }
579 #endif
580
remove_poly_from_mask()581 void bwm_tableau_img::remove_poly_from_mask()
582 {
583 my_observer_->remove_poly_from_mask();
584 }
585
586 #if 0
587 void bwm_tableau_img::create_mask()
588 {
589 my_observer_->create_mask();
590 }
591 #endif
592