Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 2 // See the file tools.license for terms. 3 4 #ifndef tools_sg_plotter 5 #define tools_sg_plotter 6 7 #include "../lina/vec2f" 8 9 #include "render_action" 10 #include "plottables" 11 #include "style" 12 #include "rep" 13 #include "colormap" 14 #include "noderef" 15 #include "atb_vertices" 16 #include "cube" //for lego 17 #include "matrix" 18 #include "normal" 19 #include "holder" 20 #include "tex_rect" //for plottable_img. 21 22 #include "axis" 23 #include "infos_box" 24 #include "legend" 25 #include "text" 26 #include "torche" 27 #include "ellipse" 28 29 #include "../data_axis" 30 #include "../hatcher" 31 #include "../clist_contour" 32 #include "../tess_contour" 33 #include "../lina/geom3" 34 #include "../spline" 35 #include "../rtausmef" 36 37 //#define INLIBS_SG_PLOTTER_TIMING 38 #ifdef INLIBS_SG_PLOTTER_TIMING 39 #include "../sys/atime" 40 #endif 41 42 #include <utility> 43 44 namespace tools { 45 namespace sg { 46 47 class plotter : public node { 48 TOOLS_NODE(plotter,tools::sg::plotter,node) 49 private: 50 static const std::string& s_infos_what_def() 51 static const std::string s_v("name entries 52 return s_v; 53 } 54 static float default_infos_margin() {return 55 static float default_title_box_width() {r 56 static float default_title_box_height() {r 57 static float default_title_box_x_margin() {r 58 static float default_title_box_y_margin() {r 59 public: 60 sf<float> width; //PAW XSIZ 61 sf<float> height; //PAW YSIZ 62 sf<float> left_margin; //PAW XMGL 63 sf<float> right_margin; //PAW XMGR 64 sf<float> bottom_margin; //PAW YMGL 65 sf<float> top_margin; //PAW YMGU 66 67 sf<float> depth; 68 sf<float> down_margin; 69 sf<float> up_margin; 70 71 sf<bool> title_up; 72 sf<float> title_to_axis; 73 sf<float> title_height; 74 sf<bool> title_automated; 75 sf_enum<hjust> title_hjust; 76 sf_string title; //output if title_automated 77 78 sf<bool> colormap_visible; 79 enum colormap_axis_labeling_type { 80 cells = 0, 81 min_max 82 }; 83 sf_enum<colormap_axis_labeling_type> colorma 84 sf<bool> colormap_attached; 85 sf<bool> colormap_axis_visible; 86 87 // Wanted axes parameters. 88 // They are not necessary realized on the sg 89 sf<bool> x_axis_enforced; 90 sf<bool> x_axis_automated; 91 sf<float> x_axis_min; 92 sf<float> x_axis_max; 93 sf<bool> x_axis_is_log; 94 95 sf<bool> y_axis_enforced; 96 sf<bool> y_axis_automated; 97 sf<float> y_axis_min; 98 sf<float> y_axis_max; 99 sf<bool> y_axis_is_log; 100 101 sf<bool> z_axis_enforced; 102 sf<bool> z_axis_automated; 103 sf<float> z_axis_min; 104 sf<float> z_axis_max; 105 sf<bool> z_axis_is_log; 106 107 sf<float> value_top_margin; 108 sf<float> value_bottom_margin; 109 sf<bool> value_bins_with_entries; 110 111 sf<float> infos_width; //in percent of width 112 sf<float> infos_x_margin; //in percent of wi 113 sf<float> infos_y_margin; //in percent of he 114 sf_string infos_what; 115 116 sf<float> title_box_width; //in percent o 117 sf<float> title_box_height; //in percent o 118 sf<float> title_box_x_margin; //in percent o 119 sf<float> title_box_y_margin; //in percent o 120 121 sf<bool> func2D_borders_visible; 122 123 // used with shape xyz 124 sf<float> theta; //in degrees. 125 sf<float> phi; //in degrees. 126 sf<float> tau; //in degrees. 127 128 //////////////////////////////////////////// 129 /// legend related ://////////////////////// 130 //////////////////////////////////////////// 131 sf<bool> legends_automated; 132 //sf<bool> legends_attached_to_infos; 133 //if legends_attached_to_infos is false : 134 // legends_origin is used to place the lege 135 // the lower left corner of the box contain 136 mf_vec<vec2f,float> legends_origin; //common 137 enum unit_type { 138 unit_percent, 139 unit_axis 140 }; 141 mf_enum<unit_type> legends_origin_unit; 142 mf_vec<vec2f,float> legends_size; //overall 143 mf_string legends_string; 144 145 //////////////////////////////////////////// 146 //////////////////////////////////////////// 147 //////////////////////////////////////////// 148 149 sf<bool> shape_automated; 150 151 enum shape_type { 152 xy = 0, 153 xyz 154 }; 155 sf_enum<shape_type> shape; 156 157 // used with xy shape : 158 sf<float> xy_depth; //all is in z [0,xy_dept 159 160 sf<unsigned int> curve_number_of_points; 161 162 sf<bool> data_light_on_automated; 163 164 // for gopaw : 165 sf<bool> primitives_enforced; 166 sf<bool> inner_frame_enforced; 167 // to be implemented : 168 sf<bool> top_axis_visible; 169 sf<bool> right_axis_visible; 170 sf<bool> superpose_bins; 171 //sf<bool> grid_visible; 172 // For contours : 173 sf<unsigned int> number_of_levels; 174 mf<float> levels; 175 //sf<bool> frozen; 176 //sf<float> ttfScale; 177 //sf<bool> wallEnforced; 178 //sf<bool> gridEnforced; 179 //SoMFString infos; //Output 180 //SoMFString legend; //Output 181 182 public: 183 virtual const desc_fields& node_desc_fields( 184 TOOLS_FIELD_DESC_NODE_CLASS(tools::sg::plo 185 static const desc_fields s_v(parent::node_ 186 187 TOOLS_ARG_FIELD_DESC(width), 188 TOOLS_ARG_FIELD_DESC(height), 189 TOOLS_ARG_FIELD_DESC(left_margin), 190 TOOLS_ARG_FIELD_DESC(right_margin), 191 TOOLS_ARG_FIELD_DESC(bottom_margin), 192 TOOLS_ARG_FIELD_DESC(top_margin), 193 TOOLS_ARG_FIELD_DESC(depth), 194 TOOLS_ARG_FIELD_DESC(down_margin), 195 TOOLS_ARG_FIELD_DESC(up_margin), 196 TOOLS_ARG_FIELD_DESC(colormap_visible), 197 198 TOOLS_ARG_FIELD_DESC_ENUMS_BEG(colormap_ 199 TOOLS_ARG_ENUM(cells), 200 TOOLS_ARG_ENUM(min_max) 201 TOOLS_ARG_FIELD_DESC_ENUMS_END, 202 203 TOOLS_ARG_FIELD_DESC(colormap_attached), 204 TOOLS_ARG_FIELD_DESC(colormap_axis_visib 205 206 TOOLS_ARG_FIELD_DESC(title_up), 207 TOOLS_ARG_FIELD_DESC(title_to_axis), 208 TOOLS_ARG_FIELD_DESC(title_height), 209 TOOLS_ARG_FIELD_DESC(title_automated), 210 211 TOOLS_ARG_FIELD_DESC_ENUMS_BEG(title_hju 212 "left",left, 213 "center",center, 214 "right",right 215 TOOLS_ARG_FIELD_DESC_ENUMS_END, 216 217 TOOLS_ARG_FIELD_DESC(title), 218 219 TOOLS_ARG_FIELD_DESC(x_axis_enforced), 220 TOOLS_ARG_FIELD_DESC(x_axis_automated), 221 TOOLS_ARG_FIELD_DESC(x_axis_min), 222 TOOLS_ARG_FIELD_DESC(x_axis_max), 223 TOOLS_ARG_FIELD_DESC(x_axis_is_log), 224 225 TOOLS_ARG_FIELD_DESC(y_axis_enforced), 226 TOOLS_ARG_FIELD_DESC(y_axis_automated), 227 TOOLS_ARG_FIELD_DESC(y_axis_min), 228 TOOLS_ARG_FIELD_DESC(y_axis_max), 229 TOOLS_ARG_FIELD_DESC(y_axis_is_log), 230 231 TOOLS_ARG_FIELD_DESC(z_axis_enforced), 232 TOOLS_ARG_FIELD_DESC(z_axis_automated), 233 TOOLS_ARG_FIELD_DESC(z_axis_min), 234 TOOLS_ARG_FIELD_DESC(z_axis_max), 235 TOOLS_ARG_FIELD_DESC(z_axis_is_log), 236 237 TOOLS_ARG_FIELD_DESC(value_top_margin), 238 TOOLS_ARG_FIELD_DESC(value_bottom_margin 239 TOOLS_ARG_FIELD_DESC(value_bins_with_ent 240 241 TOOLS_ARG_FIELD_DESC(infos_width), 242 TOOLS_ARG_FIELD_DESC(infos_x_margin), 243 TOOLS_ARG_FIELD_DESC(infos_y_margin), // 244 TOOLS_ARG_FIELD_DESC(infos_what), 245 246 TOOLS_ARG_FIELD_DESC(func2D_borders_visi 247 TOOLS_ARG_FIELD_DESC(theta), 248 TOOLS_ARG_FIELD_DESC(phi), 249 TOOLS_ARG_FIELD_DESC(tau), 250 251 TOOLS_ARG_FIELD_DESC(legends_automated), 252 253 TOOLS_ARG_FIELD_DESC_ENUMS_BEG(legends_o 254 "unit_percent",unit_percent, 255 "unit_axis",unit_axis 256 TOOLS_ARG_FIELD_DESC_ENUMS_END, 257 258 TOOLS_ARG_FIELD_DESC(legends_origin_unit 259 TOOLS_ARG_FIELD_DESC(legends_size), 260 TOOLS_ARG_FIELD_DESC(legends_string), // 261 262 TOOLS_ARG_FIELD_DESC(shape_automated), 263 264 TOOLS_ARG_FIELD_DESC_ENUMS_BEG(shape,2) 265 "xy",xy, 266 "xyz",xyz 267 TOOLS_ARG_FIELD_DESC_ENUMS_END, 268 269 TOOLS_ARG_FIELD_DESC(xy_depth), 270 TOOLS_ARG_FIELD_DESC(curve_number_of_poi 271 272 TOOLS_ARG_FIELD_DESC(number_of_levels), 273 TOOLS_ARG_FIELD_DESC(levels), 274 275 TOOLS_ARG_FIELD_DESC(data_light_on_autom 276 277 TOOLS_ARG_FIELD_DESC(primitives_enforced 278 TOOLS_ARG_FIELD_DESC(inner_frame_enforce 279 280 TOOLS_ARG_FIELD_DESC(title_box_width), / 281 TOOLS_ARG_FIELD_DESC(title_box_height), 282 TOOLS_ARG_FIELD_DESC(title_box_x_margin) 283 TOOLS_ARG_FIELD_DESC(title_box_y_margin) 284 285 ); 286 return s_v; 287 } 288 virtual bool touched() { 289 if(parent::touched()) return true; 290 291 if(background_style().touched()) return tr 292 if(title_style().touched()) return true; 293 if(infos_style().touched()) return true; 294 if(title_box_style().touched()) return tru 295 if(inner_frame_style().touched()) return t 296 if(grid_style().touched()) return true; 297 if(wall_style().touched()) return true; 298 299 {tools_vforit(style,m_bins_style,it) {if((* 300 {tools_vforit(style,m_errors_style,it) {if( 301 {tools_vforit(style,m_func_style,it) {if((* 302 {tools_vforit(style,m_points_style,it) {if( 303 {tools_vforit(style,m_left_hatch_style,it) 304 {tools_vforit(style,m_right_hatch_style,it) 305 {tools_vforit(style,m_legend_style,it) {if( 306 307 return false; 308 } 309 virtual void reset_touched() { 310 parent::reset_touched(); 311 312 background_style().reset_touched(); 313 title_style().reset_touched(); 314 infos_style().reset_touched(); 315 title_box_style().reset_touched(); 316 inner_frame_style().reset_touched(); 317 grid_style().reset_touched(); 318 wall_style().reset_touched(); 319 320 {tools_vforit(style,m_bins_style,it) (*it). 321 {tools_vforit(style,m_errors_style,it) (*it 322 {tools_vforit(style,m_func_style,it) (*it). 323 {tools_vforit(style,m_points_style,it) (*it 324 {tools_vforit(style,m_left_hatch_style,it) 325 {tools_vforit(style,m_right_hatch_style,it) 326 {tools_vforit(style,m_legend_style,it) (*it 327 } 328 329 private: 330 void add_fields(){ 331 // if adding a field, look for reset_style 332 add_field(&width); 333 add_field(&height); 334 add_field(&left_margin); 335 add_field(&right_margin); 336 add_field(&bottom_margin); 337 add_field(&top_margin); 338 add_field(&depth); 339 add_field(&down_margin); 340 add_field(&up_margin); 341 342 add_field(&title_up); 343 add_field(&title_to_axis); 344 add_field(&title_height); 345 add_field(&title_automated); 346 add_field(&title_hjust); 347 add_field(&title); 348 349 add_field(&x_axis_enforced); 350 add_field(&x_axis_automated); 351 add_field(&x_axis_min); 352 add_field(&x_axis_max); 353 add_field(&x_axis_is_log); 354 355 add_field(&y_axis_enforced); 356 add_field(&y_axis_automated); 357 add_field(&y_axis_min); 358 add_field(&y_axis_max); 359 add_field(&y_axis_is_log); 360 361 add_field(&z_axis_enforced); 362 add_field(&z_axis_automated); 363 add_field(&z_axis_min); 364 add_field(&z_axis_max); 365 add_field(&z_axis_is_log); 366 367 add_field(&value_top_margin); 368 add_field(&value_bottom_margin); 369 add_field(&value_bins_with_entries); 370 371 add_field(&infos_width); 372 add_field(&infos_x_margin); 373 add_field(&infos_y_margin); 374 add_field(&infos_what); 375 376 add_field(&title_box_width); 377 add_field(&title_box_height); 378 add_field(&title_box_x_margin); 379 add_field(&title_box_y_margin); 380 381 add_field(&func2D_borders_visible); 382 add_field(&theta); 383 add_field(&phi); 384 add_field(&tau); 385 386 add_field(&legends_automated); 387 //add_field(&legends_attached_to_infos); 388 add_field(&legends_origin); 389 add_field(&legends_origin_unit); 390 add_field(&legends_size); 391 add_field(&legends_string); 392 393 add_field(&shape_automated); 394 add_field(&shape); 395 396 add_field(&xy_depth); 397 add_field(&curve_number_of_points); 398 add_field(&number_of_levels); 399 add_field(&levels); 400 add_field(&data_light_on_automated); 401 add_field(&primitives_enforced); 402 add_field(&inner_frame_enforced); 403 } 404 public: //style 405 void copy_style(const plotter& a_from) { // 406 ////////////////////////////////////////// 407 ////////////////////////////////////////// 408 ////////////////////////////////////////// 409 shape_automated = a_from.shape_automated; 410 shape = a_from.shape; 411 xy_depth = a_from.xy_depth; 412 curve_number_of_points = a_from.curve_numb 413 value_top_margin = a_from.value_top_margin 414 value_bottom_margin = a_from.value_bottom_ 415 value_bins_with_entries = a_from.value_bin 416 infos_what = a_from.infos_what; 417 infos_width = a_from.infos_width; 418 //infos height is automatic. 419 infos_x_margin = a_from.infos_x_margin; 420 infos_y_margin = a_from.infos_y_margin; 421 422 title_box_width = a_from.title_box_width; 423 title_box_height = a_from.title_box_height 424 title_box_x_margin = a_from.title_box_x_ma 425 title_box_y_margin = a_from.title_box_y_ma 426 427 legends_automated = a_from.legends_automat 428 title_automated = a_from.title_automated; 429 title = a_from.title; 430 title_up = a_from.title_up; 431 title_hjust = a_from.title_hjust; 432 433 colormap_visible = a_from.colormap_visible 434 colormap_axis_labeling = a_from.colormap_a 435 colormap_attached = a_from.colormap_attach 436 colormap_axis_visible = a_from.colormap_ax 437 438 number_of_levels = a_from.number_of_levels 439 levels = a_from.levels; 440 data_light_on_automated = a_from.data_ligh 441 primitives_enforced = a_from.primitives_en 442 inner_frame_enforced = a_from.inner_frame_ 443 444 ////////////////////////////////////////// 445 ////////////////////////////////////////// 446 ////////////////////////////////////////// 447 x_axis_enforced = a_from.x_axis_enforced; 448 x_axis_automated = a_from.x_axis_automated 449 x_axis_min = a_from.x_axis_min; 450 x_axis_max = a_from.x_axis_max; 451 x_axis_is_log = a_from.x_axis_is_log; 452 453 y_axis_enforced = a_from.y_axis_enforced; 454 y_axis_automated = a_from.y_axis_automated 455 y_axis_min = a_from.y_axis_min; 456 y_axis_max = a_from.y_axis_max; 457 y_axis_is_log = a_from.y_axis_is_log; 458 459 z_axis_enforced = a_from.z_axis_enforced; 460 z_axis_automated = a_from.z_axis_automated 461 z_axis_min = a_from.z_axis_min; 462 z_axis_max = a_from.z_axis_max; 463 z_axis_is_log = a_from.z_axis_is_log; 464 465 /* 466 m_x_axis = a_from.m_x_axis; 467 m_y_axis = a_from.m_y_axis; 468 m_z_axis = a_from.m_z_axis; 469 m_cmap_axis = a_from.m_cmap_axis; 470 471 */ 472 ////////////////////////////////////////// 473 ////////////////////////////////////////// 474 ////////////////////////////////////////// 475 476 m_background_style = a_from.m_background_s 477 m_title_style = a_from.m_title_style; 478 m_infos_style = a_from.m_infos_style; 479 m_title_box_style = a_from.m_title_box_sty 480 m_inner_frame_style = a_from.m_inner_frame 481 m_grid_style = a_from.m_grid_style; 482 m_wall_style = a_from.m_wall_style; 483 484 m_bins_style = a_from.m_bins_style; 485 m_errors_style = a_from.m_errors_style; 486 m_func_style = a_from.m_func_style; 487 m_points_style = a_from.m_points_style; 488 m_left_hatch_style = a_from.m_left_hatch_s 489 m_right_hatch_style = a_from.m_right_hatch 490 m_legend_style = a_from.m_legend_style; 491 } 492 493 void reset_style(bool a_geom = false) { 494 //reset fields that are considered as part 495 496 //::printf("debug : tools::sg::plotter::re 497 498 shape_automated = true; 499 shape = xy; 500 501 xy_depth = 0.01f; 502 curve_number_of_points = 100; 503 ////////////////////////////////////////// 504 value_top_margin = 0.1f; //percent. // CE 505 value_bottom_margin = 0.0f; //percent. 506 value_bins_with_entries = true; //gopaw us 507 508 infos_what = s_infos_what_def(); 509 infos_width = 0.3f; 510 //infos height is automatic. 511 infos_x_margin = default_infos_margin(); / 512 infos_y_margin = default_infos_margin(); / 513 514 title_box_width = default_title_box_width( 515 title_box_height = default_title_box_heigh 516 title_box_x_margin = default_title_box_x_m 517 title_box_y_margin = default_title_box_y_m 518 519 legends_automated = true; 520 521 ////////////////////////////////////////// 522 523 if(a_geom) { 524 float xfac = 1.0F/20.0F; //0.05 525 float yfac = 1.0F/20.0F; //0.05 526 527 // Take PAW defaults : 528 float XSIZ = 20 * xfac; //1 //page 529 float YSIZ = 20 * yfac; //1 //page 530 float XMGL = 2 * xfac; //0.1 //left 531 float XMGR = 2 * xfac; //0.1 //right 532 float YMGL = 2 * yfac; //0.1 //low y 533 float YMGU = 2 * yfac; //0.1 //up y 534 // Axes : 535 float VSIZ = 0.28F * yfac; //0.014 //tick 536 float XVAL = 0.4F * xfac; //0.02 //x dist 537 float YVAL = 0.4F * yfac; //0.02 //y dist 538 float XTIC = 0.3F * yfac; //0.015 //y len 539 float YTIC = 0.3F * xfac; //0.015 //x len 540 float XLAB = 1.4F * xfac; //0.07 //x dis 541 float YLAB = 0.8F * yfac; //0.04 //y dis 542 float ASIZ = 0.28F * yfac; //0.014 // axis 543 544 float YHTI = 1.2F * yfac; //0.06 //y dis 545 float TSIZ = 0.28F * yfac; //0.014 //title 546 547 float zfac = 1.0F/20.0F; //0.05 548 float ZSIZ = 20 * zfac; //1 //page 549 float ZMGD = 2 * zfac; //0.1 //low y 550 float ZMGU = 2 * zfac; //0.1 //up y 551 552 // Data area : 553 //float wData = XSIZ-XMGL-XMGR; 554 //float hData = YSIZ-YMGL-YMGU; 555 //float dData = ZSIZ-ZMGD-ZMGU; 556 557 width = XSIZ; 558 height = YSIZ; 559 depth = ZSIZ; 560 561 left_margin = XMGL; 562 right_margin = XMGR; 563 bottom_margin = YMGL; 564 top_margin = YMGU; 565 down_margin = ZMGD; 566 up_margin = ZMGU; 567 568 title_to_axis = YHTI; 569 title_height = TSIZ; 570 571 if(shape.value()==xy) { 572 m_x_axis.tick_length.value(XTIC); 573 m_x_axis.label_to_axis.value(YVAL); 574 m_x_axis.label_height.value(VSIZ); 575 m_x_axis.title_to_axis.value(YLAB); 576 m_x_axis.title_height.value(ASIZ); 577 578 m_y_axis.tick_length.value(YTIC); 579 m_y_axis.label_to_axis.value(XVAL); 580 m_y_axis.label_height.value(VSIZ); 581 m_y_axis.title_to_axis.value(XLAB); 582 m_y_axis.title_height.value(ASIZ); 583 584 //set anyway z axis : 585 //m_z_axis.tick_length.value(YTIC); 586 //m_z_axis.label_to_axis.value(XVAL); 587 //m_z_axis.label_height.value(VSIZ); 588 //m_z_axis.title_to_axis.value(XLAB); 589 //m_z_axis.title_height.value(ASIZ); 590 591 m_cmap_axis.tick_length.value(YTIC); 592 m_cmap_axis.label_to_axis.value(XVAL); 593 m_cmap_axis.label_height.value(VSIZ); 594 m_cmap_axis.title_to_axis.value(XLAB); 595 m_cmap_axis.title_height.value(ASIZ); 596 597 } else { //xyz 598 m_x_axis.tick_length.value(XTIC); 599 m_x_axis.label_to_axis.value(YVAL); 600 m_x_axis.label_height.value(VSIZ); 601 m_x_axis.title_to_axis.value(YLAB); 602 m_x_axis.title_height.value(ASIZ); 603 604 m_y_axis.tick_length.value(XTIC); 605 m_y_axis.label_to_axis.value(YVAL); 606 m_y_axis.label_height.value(VSIZ); 607 m_y_axis.title_to_axis.value(YLAB); 608 m_y_axis.title_height.value(ASIZ); 609 610 m_z_axis.tick_length.value(YTIC); 611 m_z_axis.label_to_axis.value(XVAL); 612 m_z_axis.label_height.value(VSIZ); 613 m_z_axis.title_to_axis.value(XLAB); 614 m_z_axis.title_height.value(ASIZ); 615 616 m_cmap_axis.tick_length.value(XTIC); 617 m_cmap_axis.label_to_axis.value(YVAL); 618 m_cmap_axis.label_height.value(VSIZ); 619 m_cmap_axis.title_to_axis.value(YLAB); 620 m_cmap_axis.title_height.value(ASIZ); 621 622 } 623 624 } 625 626 title_automated = true; 627 title.value().clear(); 628 title_up = true; 629 title_hjust = center; 630 631 ////////////////////////////////////////// 632 colormap_visible = true; 633 colormap_axis_labeling = cells; 634 colormap_attached = true; 635 colormap_axis_visible = true; 636 637 ////////////////////////////////////////// 638 x_axis_enforced = false; 639 x_axis_automated = true; 640 x_axis_min = 0; 641 x_axis_max = 1; 642 x_axis_is_log = false; 643 644 y_axis_enforced = false; 645 y_axis_automated = true; 646 y_axis_min = 0; 647 y_axis_max = 1; 648 y_axis_is_log = false; 649 650 z_axis_enforced = false; 651 z_axis_automated = true; 652 z_axis_min = 0; 653 z_axis_max = 1; 654 z_axis_is_log = false; 655 656 m_x_axis.reset_style(); 657 m_y_axis.reset_style(); 658 m_z_axis.reset_style(); 659 660 ////////////////////////////////////////// 661 ////////////////////////////////////////// 662 ////////////////////////////////////////// 663 number_of_levels = 10; 664 levels.clear(); 665 data_light_on_automated = true; 666 primitives_enforced = false; 667 inner_frame_enforced = false; 668 669 ////////////////////////////////////////// 670 // setup styles : 671 ////////////////////////////////////////// 672 673 m_title_style = text_style(); 674 m_infos_style = text_style(); 675 m_title_box_style = text_style(); 676 m_background_style = style(); 677 m_wall_style = style(); 678 m_inner_frame_style = style(); 679 m_grid_style = style(); 680 681 m_title_style.color = colorf_black(); 682 m_title_style.font = font_hershey(); 683 m_title_style.font_modeling = font_filled; 684 m_title_style.encoding = encoding_PAW(); 685 686 m_background_style.back_color = colorf_whi 687 m_background_style.line_width = 0; //no bo 688 m_background_style.color = colorf_black(); 689 690 m_inner_frame_style.color = colorf_black() 691 m_inner_frame_style.line_pattern = line_so 692 693 m_grid_style.color = colorf_black(); 694 m_grid_style.line_pattern = line_dashed; 695 696 m_infos_style.font = font_hershey(); 697 m_infos_style.font_modeling = font_filled; 698 m_infos_style.encoding = encoding_PAW(); 699 700 m_title_box_style.visible = false; 701 m_title_box_style.font = font_hershey(); 702 m_title_box_style.font_modeling = font_fil 703 m_title_box_style.encoding = encoding_PAW( 704 705 {tools_vforit(style,m_bins_style,it) { 706 (*it) = style(); 707 (*it).modeling = modeling_top_lines(); 708 (*it).marker_size = 5; //for bins1D of p 709 }} 710 {tools_vforit(style,m_errors_style,it) {(*i 711 {tools_vforit(style,m_func_style,it) (*it) 712 {tools_vforit(style,m_points_style,it) { 713 (*it) = style(); 714 (*it).modeling = modeling_markers(); //f 715 }} 716 {tools_vforit(style,m_left_hatch_style,it) 717 {tools_vforit(style,m_right_hatch_style,it) 718 {tools_vforit(style,m_legend_style,it) {(*i 719 720 } 721 722 void gopaw_reset_style() { 723 {tools_vforit(style,m_bins_style,it) { 724 (*it) = style(); 725 (*it).modeling = modeling_top_lines(); 726 (*it).marker_size = 5; //for bins1D of p 727 }} 728 729 {tools_vforit(style,m_errors_style,it) {(*i 730 {tools_vforit(style,m_func_style,it) (*it) 731 {tools_vforit(style,m_points_style,it) { 732 (*it) = style(); 733 (*it).modeling = modeling_markers(); //f 734 }} 735 {tools_vforit(style,m_left_hatch_style,it) 736 {tools_vforit(style,m_right_hatch_style,it) 737 {tools_vforit(style,m_legend_style,it) {(*i 738 } 739 740 typedef std::pair<std::string,std::string> s 741 typedef std::vector<style_item_t> style_t; 742 bool set_from_style(std::ostream& a_out,cons 743 tools_vforcit(style_item_t,a_style,it) { 744 const std::string& key = (*it).first; 745 const std::string& sv = (*it).second; 746 //::printf("debug : plotter::set_from_st 747 //if(key=="reset") {} 748 if(key=="tag") { 749 // key to find back <plotter_style>s. 750 // see also : 751 // xml_style::load_plotter_style() 752 // xml_style::find_plotter_styles() 753 754 755 //width,height,depth : could set from st 756 } else if(key=="width") { 757 float v; 758 if(!to<float>(sv,v)) {style_failed(a_o 759 width = v; 760 } else if(key=="height") { 761 float v; 762 if(!to<float>(sv,v)) {style_failed(a_o 763 height = v; 764 } else if(key=="depth") { 765 float v; 766 if(!to<float>(sv,v)) {style_failed(a_o 767 depth = v; 768 769 } else if(key=="left_margin") { 770 float v; 771 if(!to<float>(sv,v)) {style_failed(a_o 772 left_margin = v; 773 } else if(key=="right_margin") { 774 float v; 775 if(!to<float>(sv,v)) {style_failed(a_o 776 right_margin = v; 777 } else if(key=="bottom_margin") { 778 float v; 779 if(!to<float>(sv,v)) {style_failed(a_o 780 bottom_margin = v; 781 } else if(key=="top_margin") { 782 float v; 783 if(!to<float>(sv,v)) {style_failed(a_o 784 top_margin = v; 785 } else if(key=="down_margin") { 786 float v; 787 if(!to<float>(sv,v)) {style_failed(a_o 788 down_margin = v; 789 } else if(key=="up_margin") { 790 float v; 791 if(!to<float>(sv,v)) {style_failed(a_o 792 up_margin = v; 793 794 } else if(key=="title") { 795 title = sv; 796 } else if(key=="title_up") { 797 bool v; 798 if(!to(sv,v)) {style_failed(a_out,key, 799 title_up = v; 800 } else if(key=="title_to_axis") { 801 float v; 802 if(!to<float>(sv,v)) {style_failed(a_o 803 title_to_axis = v; 804 } else if(key=="title_height") { 805 float v; 806 if(!to<float>(sv,v)) {style_failed(a_o 807 title_height = v; 808 } else if(key=="title_automated") { 809 bool v; 810 if(!to(sv,v)) {style_failed(a_out,key, 811 title_automated = v; 812 } else if(key=="title_hjust") { 813 hjust v; 814 if(!shjust(sv,v)) 815 {style_failed(a_out,key,sv);return f 816 title_hjust = v; 817 818 } else if(key=="x_axis_enforced") { 819 bool v; 820 if(!to(sv,v)) {style_failed(a_out,key, 821 x_axis_enforced = v; 822 } else if(key=="x_axis_automated") { 823 bool v; 824 if(!to(sv,v)) {style_failed(a_out,key, 825 x_axis_automated = v; 826 } else if(key=="x_axis_min") { 827 float v; 828 if(!to<float>(sv,v)) {style_failed(a_o 829 x_axis_min = v; 830 } else if(key=="x_axis_max") { 831 float v; 832 if(!to<float>(sv,v)) {style_failed(a_o 833 x_axis_max = v; 834 } else if(key=="x_axis_is_log") { 835 bool v; 836 if(!to(sv,v)) {style_failed(a_out,key, 837 x_axis_is_log = v; 838 839 } else if(key=="y_axis_enforced") { 840 bool v; 841 if(!to(sv,v)) {style_failed(a_out,key, 842 y_axis_enforced = v; 843 } else if(key=="y_axis_automated") { 844 bool v; 845 if(!to(sv,v)) {style_failed(a_out,key, 846 y_axis_automated = v; 847 } else if(key=="y_axis_min") { 848 float v; 849 if(!to<float>(sv,v)) {style_failed(a_o 850 y_axis_min = v; 851 } else if(key=="y_axis_max") { 852 float v; 853 if(!to<float>(sv,v)) {style_failed(a_o 854 y_axis_max = v; 855 } else if(key=="y_axis_is_log") { 856 bool v; 857 if(!to(sv,v)) {style_failed(a_out,key, 858 y_axis_is_log = v; 859 860 } else if(key=="z_axis_enforced") { 861 bool v; 862 if(!to(sv,v)) {style_failed(a_out,key, 863 z_axis_enforced = v; 864 } else if(key=="z_axis_automated") { 865 bool v; 866 if(!to(sv,v)) {style_failed(a_out,key, 867 z_axis_automated = v; 868 } else if(key=="z_axis_min") { 869 float v; 870 if(!to<float>(sv,v)) {style_failed(a_o 871 z_axis_min = v; 872 } else if(key=="z_axis_max") { 873 float v; 874 if(!to<float>(sv,v)) {style_failed(a_o 875 z_axis_max = v; 876 } else if(key=="z_axis_is_log") { 877 bool v; 878 if(!to(sv,v)) {style_failed(a_out,key, 879 z_axis_is_log = v; 880 881 } else if(key=="value_top_margin") { 882 float v; 883 if(!to<float>(sv,v)) {style_failed(a_o 884 value_top_margin = v; 885 } else if(key=="value_bottom_margin") { 886 float v; 887 if(!to<float>(sv,v)) {style_failed(a_o 888 value_bottom_margin = v; 889 } else if(key=="value_bins_with_entries" 890 float v; 891 if(!to<float>(sv,v)) {style_failed(a_o 892 value_bins_with_entries = v; 893 } else if(key=="infos_width") { 894 float v; 895 if(!to<float>(sv,v)) {style_failed(a_o 896 infos_width = v; 897 } else if(key=="infos_x_margin") { 898 float v; 899 if(!to<float>(sv,v)) {style_failed(a_o 900 infos_x_margin = v; 901 } else if(key=="infos_y_margin") { 902 float v; 903 if(!to<float>(sv,v)) {style_failed(a_o 904 infos_y_margin = v; 905 906 } else if(key=="title_box_width") { 907 float v; 908 if(!to<float>(sv,v)) {style_failed(a_o 909 title_box_width = v; 910 } else if(key=="title_box_height") { 911 float v; 912 if(!to<float>(sv,v)) {style_failed(a_o 913 title_box_height = v; 914 } else if(key=="title_box_x_margin") { 915 float v; 916 if(!to<float>(sv,v)) {style_failed(a_o 917 title_box_x_margin = v; 918 } else if(key=="title_box_y_margin") { 919 float v; 920 if(!to<float>(sv,v)) {style_failed(a_o 921 title_box_y_margin = v; 922 923 } else if(key=="infos_what") { 924 infos_what = sv; 925 926 // } else if(key=="legends_visible") { 927 // bool v; 928 // if(!to(sv,v)) {style_failed(a_out,ke 929 // legends_visible = v; 930 } else if(key=="legends_automated") { 931 bool v; 932 if(!to(sv,v)) {style_failed(a_out,key, 933 legends_automated = v; 934 // } else if(key=="legends_attached_to_info 935 // bool v; 936 // if(!to(sv,v)) {style_failed(a_out,key, 937 // legends_attached_to_infos = v; 938 } else if(key=="legends_origin") { 939 vec2f v; 940 if(!sto(sv,v)) {style_failed(a_out,key 941 legends_origin.setValue(v); 942 } else if(key=="legends_size") { 943 vec2f v; 944 if(!sto(sv,v)) {style_failed(a_out,key 945 legends_size.setValue(v); 946 } else if(key=="legends_origin_unit") { 947 unit_type v; 948 if(!sto(sv,v)) {style_failed(a_out,key 949 legends_origin_unit.setValue(v); 950 951 } else if(key=="shape_automated") { 952 bool v; 953 if(!to(sv,v)) {style_failed(a_out,key, 954 shape_automated = v; 955 956 } else if(key=="shape") { 957 if(sv=="xy") { 958 shape = xy; 959 } else if(sv=="xyz") { 960 shape = xyz; 961 } else { 962 style_failed(a_out,key,sv);return fa 963 } 964 965 //legends_string 966 //legends_color 967 //legends_string mf_string 968 //legends_color mf_vec<colorf,float> 969 970 } else { 971 a_out << "tools::sg::plotter::set_from 972 } 973 } 974 return true; 975 } 976 977 protected: 978 bool s2axis(const std::string& a_s,sg::axis* 979 if(a_s=="x_axis") {a_axis = &( 980 else if(a_s=="y_axis") {a_axis = &( 981 else if(a_s=="z_axis") {a_axis = &( 982 else if(a_s=="colormap_axis") {a_axis = &( 983 else { 984 a_axis = 0; 985 return false; 986 } 987 } 988 public: 989 bool set_from_string(std::ostream& a_out,cma 990 // see also plotter_style file. 991 std::string::size_type pos = a_field.find( 992 bool status = true; 993 if(pos==std::string::npos) { 994 style_t _style; 995 _style.push_back(style_item_t(a_field,a_ 996 if(!set_from_style(a_out,_style)) status 997 } else { 998 std::vector<std::string> _words; 999 words(a_field,".",false,_words); 1000 if(_words.size()==2) { 1001 const std::string& word0 = _words[0]; 1002 const std::string& word1 = _words[1]; 1003 std::string _s = word1+" "+std::strin 1004 sg::axis* _axis = 0; 1005 if(word0=="background_style") { 1006 else if(word0=="title_style") { 1007 else if(word0=="infos_style") { 1008 else if(word0=="title_box_style") { 1009 else if(word0=="inner_frame_style") { 1010 else if(word0=="grid_style") { 1011 else if(word0=="wall_style") { 1012 else if(!s2axis(word0,_axis)) { 1013 a_out << "tools::sg::plotter::set_f 1014 status = false; 1015 } else { 1016 style_t _style; 1017 _style.push_back(style_item_t(word1 1018 if(!_axis->set_from_style(a_out,_st 1019 } 1020 } else if(_words.size()==3) { 1021 const std::string& word0 = _words[0]; 1022 const std::string& word1 = _words[1]; 1023 const std::string& word2 = _words[2]; 1024 sg::axis* _axis = 0; 1025 std::string _s = word2+" "+std::strin 1026 unsigned int index; 1027 bool to_status = to<unsigned int>(wor 1028 if(word0=="bins_style") { 1029 if(!to_status) { 1030 a_out << "tools::sg::plotter::set 1031 status = false; 1032 } else { 1033 if(!bins_style(index).from_string 1034 } 1035 } else if(word0=="errors_style") { 1036 if(!to_status) { 1037 a_out << "tools::sg::plotter::set 1038 status = false; 1039 } else { 1040 if(!errors_style(index).from_stri 1041 } 1042 } else if(word0=="func_style") { 1043 if(!to_status) { 1044 a_out << "tools::sg::plotter::set 1045 status = false; 1046 } else { 1047 if(!func_style(index).from_string 1048 } 1049 } else if(word0=="points_style") { 1050 if(!to_status) { 1051 a_out << "tools::sg::plotter::set 1052 status = false; 1053 } else { 1054 if(!points_style(index).from_stri 1055 } 1056 } else if(word0=="left_hatch_style") { 1057 if(!to_status) { 1058 a_out << "tools::sg::plotter::set 1059 status = false; 1060 } else { 1061 if(!left_hatch_style(index).from_ 1062 } 1063 } else if(word0=="right_hatch_style") { 1064 if(!to_status) { 1065 a_out << "tools::sg::plotter::set 1066 status = false; 1067 } else { 1068 if(!right_hatch_style(index).from 1069 } 1070 } else if(word0=="legend_style") { 1071 if(!to_status) { 1072 a_out << "tools::sg::plotter::set 1073 status = false; 1074 } else { 1075 if(!legend_style(index).from_stri 1076 } 1077 } else if(!s2axis(word0,_axis)) { 1078 a_out << "tools::sg::plotter::set_f 1079 status = false; 1080 } else { 1081 if(word1=="line_style") {if( 1082 else if(word1=="ticks_style") {if( 1083 else if(word1=="labels_style") {if( 1084 else if(word1=="mag_style") {if( 1085 else if(word1=="title_style") {if( 1086 else { 1087 a_out << "tools::sg::plotter::set 1088 status = false; 1089 } 1090 } 1091 } else { 1092 a_out << "tools::sg::plotter::set_fro 1093 status = false; 1094 } 1095 } 1096 return status; 1097 } 1098 1099 void set_encoding(const std::string& a_valu 1100 title_style().encoding = a_value; 1101 infos_style().encoding = a_value; 1102 title_box_style().encoding = a_value; 1103 m_x_axis.set_encoding(a_value); 1104 m_y_axis.set_encoding(a_value); 1105 m_z_axis.set_encoding(a_value); 1106 m_cmap_axis.set_encoding(a_value); 1107 } 1108 void set_encoding_none() {set_encoding(enco 1109 1110 void print_available_customization(std::ost 1111 a_out << "plotter fields :" << std::endl; 1112 {const std::vector<field_desc>& fds = node 1113 tools_vforcit(field_desc,fds,itd) { 1114 a_out << " " << (*itd).name() << ", cla 1115 }} 1116 a_out << std::endl; 1117 1118 a_out << "plotter data available styles : 1119 a_out << " bins_style.<uint>, class style 1120 a_out << " errors_style.<uint>, class sty 1121 a_out << " func_style.<uint>, class style 1122 a_out << " points_style.<uint>, class sty 1123 a_out << " left_hatch_style.<uint>, class 1124 a_out << " right_hatch_style.<uint>, clas 1125 a_out << " legend_style.<uint>, class sty 1126 a_out << std::endl; 1127 1128 a_out << "plotter available styles :" << 1129 a_out << " title_style, class text_style" 1130 a_out << " infos_style, class text_style" 1131 a_out << " title_box_style, class text_st 1132 a_out << " background_style, class style" 1133 a_out << " inner_frame_style, class style 1134 a_out << " grid_style, class style" << st 1135 a_out << " wall_style, class style" << st 1136 a_out << std::endl; 1137 1138 a_out << "plotter available axes :" << st 1139 a_out << " x_axis" << std::endl; 1140 a_out << " y_axis" << std::endl; 1141 a_out << " z_axis" << std::endl; 1142 a_out << " colormap_axis" << std::endl; 1143 a_out << std::endl; 1144 1145 a_out << "plotter axis available styles : 1146 a_out << " title_style, class text_style" 1147 a_out << " labels_style, class text_style 1148 a_out << " mag_style, class text_style" < 1149 a_out << " line_style, class line_style" 1150 a_out << " ticks_style, class line_style" 1151 a_out << std::endl; 1152 1153 a_out << "plotter style class fields :" < 1154 {style _style; 1155 const std::vector<field_desc>& fds = _sty 1156 tools_vforcit(field_desc,fds,itd) { 1157 a_out << " " << (*itd).name() << ", cla 1158 }} 1159 a_out << std::endl; 1160 1161 a_out << "plotter text_style class fields 1162 {text_style _style; 1163 const std::vector<field_desc>& fds = _sty 1164 tools_vforcit(field_desc,fds,itd) { 1165 a_out << " " << (*itd).name() << ", cla 1166 }} 1167 a_out << std::endl; 1168 1169 a_out << "plotter line_style class fields 1170 {line_style _style; 1171 const std::vector<field_desc>& fds = _sty 1172 tools_vforcit(field_desc,fds,itd) { 1173 a_out << " " << (*itd).name() << ", cla 1174 }} 1175 a_out << std::endl; 1176 } 1177 protected: 1178 void style_failed(std::ostream& a_out,const 1179 a_out << "tools::sg::plotter::set_from_st 1180 << " failed for key " << sout(a_key 1181 << " and value " << sout(a_value) < 1182 << std::endl; 1183 } 1184 public: 1185 virtual void render(render_action& a_action 1186 if(touched()) { 1187 update_sg(a_action.out()); 1188 reset_touched(); 1189 } 1190 m_group.render(a_action); 1191 } 1192 virtual void pick(pick_action& a_action) { 1193 if(touched()) { 1194 update_sg(a_action.out()); 1195 reset_touched(); 1196 } 1197 nodekit_pick(a_action,m_group,this); 1198 } 1199 virtual void search(search_action& a_action 1200 if(touched()) { 1201 update_sg(a_action.out()); 1202 reset_touched(); 1203 } 1204 node::search(a_action); 1205 if(a_action.done()) return; 1206 m_group.search(a_action); 1207 } 1208 virtual void bbox(bbox_action& a_action) { 1209 if(touched()) { 1210 update_sg(a_action.out()); 1211 reset_touched(); 1212 } 1213 m_group.bbox(a_action); 1214 } 1215 1216 virtual bool write(write_action& a_action) 1217 if(touched()) { 1218 update_sg(a_action.out()); 1219 reset_touched(); 1220 } 1221 //if(!write_fields(a_action)) return fals 1222 return m_group.write(a_action); 1223 } 1224 public: 1225 plotter(const base_freetype& a_ttf) 1226 :parent() 1227 ,width(0) 1228 ,height(0) 1229 ,left_margin(0) 1230 ,right_margin(0) 1231 ,bottom_margin(0) 1232 ,top_margin(0) 1233 ,depth(0) 1234 ,down_margin(0) 1235 ,up_margin(0) 1236 1237 ,title_up(true) 1238 ,title_to_axis(0) //set below. 1239 ,title_height(0) //set below. 1240 ,title_automated(true) 1241 ,title_hjust(center) 1242 ,title("") 1243 1244 ,colormap_visible(true) 1245 ,colormap_axis_labeling(cells) 1246 ,colormap_attached(true) 1247 ,colormap_axis_visible(true) 1248 1249 ,x_axis_enforced(false) 1250 ,x_axis_automated(true) 1251 ,x_axis_min(0) 1252 ,x_axis_max(1) 1253 ,x_axis_is_log(false) 1254 ,y_axis_enforced(false) 1255 ,y_axis_automated(true) 1256 ,y_axis_min(0) 1257 ,y_axis_max(1) 1258 ,y_axis_is_log(false) 1259 ,z_axis_enforced(false) 1260 ,z_axis_automated(true) 1261 ,z_axis_min(0) 1262 ,z_axis_max(1) 1263 ,z_axis_is_log(false) 1264 1265 ,value_top_margin(0.1f) //percent. // CERN- 1266 ,value_bottom_margin(0.0f) //percent. 1267 ,value_bins_with_entries(true) 1268 1269 ,infos_width(0.3f) //percent of width 1270 ,infos_x_margin(default_infos_margin()) //p 1271 ,infos_y_margin(default_infos_margin()) //p 1272 ,infos_what(s_infos_what_def()) 1273 1274 ,title_box_width(default_title_box_width()) 1275 ,title_box_height(default_title_box_height( 1276 ,title_box_x_margin(default_title_box_x_mar 1277 ,title_box_y_margin(default_title_box_y_mar 1278 1279 ,func2D_borders_visible(true) 1280 ,theta(30) 1281 ,phi(30) 1282 ,tau(-90) 1283 1284 ,legends_automated(true) 1285 //,legends_attached_to_infos(true) 1286 // if legends_attached_to_infos is false an 1287 // unit_percent, legends_origin is the posi 1288 // of the upper right corner of the legends 1289 // relative to the upper right corner of th 1290 // with positive values going in reverse x, 1291 //,legends_origin(vec2f(0.01f,0.01f)) 1292 //,legends_origin_unit(unit_percent) 1293 //,legends_size(vec2f(0.2f,0.16f)) 1294 //legends_string 1295 1296 ,shape_automated(true) 1297 ,shape(xy) 1298 1299 ,xy_depth(0.01f) 1300 ,curve_number_of_points(100) 1301 ,data_light_on_automated(true) 1302 ,primitives_enforced(false) 1303 ,inner_frame_enforced(false) 1304 ,number_of_levels(10) 1305 ,levels() 1306 1307 ,m_ttf(a_ttf) 1308 1309 ,m_cmap_axis(a_ttf) 1310 ,m_x_axis(a_ttf) 1311 ,m_y_axis(a_ttf) 1312 ,m_z_axis(a_ttf) 1313 1314 ,m_shape(xy) 1315 { 1316 m_cmaps[style_default_colormap::s_default 1317 1318 add_fields(); 1319 reset_style(true); 1320 1321 init_sg(); // skeleton of scene graph. 1322 } 1323 virtual ~plotter(){ 1324 clear_plottables(); 1325 clear_primitives(); 1326 clear_cmaps(); 1327 } 1328 public: 1329 plotter(const plotter& a_from) 1330 :parent(a_from) 1331 ,width(a_from.width) 1332 ,height(a_from.height) 1333 ,left_margin(a_from.left_margin) 1334 ,right_margin(a_from.right_margin) 1335 ,bottom_margin(a_from.bottom_margin) 1336 ,top_margin(a_from.top_margin) 1337 ,depth(a_from.depth) 1338 ,down_margin(a_from.down_margin) 1339 ,up_margin(a_from.up_margin) 1340 1341 ,title_up(a_from.title_up) 1342 ,title_to_axis(a_from.title_to_axis) 1343 ,title_height(a_from.title_height) 1344 ,title_automated(a_from.title_automated) 1345 ,title_hjust(a_from.title_hjust) 1346 ,title(a_from.title) 1347 1348 ,colormap_visible(a_from.colormap_visible) 1349 ,colormap_axis_labeling(a_from.colormap_axi 1350 ,colormap_attached(a_from.colormap_attached 1351 ,colormap_axis_visible(a_from.colormap_axis 1352 1353 ,x_axis_enforced(a_from.x_axis_enforced) 1354 ,x_axis_automated(a_from.x_axis_automated) 1355 ,x_axis_min(a_from.x_axis_min) 1356 ,x_axis_max(a_from.x_axis_max) 1357 ,x_axis_is_log(a_from.x_axis_is_log) 1358 ,y_axis_enforced(a_from.y_axis_enforced) 1359 ,y_axis_automated(a_from.y_axis_automated) 1360 ,y_axis_min(a_from.y_axis_min) 1361 ,y_axis_max(a_from.y_axis_max) 1362 ,y_axis_is_log(a_from.y_axis_is_log) 1363 ,z_axis_enforced(a_from.z_axis_enforced) 1364 ,z_axis_automated(a_from.z_axis_automated) 1365 ,z_axis_min(a_from.z_axis_min) 1366 ,z_axis_max(a_from.z_axis_max) 1367 ,z_axis_is_log(a_from.z_axis_is_log) 1368 ,value_top_margin(a_from.value_top_margin) 1369 ,value_bottom_margin(a_from.value_bottom_ma 1370 ,value_bins_with_entries(a_from.value_bins_ 1371 1372 ,infos_width(a_from.infos_width) 1373 ,infos_x_margin(a_from.infos_x_margin) 1374 ,infos_y_margin(a_from.infos_y_margin) 1375 ,infos_what(a_from.infos_what) 1376 1377 ,title_box_width(a_from.title_box_width) 1378 ,title_box_height(a_from.title_box_height) 1379 ,title_box_x_margin(a_from.title_box_x_marg 1380 ,title_box_y_margin(a_from.title_box_y_marg 1381 1382 ,func2D_borders_visible(a_from.func2D_borde 1383 ,theta(a_from.theta) 1384 ,phi(a_from.phi) 1385 ,tau(a_from.tau) 1386 1387 ,legends_automated(a_from.legends_automated 1388 //,legends_attached_to_infos(a_from.legends_a 1389 ,legends_origin(a_from.legends_origin) 1390 ,legends_origin_unit(a_from.legends_origin_ 1391 ,legends_size(a_from.legends_size) 1392 ,legends_string(a_from.legends_string) 1393 1394 ,shape_automated(a_from.shape_automated) 1395 ,shape(a_from.shape) 1396 1397 ,xy_depth(a_from.xy_depth) 1398 ,curve_number_of_points(a_from.curve_number 1399 ,data_light_on_automated(a_from.data_light_ 1400 ,primitives_enforced(a_from.primitives_enfo 1401 ,inner_frame_enforced(a_from.inner_frame_en 1402 ,number_of_levels(a_from.number_of_levels) 1403 ,levels(a_from.levels) 1404 1405 ,m_ttf(a_from.m_ttf) 1406 1407 ,m_background_sep() 1408 1409 ,m_cmap_axis(m_ttf) 1410 ,m_x_axis(m_ttf) 1411 ,m_y_axis(m_ttf) 1412 ,m_z_axis(m_ttf) 1413 1414 ,m_etc_sep(a_from.m_etc_sep) 1415 1416 ,m_shape(a_from.m_shape) 1417 1418 ,m_bins_style(a_from.m_bins_style) 1419 ,m_errors_style(a_from.m_errors_style) 1420 ,m_func_style(a_from.m_func_style) 1421 ,m_points_style(a_from.m_points_style) 1422 ,m_left_hatch_style(a_from.m_left_hatch_sty 1423 ,m_right_hatch_style(a_from.m_right_hatch_s 1424 ,m_legend_style(a_from.m_legend_style) 1425 1426 ,m_title_style(a_from.m_title_style) 1427 ,m_infos_style(a_from.m_infos_style) 1428 ,m_title_box_style(a_from.m_title_box_style 1429 ,m_background_style(a_from.m_background_sty 1430 ,m_wall_style(a_from.m_wall_style) 1431 ,m_inner_frame_style(a_from.m_inner_frame_s 1432 ,m_grid_style(a_from.m_grid_style) 1433 ,m_cmaps(a_from.m_cmaps) 1434 { 1435 add_fields(); 1436 1437 // to copy axes styles : 1438 m_x_axis = a_from.m_x_axis; 1439 m_y_axis = a_from.m_y_axis; 1440 m_z_axis = a_from.m_z_axis; 1441 m_cmap_axis = a_from.m_cmap_axis; 1442 1443 init_sg(); // skeleton of scene graph. 1444 1445 {tools_vforcit(plottable*,a_from.m_plottab 1446 {tools_vforcit(plotprim*,a_from.m_primitiv 1447 } 1448 plotter& operator=(const plotter& a_from){ 1449 parent::operator=(a_from); 1450 if(&a_from==this) return *this; 1451 1452 width = a_from.width; 1453 height = a_from.height; 1454 left_margin = a_from.left_margin; 1455 right_margin = a_from.right_margin; 1456 bottom_margin = a_from.bottom_margin; 1457 top_margin = a_from.top_margin; 1458 depth = a_from.depth; 1459 down_margin = a_from.down_margin; 1460 up_margin = a_from.up_margin; 1461 1462 title_up = a_from.title_up; 1463 title_to_axis = a_from.title_to_axis; 1464 title_height = a_from.title_height; 1465 title_automated = a_from.title_automated; 1466 title_hjust = a_from.title_hjust; 1467 title = a_from.title; 1468 1469 colormap_visible = a_from.colormap_visibl 1470 colormap_axis_labeling = a_from.colormap_ 1471 colormap_attached = a_from.colormap_attac 1472 colormap_axis_visible = a_from.colormap_a 1473 1474 x_axis_enforced = a_from.x_axis_enforced; 1475 x_axis_automated = a_from.x_axis_automate 1476 x_axis_min = a_from.x_axis_min; 1477 x_axis_max = a_from.x_axis_max; 1478 x_axis_is_log = a_from.x_axis_is_log; 1479 y_axis_enforced = a_from.y_axis_enforced; 1480 y_axis_automated = a_from.y_axis_automate 1481 y_axis_min = a_from.y_axis_min; 1482 y_axis_max = a_from.y_axis_max; 1483 y_axis_is_log = a_from.y_axis_is_log; 1484 z_axis_enforced = a_from.z_axis_enforced; 1485 z_axis_automated = a_from.z_axis_automate 1486 z_axis_min = a_from.z_axis_min; 1487 z_axis_max = a_from.z_axis_max; 1488 z_axis_is_log = a_from.z_axis_is_log; 1489 value_top_margin = a_from.value_top_margi 1490 value_bottom_margin = a_from.value_bottom 1491 value_bins_with_entries = a_from.value_bi 1492 1493 infos_width = a_from.infos_width; 1494 infos_x_margin = a_from.infos_x_margin; 1495 infos_y_margin = a_from.infos_y_margin; 1496 infos_what = a_from.infos_what; 1497 1498 title_box_width = a_from.title_box_width; 1499 title_box_height = a_from.title_box_heigh 1500 title_box_x_margin = a_from.title_box_x_m 1501 title_box_y_margin = a_from.title_box_y_m 1502 1503 func2D_borders_visible = a_from.func2D_bo 1504 theta = a_from.theta; 1505 phi = a_from.phi; 1506 tau = a_from.tau; 1507 1508 legends_automated = a_from.legends_automa 1509 //legends_attached_to_infos = a_from.legend 1510 legends_origin = a_from.legends_origin; 1511 legends_origin_unit = a_from.legends_orig 1512 legends_size = a_from.legends_size; 1513 legends_string = a_from.legends_string; 1514 1515 shape_automated = a_from.shape_automated; 1516 shape = a_from.shape; 1517 1518 xy_depth = a_from.xy_depth; 1519 curve_number_of_points = a_from.curve_num 1520 number_of_levels = a_from.number_of_level 1521 levels = a_from.levels; 1522 data_light_on_automated = a_from.data_lig 1523 primitives_enforced = a_from.primitives_e 1524 inner_frame_enforced = a_from.inner_frame 1525 1526 m_etc_sep = a_from.m_etc_sep; 1527 1528 m_bins_style = a_from.m_bins_style; 1529 m_errors_style = a_from.m_errors_style; 1530 m_func_style = a_from.m_func_style; 1531 m_points_style = a_from.m_points_style; 1532 m_left_hatch_style = a_from.m_left_hatch_ 1533 m_right_hatch_style = a_from.m_right_hatc 1534 m_legend_style = a_from.m_legend_style; 1535 1536 m_title_style = a_from.m_title_style; 1537 m_infos_style = a_from.m_infos_style; 1538 m_title_box_style = a_from.m_title_box_st 1539 m_background_style = a_from.m_background_ 1540 m_wall_style = a_from.m_wall_style; 1541 m_inner_frame_style = a_from.m_inner_fram 1542 m_grid_style = a_from.m_grid_style; 1543 1544 // to copy axes styles : 1545 m_x_axis = a_from.m_x_axis; 1546 m_y_axis = a_from.m_y_axis; 1547 m_z_axis = a_from.m_z_axis; 1548 m_cmap_axis = a_from.m_cmap_axis; 1549 1550 m_cmaps = a_from.m_cmaps; 1551 1552 clear_plottables(); 1553 clear_primitives(); 1554 clear_todels(); 1555 1556 {tools_vforcit(plottable*,a_from.m_plottab 1557 {tools_vforcit(plotprim*,a_from.m_primitiv 1558 1559 return *this; 1560 } 1561 public: 1562 size_t number_of_plottables() const { 1563 size_t number = 0; 1564 tools_vforcit(plottable*,m_plottables,it) 1565 plottable* object = *it; 1566 if(!object) continue; 1567 if(!object->is_valid()) continue; 1568 // take into account all valid plottabl 1569 number++; 1570 } 1571 return number; 1572 } 1573 1574 #define TOOLS_SG_PLOTTER_NUMBER_OF(a__what) \ 1575 size_t number_of_plotted_##a__what##s() con 1576 size_t number = 0;\ 1577 tools_vforcit(plottable*,m_plottables,it) 1578 plottable* object = *it;\ 1579 if(!object) continue;\ 1580 if(!object->is_valid()) continue;\ 1581 if(safe_cast<plottable,a__what>(*object 1582 }\ 1583 return number;\ 1584 } 1585 1586 TOOLS_SG_PLOTTER_NUMBER_OF(bins1D) 1587 TOOLS_SG_PLOTTER_NUMBER_OF(bins2D) 1588 TOOLS_SG_PLOTTER_NUMBER_OF(points2D) 1589 TOOLS_SG_PLOTTER_NUMBER_OF(points3D) 1590 TOOLS_SG_PLOTTER_NUMBER_OF(func1D) 1591 TOOLS_SG_PLOTTER_NUMBER_OF(func2D) 1592 1593 #undef TOOLS_SG_PLOTTER_NUMBER_OF 1594 1595 void plotted_object_names(std::vector<std:: 1596 a_names.clear(); 1597 tools_vforcit(plottable*,m_plottables,it) 1598 plottable* object = *it; 1599 if(!object) continue; 1600 if(!object->is_valid()) continue; 1601 // take into account all valid plottabl 1602 a_names.push_back(object->name()); 1603 } 1604 } 1605 1606 public: //public 1607 const torche& data_light() const {return m_ 1608 torche& data_light() {return m_data_light;} 1609 1610 matrix& tsf() {return m_tsf;} 1611 1612 const separator& etc_sep() const {return m_ 1613 separator& etc_sep() {return m_etc_sep;} 1614 1615 const std::vector<plottable*>& plottables() 1616 1617 void add_plottable(plottable* a_p) { 1618 //WARNING : it takes ownership of a_p obj 1619 m_plottables.push_back(a_p); 1620 touch(); 1621 } 1622 1623 void prep_plottable(plottable* a_p) { 1624 //WARNING : it takes ownership of a_p obj 1625 m_plottables.insert(m_plottables.begin(), 1626 touch(); 1627 } 1628 1629 void transfer_plottables(std::vector<plotta 1630 a_to = m_plottables; 1631 m_plottables.clear(); //do not delete plo 1632 touch(); 1633 } 1634 1635 template <class T> 1636 bool remove_plottables() { 1637 bool found = false; 1638 std::vector<plottable*>::iterator it; 1639 for(it=m_plottables.begin();it!=m_plottab 1640 plottable* object = *it; 1641 if(object && safe_cast<plottable,T>(*ob 1642 it = m_plottables.erase(it); 1643 delete object; 1644 found = true; 1645 } else { 1646 it++; 1647 } 1648 } 1649 if(found) touch(); 1650 return found; 1651 } 1652 1653 void add_primitive(plotprim* a_prim) {m_pri 1654 1655 void transfer_primitives(std::vector<plotpr 1656 a_to = m_primitives; 1657 m_primitives.clear(); //do not delete pri 1658 touch(); 1659 } 1660 1661 template <class T> 1662 void add_todel(T* a_obj) { 1663 m_todel_group.add(new sg::holder<T>(a_obj 1664 } 1665 template <class T> 1666 void remove_todels(){ 1667 remove_holders<T>(m_todel_group.children( 1668 } 1669 void transfer_todels(std::vector<node*>& a_ 1670 m_todel_group.transfer(a_to); 1671 } 1672 void add_node_todel(node* a_node) { //used 1673 m_todel_group.add(a_node); 1674 } 1675 1676 void clear() { 1677 clear_plottables(); 1678 clear_primitives(); 1679 clear_todels(); 1680 1681 legends_string.clear(); 1682 legends_origin_unit.clear(); 1683 legends_origin.clear(); 1684 legends_size.clear(); 1685 1686 //wallEnforced.setValue(false); 1687 //gridEnforced.setValue(false); 1688 primitives_enforced = false; 1689 inner_frame_enforced = false; 1690 1691 //getEtcSeparator()->removeAllChildren(); 1692 //getEtcDataSeparator()->removeAllChildre 1693 } 1694 1695 const sg::axis& x_axis() const {return m_x_ 1696 sg::axis& x_axis() {return m_x_axis;} 1697 1698 const sg::axis& y_axis() const {return m_y_ 1699 sg::axis& y_axis() {return m_y_axis;} 1700 1701 const sg::axis& z_axis() const {return m_z_ 1702 sg::axis& z_axis() {return m_z_axis;} 1703 1704 const sg::axis& colormap_axis() const {retu 1705 sg::axis& colormap_axis() {return m_cmap_ax 1706 1707 text_style& title_style() {return m_title_s 1708 style& background_style() {return m_backgro 1709 style& wall_style() {return m_wall_style;} 1710 style& inner_frame_style() {return m_inner_ 1711 style& grid_style() {return m_grid_style;} 1712 text_style& infos_style() {return m_infos_s 1713 text_style& title_box_style() {return m_tit 1714 1715 style& bins_style(size_t a_index) { 1716 size_t sz = m_bins_style.size(); 1717 if(a_index>=sz) { 1718 //012345 sz=6 1719 // 9 a_index wanted 1720 // 6789 loop 1721 for(size_t index=sz;index<=a_index;inde 1722 m_bins_style.push_back(style()); 1723 m_bins_style.back().modeling = modeli 1724 m_bins_style.back().marker_size = 5; 1725 } 1726 } 1727 return m_bins_style[a_index]; 1728 } 1729 1730 style& errors_style(size_t a_index) { 1731 size_t sz = m_errors_style.size(); 1732 if(a_index>=sz) { 1733 for(size_t index=sz;index<=a_index;inde 1734 m_errors_style.push_back(style()); 1735 m_errors_style.back().visible = false 1736 } 1737 } 1738 return m_errors_style[a_index]; 1739 } 1740 1741 style& func_style(size_t a_index) { 1742 size_t sz = m_func_style.size(); 1743 if(a_index>=sz) { 1744 for(size_t index=sz;index<=a_index;inde 1745 m_func_style.push_back(style()); 1746 } 1747 } 1748 return m_func_style[a_index]; 1749 } 1750 1751 style& points_style(size_t a_index) { 1752 size_t sz = m_points_style.size(); 1753 if(a_index>=sz) { 1754 //012345 sz=6 1755 // 9 a_index wanted 1756 // 6789 loop 1757 for(size_t index=sz;index<=a_index;inde 1758 m_points_style.push_back(style()); 1759 m_points_style.back().modeling = mode 1760 } 1761 } 1762 return m_points_style[a_index]; 1763 } 1764 1765 style& left_hatch_style(size_t a_index) { 1766 size_t sz = m_left_hatch_style.size(); 1767 if(a_index>=sz) { 1768 for(size_t index=sz;index<=a_index;inde 1769 m_left_hatch_style.push_back(style()) 1770 m_left_hatch_style.back().visible = f 1771 } 1772 } 1773 return m_left_hatch_style[a_index]; 1774 } 1775 1776 style& right_hatch_style(size_t a_index) { 1777 size_t sz = m_right_hatch_style.size(); 1778 if(a_index>=sz) { 1779 for(size_t index=sz;index<=a_index;inde 1780 m_right_hatch_style.push_back(style() 1781 m_right_hatch_style.back().visible = 1782 } 1783 } 1784 return m_right_hatch_style[a_index]; 1785 } 1786 1787 style& legend_style(size_t a_index) { 1788 size_t sz = m_legend_style.size(); 1789 if(a_index>=sz) { 1790 for(size_t index=sz;index<=a_index;inde 1791 m_legend_style.push_back(style()); 1792 } 1793 } 1794 return m_legend_style[a_index]; 1795 } 1796 1797 void bins_modelings(size_t a_index,std::vec 1798 a_opts.clear(); 1799 update_shape(); 1800 if(m_shape==xy) { 1801 size_t ibins = 0; 1802 tools_vforcit(plottable*,m_plottables,i 1803 plottable* object = *it; 1804 if(!object) continue; 1805 if(bins1D* b1 = safe_cast<plottable,b 1806 //update_bins1D_xy 1807 if(a_index==ibins) { 1808 if(b1->is_profile()) { 1809 a_opts.push_back(modeling_point 1810 a_opts.push_back(modeling_marke 1811 return; 1812 } else { 1813 a_opts.push_back(modeling_boxes 1814 a_opts.push_back(modeling_wire_ 1815 a_opts.push_back(modeling_bar_c 1816 a_opts.push_back(modeling_top_l 1817 a_opts.push_back(modeling_point 1818 a_opts.push_back(modeling_marke 1819 return; 1820 } 1821 } 1822 ibins++; 1823 } if(safe_cast<plottable,bins2D>(*obj 1824 //update_bins2D_xy 1825 if(a_index==ibins) { 1826 a_opts.push_back(modeling_curve() 1827 a_opts.push_back(modeling_filled_ 1828 a_opts.push_back(modeling_boxes() 1829 a_opts.push_back(modeling_wire_bo 1830 a_opts.push_back(modeling_solid() 1831 a_opts.push_back(modeling_points( 1832 return; 1833 } 1834 ibins++; 1835 } 1836 } 1837 } 1838 } 1839 1840 bool xx_2_yy(const vec3f& a_pos,vec3f& a_ou 1841 // a_pos is in data frame NDC coordinates 1842 {float XSIZ = width; 1843 float XMGL = left_margin; 1844 float XMGR = right_margin; 1845 float wData = XSIZ-XMGL-XMGR; 1846 a_out[0] = wData*a_pos[0];} 1847 1848 {float YSIZ = height; 1849 float YMGL = bottom_margin; 1850 float YMGU = top_margin; 1851 float hData = YSIZ-YMGL-YMGU; 1852 a_out[1] = hData*a_pos[1];} 1853 1854 {float ZSIZ = depth; 1855 float ZMGD = down_margin; 1856 float ZMGU = up_margin; 1857 float dData = ZSIZ-ZMGD-ZMGU; 1858 a_out[2] = dData*a_pos[2];} 1859 1860 return true; 1861 } 1862 1863 bool data_frame_2_vp(const vec3f& a_pos,vec 1864 // a_pos is in data frame NDC coordinates 1865 // a_vp is in viewport/screen coordinates 1866 {float XSIZ = width; 1867 float XMGL = left_margin; 1868 float XMGR = right_margin; 1869 float wData = XSIZ-XMGL-XMGR; 1870 if(XSIZ==0.0F) { 1871 //SoDebugError::postInfo("tools::sg;:pl 1872 return false; 1873 } 1874 a_vp[0] = (wData*a_pos[0] + XMGL)/XSIZ;} 1875 1876 {float YSIZ = height; 1877 float YMGL = bottom_margin; 1878 float YMGU = top_margin; 1879 float hData = YSIZ-YMGL-YMGU; 1880 if(YSIZ==0.0F) { 1881 //SoDebugError::postInfo("tools::sg;:pl 1882 return false; 1883 } 1884 a_vp[1] = (hData*a_pos[1] + YMGL)/YSIZ;} 1885 1886 {float ZSIZ = depth; 1887 float ZMGD = down_margin; 1888 float ZMGU = up_margin; 1889 float dData = ZSIZ-ZMGD-ZMGU; 1890 if(ZSIZ==0.0F) { 1891 //SoDebugError::postInfo("tools::sg;:pl 1892 return false; 1893 } 1894 a_vp[2] = (dData*a_pos[2] + ZMGD)/ZSIZ;} 1895 1896 return true; 1897 } 1898 1899 bool vp_2_data_frame(const vec3f& a_vp,vec3 1900 // a_vp is in viewport/screen coordinates 1901 // a_pos is in data frame NDC coordinates 1902 1903 {float XSIZ = width; 1904 float XMGL = left_margin; 1905 float XMGR = right_margin; 1906 float wData = XSIZ-XMGL-XMGR; 1907 if(wData==0.0F) { 1908 //SoDebugError::postInfo("tools::sg;:pl 1909 return false; 1910 } 1911 a_pos[0] = (a_vp[0]*XSIZ - XMGL)/wData;} 1912 1913 {float YSIZ = height; 1914 float YMGL = bottom_margin; 1915 float YMGU = top_margin; 1916 float hData = YSIZ-YMGL-YMGU; 1917 if(hData==0.0F) { 1918 //SoDebugError::postInfo("tools::sg;:pl 1919 return false; 1920 } 1921 a_pos[1] = (a_vp[1]*YSIZ - YMGL)/hData;} 1922 1923 {float ZSIZ = depth; 1924 float ZMGD = down_margin; 1925 float ZMGU = up_margin; 1926 float dData = ZSIZ-ZMGD-ZMGU; 1927 if(dData==0.0F) { 1928 //SoDebugError::postInfo("tools::sg;:pl 1929 return false; 1930 } 1931 a_pos[2] = (a_vp[2]*ZSIZ - ZMGD)/dData;} 1932 1933 return true; 1934 } 1935 1936 bool data_frame_2_axis(const vec3f& aDF,vec 1937 // aDF is in data area coordinates. In [0 1938 // a_pos is in axes coordinates. 1939 1940 // Assume that axes min,max,is_log are up 1941 1942 {float mn = m_x_axis.minimum_value; 1943 float mx = m_x_axis.maximum_value; 1944 bool lg = m_x_axis.is_log; 1945 if(lg) { 1946 mn = fpow(10,mn); 1947 mx = fpow(10,mx); 1948 } 1949 a_pos[0] = verify_log_inv(aDF[0],mn,mx-mn 1950 1951 {float mn = m_y_axis.minimum_value; 1952 float mx = m_y_axis.maximum_value; 1953 bool lg = m_y_axis.is_log; 1954 if(lg) { 1955 mn = fpow(10,mn); 1956 mx = fpow(10,mx); 1957 } 1958 a_pos[1] = verify_log_inv(aDF[1],mn,mx-mn 1959 1960 {float mn = m_z_axis.minimum_value; 1961 float mx = m_z_axis.maximum_value; 1962 bool lg = m_z_axis.is_log; 1963 if(lg) { 1964 mn = fpow(10,mn); 1965 mx = fpow(10,mx); 1966 } 1967 a_pos[2] = verify_log_inv(aDF[2],mn,mx-mn 1968 1969 return true; 1970 } 1971 1972 bool axis_2_data_frame(const vec3f& a_pos,v 1973 // a_pos is in axes coordinates. 1974 // aDF in data area coordinate. In [0,1][ 1975 1976 // Assume that axes min,max,logScale are 1977 1978 {float mn = m_x_axis.minimum_value; 1979 float mx = m_x_axis.maximum_value; 1980 if(mx==mn) { 1981 //SoDebugError::postInfo 1982 // ("tools::sg;:plotter::axis_2_data_f 1983 return false; 1984 } 1985 bool lg = m_x_axis.is_log; 1986 if(lg) { 1987 if(mn<=0) { 1988 //SoDebugError::postInfo 1989 // ("tools::sg;:plotter::axis_2_data 1990 return false; 1991 } 1992 if(mx<=0) { 1993 //SoDebugError::postInfo 1994 // ("tools::sg;:plotter::axis_2_data 1995 return false; 1996 } 1997 mn = flog10(mn); 1998 mx = flog10(mx); 1999 } 2000 aDF[0] = verify_log(a_pos[0],mn,mx-mn,lg) 2001 2002 {float mn = m_y_axis.minimum_value; 2003 float mx = m_y_axis.maximum_value; 2004 if(mx==mn) { 2005 //SoDebugError::postInfo 2006 // ("tools::sg;:plotter::axis_2_data_f 2007 return false; 2008 } 2009 bool lg = m_y_axis.is_log; 2010 if(lg) { 2011 if(mn<=0) { 2012 //SoDebugError::postInfo 2013 // ("tools::sg;:plotter::axis_2_data 2014 return false; 2015 } 2016 if(mx<=0) { 2017 //SoDebugError::postInfo 2018 // ("tools::sg;:plotter::axis_2_data 2019 return false; 2020 } 2021 mn = flog10(mn); 2022 mx = flog10(mx); 2023 } 2024 aDF[1] = verify_log(a_pos[1],mn,mx-mn,lg) 2025 2026 {float mn = m_z_axis.minimum_value; 2027 float mx = m_z_axis.maximum_value; 2028 if(mx==mn) { 2029 //SoDebugError::postInfo 2030 // ("tools::sg;:plotter::axis_2_data_f 2031 return false; 2032 } 2033 bool lg = m_z_axis.is_log; 2034 if(lg) { 2035 if(mn<=0) { 2036 //SoDebugError::postInfo 2037 // ("tools::sg;:plotter::axis_2_data 2038 return false; 2039 } 2040 if(mx<=0) { 2041 //SoDebugError::postInfo 2042 // ("tools::sg;:plotter::axis_2_data 2043 return false; 2044 } 2045 mn = flog10(mn); 2046 mx = flog10(mx); 2047 } 2048 aDF[2] = verify_log(a_pos[2],mn,mx-mn,lg) 2049 2050 return true; 2051 } 2052 2053 bool axis_2_vp(const vec3f& a_pos,vec3f& a_ 2054 // a_pos is in axes coordinates. 2055 // a_vp is in viewport/screen coordinates 2056 vec3f d; // In data area coordinate. In [ 2057 if(!axis_2_data_frame(a_pos,d)) return fa 2058 return data_frame_2_vp(d,a_vp); 2059 } 2060 2061 bool vp_2_axis(const vec3f& a_vp,vec3f& a_p 2062 // a_vp is in viewport/screen coordinates 2063 // a_pos is in axes coordinates. 2064 vec3f d; // In data area coordinate. In [ 2065 if(!vp_2_data_frame(a_vp,d)) return false 2066 return data_frame_2_axis(d,a_pos); 2067 } 2068 2069 public: 2070 void set_axes_modeling(const std::string& a 2071 m_x_axis.modeling = a_v; 2072 m_y_axis.modeling = a_v; 2073 m_z_axis.modeling = a_v; 2074 m_cmap_axis.modeling = a_v; 2075 } 2076 2077 void set_axes_color(const colorf& a_color){ 2078 m_x_axis.line_style().color = a_color; 2079 m_x_axis.ticks_style().color = a_color; 2080 m_x_axis.labels_style().color = a_color; 2081 m_x_axis.title_style().color = a_color; 2082 m_x_axis.mag_style().color = a_color; 2083 2084 m_y_axis.line_style().color = a_color; 2085 m_y_axis.ticks_style().color = a_color; 2086 m_y_axis.labels_style().color = a_color; 2087 m_y_axis.title_style().color = a_color; 2088 m_y_axis.mag_style().color = a_color; 2089 2090 m_z_axis.line_style().color = a_color; 2091 m_z_axis.ticks_style().color = a_color; 2092 m_z_axis.labels_style().color = a_color; 2093 m_z_axis.title_style().color = a_color; 2094 m_z_axis.mag_style().color = a_color; 2095 2096 m_cmap_axis.line_style().color = a_color; 2097 m_cmap_axis.ticks_style().color = a_color 2098 m_cmap_axis.labels_style().color = a_colo 2099 m_cmap_axis.title_style().color = a_color 2100 m_cmap_axis.mag_style().color = a_color; 2101 } 2102 2103 void set_axes_text_scale(float a_v){ 2104 m_x_axis.labels_style().scale = a_v; 2105 m_x_axis.title_style().scale = a_v; 2106 m_x_axis.mag_style().scale = a_v; 2107 2108 m_y_axis.labels_style().scale = a_v; 2109 m_y_axis.title_style().scale = a_v; 2110 m_y_axis.mag_style().scale = a_v; 2111 2112 m_z_axis.labels_style().scale = a_v; 2113 m_z_axis.title_style().scale = a_v; 2114 m_z_axis.mag_style().scale = a_v; 2115 2116 m_cmap_axis.labels_style().scale = a_v; 2117 m_cmap_axis.title_style().scale = a_v; 2118 m_cmap_axis.mag_style().scale = a_v; 2119 } 2120 2121 void set_axes_line_pattern(unsigned short a 2122 m_x_axis.line_style().pattern = a_v; 2123 m_y_axis.line_style().pattern = a_v; 2124 m_z_axis.line_style().pattern = a_v; 2125 m_cmap_axis.line_style().pattern = a_v; 2126 } 2127 2128 void set_axes_line_width(int a_v){ 2129 m_x_axis.line_style().width = float(a_v); 2130 m_y_axis.line_style().width = float(a_v); 2131 m_z_axis.line_style().width = float(a_v); 2132 m_cmap_axis.line_style().width = float(a_ 2133 2134 m_x_axis.ticks_style().width = float(a_v) 2135 m_y_axis.ticks_style().width = float(a_v) 2136 m_z_axis.ticks_style().width = float(a_v) 2137 m_cmap_axis.ticks_style().width = float(a 2138 } 2139 2140 void set_axes_tick_length(float a_v){ 2141 m_x_axis.tick_length = a_v; 2142 m_y_axis.tick_length = a_v; 2143 m_z_axis.tick_length = a_v; 2144 m_cmap_axis.tick_length = a_v; 2145 } 2146 2147 void set_axes_title_height(float a_v){ 2148 m_x_axis.title_height = a_v; 2149 m_y_axis.title_height = a_v; 2150 m_z_axis.title_height = a_v; 2151 m_cmap_axis.title_height = a_v; 2152 } 2153 2154 void set_axes_label_height(float a_v){ 2155 m_x_axis.label_height = a_v; 2156 m_y_axis.label_height = a_v; 2157 m_z_axis.label_height = a_v; 2158 m_cmap_axis.label_height = a_v; 2159 } 2160 2161 void set_axes_font_modeling(font_modeling a 2162 m_x_axis.labels_style().font_modeling = a 2163 m_x_axis.title_style().font_modeling = a_ 2164 m_x_axis.mag_style().font_modeling = a_v; 2165 2166 m_y_axis.labels_style().font_modeling = a 2167 m_y_axis.title_style().font_modeling = a_ 2168 m_y_axis.mag_style().font_modeling = a_v; 2169 2170 m_z_axis.labels_style().font_modeling = a 2171 m_z_axis.title_style().font_modeling = a_ 2172 m_z_axis.mag_style().font_modeling = a_v; 2173 2174 m_cmap_axis.labels_style().font_modeling 2175 m_cmap_axis.title_style().font_modeling = 2176 m_cmap_axis.mag_style().font_modeling = a 2177 } 2178 2179 void set_font_modeling(font_modeling a_v){ 2180 set_axes_font_modeling(a_v); 2181 title_style().font_modeling = a_v; 2182 infos_style().font_modeling = a_v; 2183 title_box_style().font_modeling = a_v; 2184 } 2185 protected: 2186 void init_sg(){ 2187 2188 m_group.add(new noderef(m_background_sep) 2189 m_group.add(new noderef(m_cmap_sep)); 2190 m_group.add(new noderef(m_infos_title_sep 2191 m_group.add(new noderef(m_infos_sep)); 2192 m_group.add(new noderef(m_legend_sep)); 2193 m_group.add(new noderef(m_title_box_sep)) 2194 m_group.add(new noderef(m_tsf)); 2195 m_group.add(new noderef(m_layout)); 2196 m_group.add(new noderef(m_title_sep)); 2197 m_group.add(new noderef(m_x_axis_sep)); 2198 m_group.add(new noderef(m_y_axis_sep)); 2199 m_group.add(new noderef(m_z_axis_sep)); 2200 m_group.add(new noderef(m_grid_sep)); 2201 m_group.add(new noderef(m_data_sep)); 2202 m_group.add(new noderef(m_primitives_sep) 2203 2204 m_cmap_sep.add(new noderef(m_cmap_matrix) 2205 m_cmap_sep.add(new noderef(m_cmap_cells_s 2206 m_cmap_sep.add(new noderef(m_cmap_axis_ma 2207 m_cmap_sep.add(new noderef(m_cmap_axis)); 2208 2209 m_x_axis_sep.add(new noderef(m_x_axis_mat 2210 m_x_axis_sep.add(new noderef(m_x_axis)); 2211 2212 m_y_axis_sep.add(new noderef(m_y_axis_mat 2213 m_y_axis_sep.add(new noderef(m_y_axis)); 2214 2215 m_z_axis_sep.add(new noderef(m_z_axis_mat 2216 m_z_axis_sep.add(new noderef(m_z_axis)); 2217 2218 m_data_sep.add(new noderef(m_data_light)) 2219 m_data_sep.add(new noderef(m_data_matrix) 2220 2221 m_data_sep.add(new noderef(m_bins_sep)); 2222 m_data_sep.add(new noderef(m_errors_sep)) 2223 m_data_sep.add(new noderef(m_func_sep)); 2224 m_data_sep.add(new noderef(m_points_sep)) 2225 m_data_sep.add(new noderef(m_inner_frame_ 2226 m_data_sep.add(new noderef(m_etc_sep)); 2227 } 2228 2229 void update_layout(){ 2230 float XSIZ = width; 2231 float XMGL = left_margin; 2232 float XMGR = right_margin; 2233 float wData = XSIZ-XMGL-XMGR; 2234 2235 float YSIZ = height; 2236 float YMGL = bottom_margin; 2237 float YMGU = top_margin; 2238 float hData = YSIZ-YMGL-YMGU; 2239 2240 float ZSIZ = depth; 2241 float ZMGD = down_margin; 2242 float ZMGU = up_margin; 2243 float dData = ZSIZ-ZMGD-ZMGU; 2244 2245 {mat4f& mtx = m_layout.mtx.value(); 2246 mtx.set_identity(); 2247 2248 if(m_shape==xy) { 2249 // in rep primitives (0,0) is the lower 2250 // of the data area square; 2251 mtx.mul_translate(-XSIZ/2+XMGL,-YSIZ/2+ 2252 2253 if(data_light_on_automated.value()) m_d 2254 vec3f dir(0,0,-1); 2255 m_data_light.direction = dir; 2256 2257 } else { //xyz 2258 //printf("debug : update_layout : X : % 2259 // XSIZ,XMGL,XMGR,wData); 2260 //printf("debug : update_layout : Y : % 2261 // YSIZ,YMGL,YMGU,hData); 2262 2263 // global transformation (to have a "le 2264 // translate so that the center of the 2265 // is the center of the data area cube 2266 // then rotate to have lego 3D layout. 2267 2268 mtx.mul_rotate(1,0,0,theta*fdeg2rad()); 2269 mtx.mul_rotate(0,1,0,phi*fdeg2rad()); 2270 mtx.mul_rotate(1,0,0,tau*fdeg2rad()); 2271 2272 // To place as CERN-PAW default. 2273 // In CERN-PAW, it is the projection 2274 // which fits in the (XSIZ,XMGL,XMGR)/( 2275 // page setup. 2276 2277 rotf r1(vec3f(1,0,0),theta * fdeg2rad() 2278 rotf r2(vec3f(0,1,0),phi * fdeg2rad()); 2279 rotf r3(vec3f(1,0,0),tau * fdeg2rad()); 2280 2281 rotf r = r1*r2*r3; 2282 mat4f _m; 2283 r.value(_m); 2284 2285 float xmn = -0.5F*wData; 2286 float ymn = -0.5F*hData; 2287 float zmn = -0.5F*dData; 2288 float xmx = 0.5F*wData; 2289 float ymx = 0.5F*hData; 2290 float zmx = 0.5F*dData; 2291 2292 box3f _box; 2293 float x,y,z; 2294 // zmn face : 2295 {x = xmn;y = ymn;z = zmn; 2296 _m.mul_3f(x,y,z); 2297 _box.extend_by(x,y,z);} 2298 {x = xmx;y = ymn;z = zmn; 2299 _m.mul_3f(x,y,z); 2300 _box.extend_by(x,y,z);} 2301 {x = xmx;y = ymx;z = zmn; 2302 _m.mul_3f(x,y,z); 2303 _box.extend_by(x,y,z);} 2304 {x = xmn;y = ymx;z = zmn; 2305 _m.mul_3f(x,y,z); 2306 _box.extend_by(x,y,z);} 2307 2308 // zmx face : 2309 {x = xmn;y = ymn;z = zmx; 2310 _m.mul_3f(x,y,z); 2311 _box.extend_by(x,y,z);} 2312 {x = xmx;y = ymn;z = zmx; 2313 _m.mul_3f(x,y,z); 2314 _box.extend_by(x,y,z);} 2315 {x = xmx;y = ymx;z = zmx; 2316 _m.mul_3f(x,y,z); 2317 _box.extend_by(x,y,z);} 2318 {x = xmn;y = ymx;z = zmx; 2319 _m.mul_3f(x,y,z); 2320 _box.extend_by(x,y,z);} 2321 2322 float xfac = _box.mx()[0]-_box.mn()[0]; 2323 float yfac = _box.mx()[1]-_box.mn()[1]; 2324 float zfac = _box.mx()[2]-_box.mn()[2]; 2325 2326 //cube setup (driven by hData) : 2327 mtx.mul_scale(hData/xfac,hData/yfac,hDa 2328 2329 mtx.mul_translate(-wData/2,-hData/2,-dD 2330 2331 if(data_light_on_automated.value()) m_d 2332 {vec3f dir(1,-1,-10); 2333 float dx,dy,dz;dir.value(dx,dy,dz); 2334 mat4f inv; 2335 if(mtx.invert(inv)) { 2336 inv.mul_dir_3f(dx,dy,dz); 2337 m_data_light.direction = vec3f(dx,dy, 2338 }} 2339 }} 2340 2341 {mat4f& mtx = m_data_matrix.mtx.value(); 2342 mtx.set_identity(); 2343 if(m_shape==xy) { 2344 mtx.mul_scale(wData,hData,1); //z size 2345 } else if(m_shape==xyz) { 2346 mtx.mul_scale(wData,hData,dData); 2347 }} 2348 2349 } 2350 2351 public: 2352 void update_sg(std::ostream& a_out) { 2353 2354 update_shape(); 2355 update_axes_data(a_out); 2356 2357 update_background(); 2358 update_layout(); 2359 2360 // roundtrip over plottables to check if 2361 unsigned int nplottables = 0; 2362 unsigned int nbins = 0; 2363 unsigned int npoints = 0; 2364 unsigned int nfunc = 0; 2365 {tools_vforit(plottable*,m_plottables,it) 2366 plottable* object = *it; 2367 if(!object) continue; 2368 if(!object->is_valid()) { 2369 *it = 0; 2370 delete object; 2371 } else { 2372 if(safe_cast<plottable,bins1D>(*objec 2373 nplottables++; 2374 nbins++; 2375 } else if(safe_cast<plottable,bins2D> 2376 nplottables++; 2377 nbins++; 2378 2379 } else if(safe_cast<plottable,points2 2380 nplottables++; 2381 npoints++; 2382 } else if(safe_cast<plottable,points3 2383 nplottables++; 2384 npoints++; 2385 2386 } else if(safe_cast<plottable,func1D> 2387 nplottables++; 2388 nfunc++; 2389 } else if(safe_cast<plottable,func2D> 2390 nplottables++; 2391 nfunc++; 2392 } 2393 } 2394 }} 2395 2396 clear_cmaps(); 2397 m_bins_cmaps.resize(nbins,0); 2398 m_points_cmaps.resize(npoints,0); 2399 m_func_cmaps.resize(nfunc,0); 2400 2401 // even if !nplottables we continue. 2402 2403 m_infos_title_sep.clear(); 2404 m_infos_sep.clear(); 2405 m_legend_strings.clear(); 2406 2407 bool superpose = false; 2408 /*uuuu 2409 bool superpose = superposeBins; 2410 if(superpose) { 2411 // Check compatibility of bins : 2412 if( (nbins1D<=0) || (m_shape!=XY) ) { 2413 superpose = false; 2414 } else { 2415 SbPlottableBins1D* bins = f_bins1DLis 2416 int xnbin = bins->getAxisNumberOfBins 2417 float xmn = bins->get_axis_min(); 2418 float xmx = bins->get_axis_max(); 2419 superpose = true; 2420 for(int ibins=1;ibins<nbins1D;ibins++ 2421 SbPlottableBins1D* binsloop = f_bin 2422 if( (xnbin!=binsloop->getAxisNumber 2423 (xmn!=binsloop->get_axis_min()) 2424 (xmx!=binsloop->get_axis_max()) 2425 superpose = false; 2426 break; 2427 } 2428 } 2429 if(superpose) { //Compatible bins : 2430 if(y_axis_automated) { 2431 // Correct Y axis if XY shape and 2432 // Get min/max 2433 float bmin,bmax; 2434 getHeight(nbins1D-1,f_bins1DList, 2435 bmin = bmax; 2436 for(int ibin=1;ibin<xnbin;ibin++) 2437 float mini,maxi; 2438 getHeight 2439 (nbins1D-1,f_bins1DList,bins1 2440 bmin = SbMinimum(bmin,maxi); 2441 bmax = SbMaximum(bmax,maxi); 2442 } 2443 f_yDataAxis.setMinimumValue(bmin) 2444 f_yDataAxis.setMaximumValue(bmax) 2445 f_yDataAxis.adjustAxis(); 2446 } 2447 } 2448 } 2449 }*/ 2450 2451 float xmin = m_x_axis_data.min_value(); 2452 float xmax = m_x_axis_data.max_value(); 2453 bool xlog = m_x_axis_data.is_log(); 2454 if(xlog) { 2455 if((xmin<=0) || (xmax<=0) ) { 2456 m_x_axis_data.adjust(); 2457 xmin = m_x_axis_data.min_value(); 2458 xmax = m_x_axis_data.max_value(); 2459 // now should have reasonable values. 2460 } 2461 if((xmin<=0) || (xmax<=0) ) { 2462 xlog = false; 2463 } else { 2464 xmin = flog10(xmin); 2465 xmax = flog10(xmax); 2466 } 2467 } 2468 2469 float ymin = m_y_axis_data.min_value(); 2470 float ymax = m_y_axis_data.max_value(); 2471 bool ylog = m_y_axis_data.is_log(); 2472 if(ylog) { 2473 if((ymin<=0) || (ymax<=0) ) { 2474 m_y_axis_data.adjust(); 2475 ymin = m_y_axis_data.min_value(); 2476 ymax = m_y_axis_data.max_value(); 2477 // now should have reasonable values. 2478 } 2479 if((ymin<=0) || (ymax<=0) ) { 2480 ylog = false; 2481 }else{ 2482 ymin = flog10(ymin); 2483 ymax = flog10(ymax); 2484 } 2485 } 2486 2487 float zmin = m_z_axis_data.min_value(); 2488 float zmax = m_z_axis_data.max_value(); 2489 bool zlog = m_z_axis_data.is_log(); 2490 if(zlog) { 2491 if((zmin<=0) || (zmax<=0) ) { 2492 m_z_axis_data.adjust(); 2493 zmin = m_z_axis_data.min_value(); 2494 zmax = m_z_axis_data.max_value(); 2495 // now should have reasonable values. 2496 } 2497 if((zmin<=0) || (zmax<=0) ) { 2498 zlog = false; 2499 }else{ 2500 zmin = flog10(zmin); 2501 zmax = flog10(zmax); 2502 } 2503 } 2504 2505 if(m_shape==xy) { 2506 if(xmin>=xmax) { 2507 DUMP_UPDATE_WHAT(a_out,"bad min/max x 2508 } 2509 if(ymin>=ymax) { 2510 DUMP_UPDATE_WHAT(a_out,"bad min/max y 2511 } 2512 } else if(m_shape==xyz) { 2513 if(xmin>=xmax) { 2514 DUMP_UPDATE_WHAT(a_out,"bad min/max x 2515 } 2516 if(ymin>=ymax) { 2517 DUMP_UPDATE_WHAT(a_out,"bad min/max y 2518 } 2519 if(zmin>=zmax) { 2520 DUMP_UPDATE_WHAT(a_out,"bad min/max z 2521 } 2522 } 2523 2524 {float XSIZ = width; 2525 float XMGL = left_margin; 2526 float XMGR = right_margin; 2527 float wData = XSIZ-XMGL-XMGR; 2528 2529 float YSIZ = height; 2530 float YMGL = bottom_margin; 2531 float YMGU = top_margin; 2532 float hData = YSIZ-YMGL-YMGU; 2533 if(m_shape==xy) { 2534 if(wData<=0) { 2535 DUMP_UPDATE_WHAT(a_out,"null w data a 2536 } 2537 if(hData<=0) { 2538 DUMP_UPDATE_WHAT(a_out,"null h data a 2539 } 2540 } else if(m_shape==xyz) { 2541 float ZSIZ = depth; 2542 float ZMGD = down_margin; 2543 float ZMGU = up_margin; 2544 float dData = ZSIZ-ZMGD-ZMGU; 2545 if(wData<=0) { 2546 DUMP_UPDATE_WHAT(a_out,"null w data a 2547 } 2548 if(hData<=0) { 2549 DUMP_UPDATE_WHAT(a_out,"null h data a 2550 } 2551 if(dData<=0) { 2552 DUMP_UPDATE_WHAT(a_out,"null d data a 2553 } 2554 }} 2555 2556 float dx = xmax - xmin; 2557 float dy = ymax - ymin; 2558 float dz = zmax - zmin; 2559 2560 rep_box boxX(xmin,dx,xlog); 2561 rep_box boxY(ymin,dy,ylog); 2562 rep_box boxZ(zmin,dz,zlog); 2563 2564 //////////////////////////////////// 2565 /// data : ///////////////////////// 2566 //////////////////////////////////// 2567 if(m_shape==xy) { 2568 //a_out << "tools::sg::plotter::update_ 2569 2570 // first data plane is at zz = _zoffset 2571 2572 float zz = 0; 2573 2574 //////////////////////////////////// 2575 /// binss ////////////////////////// 2576 //////////////////////////////////// 2577 2578 //if(verbose) { 2579 // SoDebugError::postInfo("tools::sg;: 2580 // "%lu : XY : update bins",(unsigned 2581 //} 2582 2583 {m_bins_sep.clear(); 2584 m_errors_sep.clear(); 2585 2586 unsigned int ibins = 0; //used to get e 2587 //unsigned int ibins1D = 0; 2588 //unsigned int ibins2D = 0; 2589 tools_vforcit(plottable*,m_plottables,i 2590 plottable* object = *it; 2591 if(!object) continue; 2592 if(bins1D* b1 = safe_cast<plottable,b 2593 2594 zz += _zoffset(); // ibins = 0 back 2595 style* data_style = merge_bins_styl 2596 style* _left_hatch_style = merge_le 2597 style* _right_hatch_style = merge_r 2598 style* error_style = merge_errors_s 2599 2600 update_bins1D_xy(a_out,*b1, 2601 *data_style,*_left 2602 superpose,boxX,box 2603 2604 if(legends_automated.value()) { 2605 m_legend_strings.push_back(object 2606 style& _style = legend_style(m_le 2607 _style.color = data_style->color; 2608 _style.marker_style = data_style- 2609 _style.marker_size = data_style-> 2610 } 2611 2612 delete data_style; 2613 delete _left_hatch_style; 2614 delete _right_hatch_style; 2615 delete error_style; 2616 ibins++; 2617 //ibins1D++; 2618 } if(bins2D* b2 = safe_cast<plottable 2619 //a_out << "tools::sg::plotter::upd 2620 zz += _zoffset(); // ibins = 0 back 2621 style* data_style = merge_bins_styl 2622 2623 update_bins2D_xy(a_out,*b2,*data_st 2624 2625 if(legends_automated.value()) { 2626 m_legend_strings.push_back(object 2627 style& _style = legend_style(m_le 2628 _style.color = data_style->color; 2629 _style.marker_style = data_style- 2630 _style.marker_size = data_style-> 2631 } 2632 2633 delete data_style; 2634 ibins++; 2635 } 2636 }} 2637 2638 //////////////////////////////////// 2639 /// funcs ////////////////////////// 2640 //////////////////////////////////// 2641 2642 {m_func_sep.clear(); 2643 //zz = 0; // Functions in front. 2644 unsigned int ifunc = 0; //used to get e 2645 tools_vforcit(plottable*,m_plottables,i 2646 plottable* object = *it; 2647 if(!object) continue; 2648 if(func1D* f1 = safe_cast<plottable,f 2649 zz += _zoffset(); 2650 style* data_style = merge_func_styl 2651 update_func1D_xy(a_out,*f1,*data_st 2652 if(legends_automated.value()) { 2653 m_legend_strings.push_back(object 2654 style& _style = legend_style(m_le 2655 _style.color = data_style->color; 2656 _style.marker_style = data_style- 2657 _style.marker_size = data_style-> 2658 } 2659 delete data_style; 2660 ifunc++; 2661 } else if(func2D* f2 = safe_cast<plot 2662 zz += _zoffset(); 2663 style* data_style = merge_func_styl 2664 update_func2D_xy(a_out,*f2,ifunc,*d 2665 if(legends_automated.value()) { 2666 m_legend_strings.push_back(object 2667 style& _style = legend_style(m_le 2668 _style.color = data_style->color; 2669 _style.marker_style = data_style- 2670 _style.marker_size = data_style-> 2671 } 2672 delete data_style; 2673 ifunc++; 2674 } 2675 }} 2676 2677 //////////////////////////////////// 2678 /// pointss //////////////////////// 2679 //////////////////////////////////// 2680 {m_points_sep.clear(); 2681 unsigned int ipoints = 0; //used to get 2682 tools_vforcit(plottable*,m_plottables,i 2683 plottable* object = *it; 2684 if(!object) continue; 2685 if(points2D* p2 = safe_cast<plottable 2686 2687 zz += _zoffset(); // ibins = 0 back 2688 style* data_style = merge_points_st 2689 update_points2D_xy(a_out,*p2,*data_ 2690 2691 if(legends_automated.value()) { 2692 m_legend_strings.push_back(object 2693 style& _style = legend_style(m_le 2694 _style.color = data_style->color; 2695 _style.modeling = data_style->mod 2696 _style.marker_style = data_style- 2697 _style.marker_size = data_style-> 2698 _style.point_size = data_style->p 2699 } 2700 2701 delete data_style; 2702 ipoints++; 2703 } 2704 }} 2705 } 2706 2707 if(m_shape==xyz) { 2708 2709 //////////////////////////////////// 2710 /// binss ////////////////////////// 2711 //////////////////////////////////// 2712 {m_bins_sep.clear(); 2713 m_errors_sep.clear(); 2714 unsigned int ibins = 0; //used to get e 2715 tools_vforcit(plottable*,m_plottables,i 2716 plottable* object = *it; 2717 if(!object) continue; 2718 if(safe_cast<plottable,bins1D>(*objec 2719 ibins++; 2720 } else if(bins2D* b2 = safe_cast<plot 2721 style* data_style = merge_bins_styl 2722 update_bins2D_xyz(a_out,*b2,ibins,* 2723 delete data_style; 2724 ibins++; 2725 } 2726 }} 2727 2728 //////////////////////////////////// 2729 /// funcs ////////////////////////// 2730 //////////////////////////////////// 2731 2732 {m_func_sep.clear(); 2733 unsigned int ifunc = 0; //used to get e 2734 tools_vforcit(plottable*,m_plottables,i 2735 plottable* object = *it; 2736 if(!object) continue; 2737 if(safe_cast<plottable,func1D>(*objec 2738 ifunc++; 2739 } else if(func2D* f2 = safe_cast<plot 2740 style* data_style = merge_func_styl 2741 update_func2D_xyz(a_out,*f2,ifunc,* 2742 delete data_style; 2743 ifunc++; 2744 } 2745 }} 2746 2747 //////////////////////////////////// 2748 /// pointss //////////////////////// 2749 //////////////////////////////////// 2750 {m_points_sep.clear(); 2751 unsigned int ipoints = 0; //used to get 2752 tools_vforcit(plottable*,m_plottables,i 2753 plottable* object = *it; 2754 if(!object) continue; 2755 if(points3D* p3 = safe_cast<plottable 2756 2757 style* data_style = merge_points_st 2758 update_points3D_xyz(a_out,*p3,*data 2759 2760 if(legends_automated.value()) { 2761 m_legend_strings.push_back(object 2762 style& _style = legend_style(m_le 2763 _style.color = data_style->color; 2764 _style.modeling = data_style->mod 2765 _style.marker_style = data_style- 2766 _style.marker_size = data_style-> 2767 _style.point_size = data_style->p 2768 } 2769 2770 delete data_style; 2771 ipoints++; 2772 } 2773 }} 2774 } 2775 2776 //////////////////////////////////// 2777 /// axes : ///////////////////////// 2778 //////////////////////////////////// 2779 // done before update_legends() which nee 2780 // the x_axis min/max if legends_origin_u 2781 // is unit_axis. 2782 2783 // axes : 2784 if(m_shape==xy){ 2785 if(x_axis_enforced.value()) { 2786 update_x_axis_2D(); 2787 m_x_axis.minimum_value = x_axis_min.v 2788 m_x_axis.maximum_value = x_axis_max.v 2789 m_x_axis.is_log = x_axis_is_log.value 2790 m_x_axis.update_sg(a_out); // So that 2791 m_x_axis.reset_touched(); 2792 } else { 2793 if(!nplottables) { 2794 m_x_axis.width = 0; 2795 } else { 2796 update_x_axis_2D(); 2797 update_axis(a_out,m_x_axis,m_x_axis 2798 } 2799 } 2800 2801 if(y_axis_enforced.value()) { 2802 update_y_axis_2D(); 2803 m_y_axis.minimum_value = y_axis_min.v 2804 m_y_axis.maximum_value = y_axis_max.v 2805 m_y_axis.is_log = y_axis_is_log.value 2806 m_y_axis.update_sg(a_out); // So that 2807 m_y_axis.reset_touched(); 2808 } else { 2809 if(!nplottables) { 2810 m_y_axis.width = 0; 2811 } else { 2812 update_y_axis_2D(); 2813 update_axis(a_out,m_y_axis,m_y_axis 2814 } 2815 } 2816 2817 if(z_axis_enforced.value()) { 2818 update_z_axis_2D(); 2819 m_z_axis.minimum_value = z_axis_min.v 2820 m_z_axis.maximum_value = z_axis_max.v 2821 m_z_axis.is_log = z_axis_is_log.value 2822 m_z_axis.update_sg(a_out); // So that 2823 m_z_axis.reset_touched(); 2824 } else { 2825 if(!nplottables) { 2826 m_z_axis.width = 0; 2827 } else { 2828 update_z_axis_2D(); 2829 } 2830 } 2831 } 2832 2833 if(m_shape==xyz){ 2834 if(x_axis_enforced.value()) { 2835 update_x_axis_3D(); 2836 m_x_axis.minimum_value = x_axis_min.v 2837 m_x_axis.maximum_value = x_axis_max.v 2838 m_x_axis.is_log = x_axis_is_log.value 2839 m_x_axis.update_sg(a_out); // So that 2840 m_x_axis.reset_touched(); 2841 } else { 2842 if(!nplottables) { 2843 m_x_axis.width = 0; 2844 } else { 2845 update_x_axis_3D(); 2846 update_axis(a_out,m_x_axis,m_x_axis 2847 } 2848 } 2849 2850 if(y_axis_enforced.value()) { 2851 update_y_axis_3D(); 2852 m_y_axis.minimum_value = y_axis_min.v 2853 m_y_axis.maximum_value = y_axis_max.v 2854 m_y_axis.is_log = y_axis_is_log.value 2855 m_y_axis.update_sg(a_out); // So that 2856 m_y_axis.reset_touched(); 2857 } else { 2858 if(!nplottables) { 2859 m_y_axis.width = 0; 2860 } else { 2861 update_y_axis_3D(); 2862 update_axis(a_out,m_y_axis,m_y_axis 2863 } 2864 } 2865 2866 if(z_axis_enforced.value()) { 2867 update_z_axis_3D(); 2868 m_z_axis.minimum_value = z_axis_min.v 2869 m_z_axis.maximum_value = z_axis_max.v 2870 m_z_axis.is_log = z_axis_is_log.value 2871 m_z_axis.update_sg(a_out); // So that 2872 m_z_axis.reset_touched(); 2873 } else { 2874 if(!nplottables) { 2875 m_z_axis.width = 0; 2876 } else { 2877 update_z_axis_3D(); 2878 update_axis(a_out,m_z_axis,m_z_axis 2879 } 2880 } 2881 } 2882 2883 if(nplottables) { 2884 // infos box is done before update_lege 2885 // because legends may be placed relati 2886 update_infos(a_out); 2887 } 2888 m_legend_sep.clear(); 2889 2890 if(!legends_automated) { 2891 m_legend_strings = legends_string.value 2892 } 2893 update_legends(a_out); 2894 2895 if(title_automated) { 2896 std::string _s; 2897 get_title(_s); 2898 title.value(_s); 2899 title.reset_touched(); //output field. 2900 } 2901 m_title_sep.clear(); 2902 if(nplottables) update_title(); 2903 2904 m_title_box_sep.clear(); 2905 if(nplottables) update_title_box(); 2906 2907 m_inner_frame_sep.clear(); 2908 if(inner_frame_enforced.value() || nplott 2909 if(m_shape==xy) { 2910 update_inner_frame_XY(); 2911 } else { 2912 update_inner_frame_XYZ(); 2913 } 2914 } 2915 2916 m_grid_sep.clear(); 2917 if(nplottables) { 2918 if(m_shape==xy) { 2919 update_grid_XY(); 2920 } else { 2921 update_grid_XYZ(); 2922 } 2923 } 2924 2925 m_cmap_axis.width = 0; 2926 m_cmap_cells_sep.clear(); 2927 if(m_bins_cmaps.size() && m_bins_cmaps[0] 2928 update_cmap(a_out,*(m_bins_cmaps[0])); 2929 } else if(m_points_cmaps.size() && m_poin 2930 update_cmap(a_out,*(m_points_cmaps[0])) 2931 } else if(m_func_cmaps.size() && m_func_c 2932 update_cmap(a_out,*(m_func_cmaps[0])); 2933 } 2934 2935 update_primitives(a_out); 2936 } 2937 2938 void get_value_axis_min_max(float a_Sw_mn,f 2939 if(a_Sw_mn>a_Sw_mx) { 2940 a_min = 0; 2941 a_max = 0; 2942 return; 2943 } 2944 // a_Sw_mx >= a_Sw_mn. 2945 if(a_is_log && (a_Sw_mn<=0) ) { //let dat 2946 a_min = a_Sw_mn; 2947 a_max = a_Sw_mx; 2948 return; 2949 } 2950 float mn; 2951 if(a_is_log) { 2952 if(value_bottom_margin.value()!=0) { 2953 float log_Sw_mn = flog10(a_Sw_mn); 2954 float log_Sw_mx = flog10(a_Sw_mx); 2955 float log_mn = log_Sw_mn - (log_Sw_mx 2956 mn = fpow(10,log_mn); 2957 } else { 2958 mn = a_Sw_mn; 2959 if(a_min_visible) { // arrang so that 2960 float log_Sw_mn = flog10(a_Sw_mn); 2961 mn = fpow(10,log_Sw_mn)*(1.0f-0.4f) 2962 } 2963 } 2964 } else { 2965 if(value_bottom_margin.value()!=0) { 2966 mn = a_Sw_mn - (a_Sw_mx-a_Sw_mn)*valu 2967 } else { 2968 if(a_min_visible) { 2969 // Arrange so that the bin with a_Sw_mn ( 2970 if(a_Sw_mn>0) { 2971 mn = 0; //PAW logic. 2972 } else if(a_Sw_mn==0) { 2973 mn = 0; //PAW logic. min bin will be an 2974 } else { 2975 mn = a_Sw_mn; // min bin will be anyway 2976 } 2977 } else { 2978 mn = a_Sw_mn; //min bin will be on 2979 } 2980 } 2981 } 2982 a_min = mn; 2983 2984 float mx; 2985 if(a_is_log) { 2986 if(value_top_margin.value()!=0) { 2987 float log_Sw_mn = flog10(a_Sw_mn); 2988 float log_Sw_mx = flog10(a_Sw_mx); 2989 float log_mx = log_Sw_mx + (log_Sw_mx 2990 mx = fpow(10,log_mx); 2991 } else { 2992 mx = a_Sw_mx; //max bin will be on to 2993 } 2994 } else { 2995 mx = a_Sw_mx + (a_Sw_mx-mn)*value_top_m 2996 //mx = a_Sw_mx + (a_Sw_mx-a_Sw_mn)*value_ 2997 } 2998 a_max = mx; 2999 } 3000 3001 void update_axes_data(std::ostream& a_out){ 3002 m_x_axis_data.set_min_value(0); 3003 m_x_axis_data.set_max_value(0); 3004 m_x_axis_data.set_is_log(x_axis_is_log); 3005 3006 m_y_axis_data.set_min_value(0); 3007 m_y_axis_data.set_max_value(0); 3008 m_y_axis_data.set_is_log(y_axis_is_log); 3009 3010 m_z_axis_data.set_min_value(0); 3011 m_z_axis_data.set_max_value(0); 3012 m_z_axis_data.set_is_log(z_axis_is_log); 3013 3014 if(!x_axis_automated) { //def = true 3015 m_x_axis_data.set_min_value(x_axis_min) 3016 m_x_axis_data.set_max_value(x_axis_max) 3017 } 3018 3019 if(!y_axis_automated) { 3020 m_y_axis_data.set_min_value(y_axis_min) 3021 m_y_axis_data.set_max_value(y_axis_max) 3022 } 3023 3024 if(!z_axis_automated) { 3025 m_z_axis_data.set_min_value(z_axis_min) 3026 m_z_axis_data.set_max_value(z_axis_max) 3027 } 3028 3029 bins1D* b1; 3030 bins2D* b2; 3031 3032 func1D* f1; 3033 func2D* f2; 3034 3035 points2D* p2; 3036 points3D* p3; 3037 3038 if(first_bins(b1,b2)) { 3039 3040 if(b1) { 3041 3042 if(x_axis_automated) { 3043 m_x_axis_data.set_min_value(b1->axi 3044 m_x_axis_data.set_max_value(b1->axi 3045 } 3046 3047 if(y_axis_automated) { 3048 //::printf("debug : value %g %g %d : 3049 // value_bottom_margin.value(),val 3050 // m_y_axis_data.is_log()); 3051 float Sw_mn,Sw_mx; 3052 b1->bins_Sw_range(Sw_mn,Sw_mx,value 3053 //::printf("debug : Sw %g %g\n",Sw_mn 3054 float mn,mx; 3055 get_value_axis_min_max(Sw_mn,Sw_mx, 3056 //::printf("debug : mn mx %g %g\n",mn 3057 m_y_axis_data.set_min_value(mn); 3058 m_y_axis_data.set_max_value(mx); 3059 3060 m_y_axis_data.adjust(); 3061 //::printf("debug : adjusted : mn mx 3062 } 3063 3064 } if(b2) { 3065 if(x_axis_automated) { 3066 m_x_axis_data.set_min_value(b2->x_a 3067 m_x_axis_data.set_max_value(b2->x_a 3068 } 3069 3070 if(y_axis_automated) { 3071 m_y_axis_data.set_min_value(b2->y_a 3072 m_y_axis_data.set_max_value(b2->y_a 3073 } 3074 3075 if(z_axis_automated) { 3076 float Sw_mn,Sw_mx; 3077 b2->bins_Sw_range(Sw_mn,Sw_mx,value 3078 float mn,mx; 3079 get_value_axis_min_max(Sw_mn,Sw_mx, 3080 m_z_axis_data.set_min_value(mn); 3081 m_z_axis_data.set_max_value(mx); 3082 3083 m_z_axis_data.adjust(); 3084 } 3085 } /*else if(f_binsList[0]->getDimension 3086 //FIXME : should do something. 3087 } else { 3088 // Unusual case. 3089 }*/ 3090 3091 } else if(first_points(p2,p3)) { 3092 if(p2) { 3093 if(x_axis_automated) { 3094 m_x_axis_data.set_min_value(p2->x_a 3095 m_x_axis_data.set_max_value(p2->x_a 3096 } 3097 if(y_axis_automated) { 3098 float ymn = p2->y_axis_min(); 3099 float ymx = p2->y_axis_max(); 3100 // For pawex22 ? 3101 //m_y_axis_data.set_min_value(ymn*1 3102 //m_y_axis_data.set_max_value(ymx*1 3103 m_y_axis_data.set_min_value(ymn); 3104 m_y_axis_data.set_max_value(ymx); 3105 } 3106 } else if(p3) { 3107 3108 if(x_axis_automated) { 3109 m_x_axis_data.set_min_value(p3->x_a 3110 m_x_axis_data.set_max_value(p3->x_a 3111 } 3112 3113 if(y_axis_automated) { 3114 m_y_axis_data.set_min_value(p3->y_a 3115 m_y_axis_data.set_max_value(p3->y_a 3116 } 3117 3118 if(z_axis_automated) { 3119 m_z_axis_data.set_min_value(p3->z_a 3120 m_z_axis_data.set_max_value(p3->z_a 3121 } 3122 } 3123 3124 } else if(first_func(f1,f2)) { 3125 3126 if(f1) { 3127 3128 if(x_axis_automated) { 3129 float xmn = f1->x_min(); 3130 float xmx = f1->x_max(); 3131 if(xmx<=xmn) { 3132 xmn = -1; 3133 xmx = 1; 3134 } 3135 m_x_axis_data.set_min_value(xmn); 3136 m_x_axis_data.set_max_value(xmx); 3137 } 3138 3139 if(y_axis_automated) { 3140 float xmn = m_x_axis_data.min_value 3141 float xmx = m_x_axis_data.max_value 3142 unsigned int nstp = f1->x_steps(); 3143 nstp = nstp <=0 ? curve_number_of_p 3144 3145 float df = (xmx - xmn)/nstp; 3146 bool problem = false; 3147 float vmin; 3148 if(!f1->value(xmn,vmin)) problem = 3149 float vmax = vmin; 3150 for(unsigned int ibin=0;ibin<=nstp; 3151 float xx = xmn + ibin * df; 3152 float val; 3153 if(!f1->value(xx,val)) problem = 3154 vmax = mx<float>(vmax,val); 3155 vmin = mn<float>(vmin,val); 3156 } 3157 if(problem) { 3158 a_out << "tools::sg::plotter :" 3159 << " problem when getting s 3160 << std::endl; 3161 } 3162 m_y_axis_data.set_min_value(vmin); 3163 m_y_axis_data.set_max_value(vmax); 3164 m_y_axis_data.adjust(); 3165 } 3166 3167 } else if(f2) { 3168 if(x_axis_automated) { 3169 float xmn = f2->x_min(); 3170 float xmx = f2->x_max(); 3171 if(xmx<=xmn) { 3172 xmn = -1; 3173 xmx = 1; 3174 } 3175 m_x_axis_data.set_min_value(xmn); 3176 m_x_axis_data.set_max_value(xmx); 3177 } 3178 3179 if(y_axis_automated) { 3180 float ymn = f2->y_min(); 3181 float ymx = f2->y_max(); 3182 if(ymx<=ymn) { 3183 ymn = -1; 3184 ymx = 1; 3185 } 3186 m_y_axis_data.set_min_value(ymn); 3187 m_y_axis_data.set_max_value(ymx); 3188 } 3189 3190 if(z_axis_automated) { 3191 3192 float xmn = m_x_axis_data.min_value 3193 float xmx = m_x_axis_data.max_value 3194 int nx = f2->x_steps(); 3195 nx = nx <=0 ? curve_number_of_point 3196 3197 float ymn = m_y_axis_data.min_value 3198 float ymx = m_y_axis_data.max_value 3199 int ny = f2->y_steps(); 3200 ny = ny <=0 ? curve_number_of_point 3201 3202 float dfx = (xmx - xmn)/nx; 3203 float dfy = (ymx - ymn)/ny; 3204 3205 bool problem = false; 3206 float vmin; 3207 if(!f2->value(xmn,ymn,vmin)) proble 3208 float vmax = vmin; 3209 for(int jbin=ny-1;jbin>=0;jbin--) { 3210 for(int ibin=nx-1;ibin>=0;ibin--) 3211 float xx = xmn + ibin * dfx; 3212 float yy = ymn + jbin * dfy; 3213 float val; 3214 if(!f2->value(xx,yy,val)) probl 3215 vmin = mn<float>(vmin,val); 3216 vmax = mx<float>(vmax,val); 3217 } 3218 } 3219 if(problem) { 3220 a_out << "tools::sg::plotter :" 3221 << " problem when getting s 3222 << std::endl; 3223 } 3224 m_z_axis_data.set_min_value(vmin); 3225 m_z_axis_data.set_max_value(vmax); 3226 m_z_axis_data.adjust(); 3227 } 3228 } 3229 } 3230 } 3231 void update_shape(){ 3232 m_shape = get_shape(); 3233 //uuuu if(shapeAutomated) { 3234 // shape.setValue(m_shape); 3235 //} 3236 } 3237 3238 void update_axis(std::ostream& a_out,sg::ax 3239 a_axis.minimum_value = a_data.min_value() 3240 a_axis.maximum_value = a_data.max_value() 3241 a_axis.is_log = a_data.is_log(); 3242 a_axis.update_sg(a_out); // So that the g 3243 a_axis.reset_touched(); 3244 } 3245 3246 void update_x_axis_2D(){ 3247 float XSIZ = width; 3248 float XMGL = left_margin; 3249 float XMGR = right_margin; 3250 float wData = XSIZ-XMGL-XMGR; 3251 3252 //m_x_axis.verbose.setValue(verbose); 3253 m_x_axis.tick_up = true; 3254 m_x_axis.width = wData; 3255 3256 {text_style& style = m_x_axis.labels_style 3257 if(!style.enforced.value()) { //gopaw may 3258 style.x_orientation = vec3f(1,0,0); 3259 style.y_orientation = vec3f(0,1,0); 3260 style.hjust = center; 3261 style.vjust = top; 3262 }} 3263 3264 {text_style& style = m_x_axis.title_style( 3265 style.x_orientation = vec3f(1,0,0); 3266 style.y_orientation = vec3f(0,1,0); 3267 style.hjust = m_x_axis.title_hjust; 3268 style.vjust = top;} 3269 3270 {text_style& style = m_x_axis.mag_style(); 3271 style.hjust = left; 3272 style.vjust = bottom;} 3273 3274 m_x_axis_matrix.set_translate(0,0,_zaxis( 3275 } 3276 3277 void update_y_axis_2D(){ 3278 float YSIZ = height; 3279 float YMGL = bottom_margin; 3280 float YMGU = top_margin; 3281 float hData = YSIZ-YMGL-YMGU; 3282 3283 //m_x_axis.verbose.setValue(verbose); 3284 m_y_axis.tick_up.value(true); 3285 m_y_axis.width.value(hData); 3286 3287 {text_style& style = m_y_axis.labels_style 3288 if(!style.enforced.value()) { 3289 style.x_orientation = vec3f(0,1,0); 3290 style.y_orientation = vec3f(1,0,0); 3291 style.hjust = right; 3292 style.vjust = middle; 3293 }} 3294 3295 {text_style& style = m_y_axis.title_style( 3296 style.x_orientation = vec3f(1,0,0); 3297 style.y_orientation = vec3f(0,-1,0); 3298 style.hjust = m_y_axis.title_hjust; 3299 style.vjust = bottom;} 3300 3301 {text_style& style = m_y_axis.mag_style(); 3302 style.x_orientation = vec3f(0,1,0); 3303 style.y_orientation = vec3f(1,0,0); 3304 style.hjust = right; 3305 style.vjust = bottom;} 3306 3307 {mat4f& mtx = m_y_axis_matrix.mtx.value(); 3308 mtx.set_translate(0,0,_zaxis()); 3309 mtx.mul_rotate(0,1,0,fpi()); 3310 mtx.mul_rotate(0,0,1,fhalf_pi());} 3311 } 3312 3313 void update_z_axis_2D(){ 3314 m_z_axis.width = 0; 3315 m_z_axis_matrix.set_identity(); 3316 } 3317 3318 void update_x_axis_3D(){ 3319 float XSIZ = width; 3320 float XMGL = left_margin; 3321 float XMGR = right_margin; 3322 float wData = XSIZ-XMGL-XMGR; 3323 3324 //m_x_axis.verbose.setValue(verbose); 3325 m_x_axis.tick_up = false; 3326 m_x_axis.width = wData; 3327 3328 {text_style& style = m_x_axis.labels_style 3329 if(!style.enforced.value()) { 3330 //style->font_name = SbFont_Hershey; // 3331 style.x_orientation = vec3f(1,0,0); 3332 style.y_orientation = vec3f(0,1,0); 3333 style.hjust = center; 3334 style.vjust = top; 3335 }} 3336 3337 {text_style& style = m_x_axis.title_style( 3338 style.x_orientation = vec3f(1,0,0); 3339 style.y_orientation = vec3f(0,1,0); 3340 style.hjust = right; 3341 style.vjust = top;} 3342 3343 //{text_style& style = m_x_axis.mag_style( 3344 // style.hjust = left; 3345 // style.vjust = bottom;} 3346 3347 m_x_axis_matrix.set_rotate(1,0,0,fhalf_pi 3348 3349 } 3350 3351 void update_y_axis_3D(){ 3352 float YSIZ = height; 3353 float YMGL = bottom_margin; 3354 float YMGU = top_margin; 3355 float hData = YSIZ-YMGL-YMGU; 3356 3357 //m_x_axis.verbose.setValue(verbose); 3358 m_y_axis.tick_up = false; 3359 m_y_axis.width = hData; 3360 3361 {text_style& style = m_y_axis.labels_style 3362 if(!style.enforced.value()) { 3363 //style->fontName.setValue(SbFont_Hersh 3364 style.x_orientation = vec3f(-1,0,0); 3365 style.y_orientation = vec3f( 0,1,0); 3366 style.hjust = center; 3367 style.vjust = top; 3368 }} 3369 3370 {text_style& style = m_y_axis.title_style( 3371 style.x_orientation = vec3f(-1,0,0); 3372 style.y_orientation = vec3f( 0,1,0); 3373 style.hjust = left; 3374 style.vjust = top;} 3375 3376 //{text_style& style = m_y_axis.mag_style( 3377 // style.x_orientation = vec3f(0,1,0); 3378 // style.y_orientation = vec3f(1,0,0); 3379 // style.hjust = right; 3380 // style.vjust = bottom;} 3381 3382 {mat4f& mtx = m_y_axis_matrix.mtx.value(); 3383 mtx.set_rotate(0,1,0,fhalf_pi()); 3384 mtx.mul_rotate(0,0,1,fhalf_pi());} 3385 } 3386 3387 void update_z_axis_3D(){ 3388 float ZSIZ = depth; 3389 float ZMGD = down_margin; 3390 float ZMGU = up_margin; 3391 float dData = ZSIZ-ZMGD-ZMGU; 3392 3393 m_z_axis.tick_up = false; 3394 m_z_axis.width = dData; 3395 3396 {text_style& style = m_z_axis.labels_style 3397 if(!style.enforced.value()) { 3398 //style->fontName.setValue(SbFont_Hersh 3399 style.x_orientation = vec3f(0,1,0); 3400 style.y_orientation = vec3f(1,0,0); 3401 style.hjust = right; 3402 style.vjust = middle; 3403 }} 3404 3405 {text_style& style = m_z_axis.title_style( 3406 style.x_orientation = vec3f(0,1,0); 3407 style.y_orientation = vec3f(1,0,0); 3408 style.hjust = right; 3409 style.vjust = bottom;} 3410 3411 //{text_style& style = m_z_axis.mag_style( 3412 // style.hjust = center; 3413 // style.vjust = bottom;} 3414 3415 {mat4f& mtx = m_z_axis_matrix.mtx.value(); 3416 mtx.set_translate(0,m_y_axis.width.value( 3417 mtx.mul_rotate(0,0,1,-fhalf_pi()); 3418 mtx.mul_rotate(0,1,0,-fhalf_pi());} 3419 3420 } 3421 3422 void update_cmap(std::ostream& a_out,const 3423 if(!colormap_visible.value()) return; 3424 3425 size_t valn = a_cmap.valn(); 3426 if(!valn) return; 3427 size_t coln = a_cmap.colorn(); 3428 if(!coln) return; 3429 3430 float XSIZ = width; 3431 float XMGL = left_margin; 3432 float XMGR = right_margin; 3433 float wData = XSIZ-XMGL-XMGR; 3434 3435 float YSIZ = height; 3436 float YMGL = bottom_margin; 3437 float YMGU = top_margin; 3438 float hData = YSIZ-YMGL-YMGU; 3439 3440 float hcmap = hData; 3441 3442 {mat4f& mtx = m_cmap_matrix.mtx.value(); 3443 if(m_shape==xy) { 3444 mtx = m_layout.mtx.value(); 3445 mtx.mul_translate(0,0,_zgrid()); 3446 } else { 3447 float ZSIZ = depth; 3448 float ZMGD = down_margin; 3449 float ZMGU = up_margin; 3450 float dData = ZSIZ-ZMGD-ZMGU; 3451 hcmap = dData; 3452 if(colormap_attached.value()) { 3453 mtx = m_layout.mtx.value(); 3454 mtx.mul_rotate(1,0,0,90.0F*fdeg2rad() 3455 } else { //OpenPAW 3456 float zz = -depth*0.5f; 3457 mtx.set_translate(-XSIZ/2+XMGL,-YSIZ/ 3458 } 3459 }} 3460 3461 float w = XMGR*0.3F; 3462 float xx = wData+XMGR*0.1F; 3463 float zz = 0; 3464 3465 float yy = 0; 3466 float h = hcmap/float(coln); 3467 3468 // colored cells : 3469 {m_cmap_cells_sep.clear(); 3470 m_cmap_cells_sep.add(new normal); 3471 for(unsigned int index=0;index<coln;index 3472 rgba* mat = new rgba(); 3473 mat->color = a_cmap.color(index); 3474 m_cmap_cells_sep.add(mat); 3475 3476 vertices* vtxs = new vertices; 3477 vtxs->mode = gl::triangle_fan(); 3478 m_cmap_cells_sep.add(vtxs); 3479 3480 vtxs->add(xx ,yy ,zz); 3481 vtxs->add(xx + w ,yy ,zz); 3482 vtxs->add(xx + w ,yy + h ,zz); 3483 vtxs->add(xx ,yy + h ,zz); 3484 3485 yy += h; 3486 }} 3487 3488 // surrounding box : 3489 {rgba* mat = new rgba(); 3490 mat->color = colorf_black(); 3491 m_cmap_cells_sep.add(mat); 3492 3493 draw_style* ds = new draw_style; 3494 ds->style = draw_lines; 3495 ds->line_pattern = line_solid; 3496 ds->line_width = 1; 3497 m_cmap_cells_sep.add(ds); 3498 3499 vertices* vtxs = new vertices; 3500 vtxs->mode = gl::line_strip(); 3501 m_cmap_cells_sep.add(vtxs); 3502 3503 vtxs->add(xx ,0 ,zz); 3504 vtxs->add(xx + w ,0 ,zz); 3505 vtxs->add(xx + w ,hcmap ,zz); 3506 vtxs->add(xx ,hcmap ,zz); 3507 vtxs->add(xx ,0 ,zz);} 3508 3509 if(!colormap_axis_visible.value()) { 3510 m_cmap_axis.width = 0; 3511 } else { 3512 3513 // right axis : 3514 mat4f& mtx = m_cmap_axis_matrix.mtx.value 3515 mtx.set_identity(); 3516 3517 zz += _zoffset()*0.01f; 3518 3519 if(safe_cast<base_colormap,by_value_color 3520 if(colormap_axis_labeling.value()==cell 3521 if((valn+1)==coln) { // <col> <num> < 3522 mtx.set_translate(xx+w,h,zz); 3523 } else { 3524 mtx.set_translate(xx+w,0,zz); 3525 } 3526 } else { 3527 mtx.set_translate(xx+w,0,zz); 3528 } 3529 } else { //grey_scale,grey_scale_inverse, 3530 mtx.set_translate(xx+w,0,zz); 3531 } 3532 3533 mtx.mul_rotate(0,0,1,fhalf_pi()); 3534 3535 m_cmap_axis.title = ""; 3536 m_cmap_axis.tick_up = true; 3537 //m_cmap_axis.label_to_axis = 0.01F; 3538 //m_cmap_axis.label_height = 0.10F; 3539 //m_cmap_axis.ttf_scale = 10.0F; 3540 3541 if(safe_cast<base_colormap,by_value_color 3542 if(colormap_axis_labeling.value()==cell 3543 if((valn+1)==coln) { // <col> <num> < 3544 m_cmap_axis.width = hcmap-2*h; 3545 m_cmap_axis.modeling = tick_modelin 3546 m_cmap_axis.tick_number = uint32(va 3547 m_cmap_axis.labels.clear(); 3548 m_cmap_axis.coords.clear(); 3549 for(unsigned int index=0;index<valn 3550 //FIXME : for the labels, have a 3551 char tmp[32]; 3552 snpf(tmp,sizeof(tmp),"%g",a_cmap. 3553 m_cmap_axis.labels.add(tmp); 3554 m_cmap_axis.coords.add(h*index); 3555 } 3556 } else if((coln+1)==valn) { // <num> 3557 m_cmap_axis.width = hcmap; 3558 m_cmap_axis.modeling = tick_modelin 3559 m_cmap_axis.tick_number = uint32(va 3560 m_cmap_axis.labels.clear(); 3561 m_cmap_axis.coords.clear(); 3562 for(unsigned int index=0;index<valn 3563 //FIXME : for the labels, have a 3564 char tmp[32]; 3565 snpf(tmp,sizeof(tmp),"%g",a_cmap. 3566 m_cmap_axis.labels.add(tmp); 3567 m_cmap_axis.coords.add(h*index); 3568 } 3569 } else { 3570 a_out << "tools::sg::plotter::updat 3571 << " inconsistent by value co 3572 << std::endl; 3573 } 3574 } else { 3575 m_cmap_axis.modeling = tick_modeling_ 3576 m_cmap_axis.width = hcmap; 3577 m_cmap_axis.minimum_value = a_cmap.va 3578 m_cmap_axis.maximum_value = a_cmap.va 3579 } 3580 } else { //grey_scale,grey_scale_inverse, 3581 m_cmap_axis.modeling = tick_modeling_hi 3582 m_cmap_axis.width = hcmap; 3583 m_cmap_axis.minimum_value = a_cmap.valu 3584 m_cmap_axis.maximum_value = a_cmap.valu 3585 } 3586 3587 {text_style& style = m_cmap_axis.labels_st 3588 style.x_orientation = vec3f(0,-1,0); 3589 style.y_orientation = vec3f(1,0,0); 3590 style.hjust = left; 3591 style.vjust = middle;} 3592 3593 {text_style& style = m_cmap_axis.mag_style 3594 style.hjust = center; 3595 style.vjust = bottom;} 3596 3597 }//end axis 3598 } 3599 3600 void update_primitives(std::ostream& a_out) 3601 // if(primitives_enforced.value()) { 3602 m_primitives_sep.clear(); 3603 tools_vforcit(plotprim*,m_primitives,it 3604 if(plottable_text* ptext = safe_cast< 3605 update_primitive_text(*ptext); 3606 } else if(plottable_box* pbox = safe_ 3607 update_primitive_box(a_out,*pbox); 3608 } else if(plottable_ellipse* pellipse 3609 update_primitive_ellipse(a_out,*pel 3610 } else if(plottable_img* pimg = safe_ 3611 update_primitive_img(a_out,*pimg); 3612 } 3613 } 3614 //} 3615 } 3616 3617 protected: //vis bins 3618 void update_bins1D_xy(std::ostream& a_out, 3619 const bins1D& a_bins, 3620 const style& a_data_s 3621 const style& a_left_h 3622 const style& a_right_ 3623 const style& a_errors 3624 int a_index, 3625 /*SoStyle& aGraphicStyl 3626 int aIndex1D, 3627 const std::vector<SbP 3628 const SbPList& a_bins 3629 bool /*aSuperpose*/, 3630 const rep_box& a_box_ 3631 const rep_box& a_box_ 3632 float a_zz){ 3633 3634 //char sid[128]; 3635 //::sprintf(sid,"tools::sg::bins1D/0x%lx" 3636 // (unsigned long)const_cast<bins1D*>(&a 3637 3638 //bool hbe = a_bins.has_entries_per_bin(); 3639 3640 float bmin = 0; 3641 float bmax = 0; 3642 3643 size_t xnbin = a_bins.bins(); 3644 std::vector<rep_bin1D> bins(xnbin); 3645 {bool first = true; 3646 for(size_t ibin=0;ibin<xnbin;ibin++) { 3647 //if(hbe && (a_bins.bin_entries(size_t(ib 3648 float val = a_bins.bin_Sw(int(ibin)); 3649 float xx = float(a_bins.bin_lower_edge( 3650 float xe = float(a_bins.bin_upper_edge( 3651 bins[ibin] = rep_bin1D(xx,xe,0,val); 3652 if(first) { 3653 first = false; 3654 bmin = val; 3655 bmax = val; 3656 } else { 3657 bmin = mn<float>(bmin,val); 3658 bmax = mx<float>(bmax,val); 3659 } 3660 }} 3661 3662 //a_bins.bins_Sw_range(bmin,bmax,false); 3663 3664 //modeling_profile could override errors_ 3665 bool errors_visible = a_errors_style.visi 3666 3667 if(a_data_style.visible) { 3668 3669 painting_policy painting = a_data_style 3670 if(painting==painting_by_value) { 3671 m_bins_cmaps[a_index] = new by_value_ 3672 } else if( (painting==painting_grey_sca 3673 (painting==painting_grey_sca 3674 (painting==painting_violet_t 3675 {float dbins = bmax-bmin; 3676 if(dbins!=0.0F) { 3677 for(size_t index=0;index<xnbin;inde 3678 }} 3679 if(painting==painting_grey_scale) { 3680 m_bins_cmaps[a_index] = new grey_sc 3681 } else if(painting==painting_grey_sca 3682 m_bins_cmaps[a_index] = new grey_sc 3683 } else if(painting==painting_violet_t 3684 m_bins_cmaps[a_index] = new violet_ 3685 } 3686 } else { 3687 m_bins_cmaps[a_index] = new const_col 3688 } 3689 3690 if(a_bins.is_profile()) { 3691 // enforce with a_data_style, a bins 3692 // rep_bins1D_xy_points 3693 // AND : 3694 // rep_errors_plus for bins rep. 3695 // NOTE : a_data_style.modeling not u 3696 //printf("debug : bins is profile : m 3697 3698 style data_style = a_data_style; 3699 data_style.modeling = modeling_marker 3700 rep_bins1D_xy_points(a_out,data_style 3701 3702 std::vector<float> bars(xnbin); 3703 for(size_t ibin=0;ibin<xnbin;ibin++) 3704 3705 rep_errors_plus_xy(a_out,a_data_style 3706 errors_visible = false; 3707 3708 } else { 3709 3710 const std::string& modeling = a_data_ 3711 3712 //bool one_node = false; 3713 //bool oneNode = false; 3714 //{int nlimit = aGraphicStyle.multiNod 3715 //if(nlimit!=NoLimit) { 3716 // oneNode = (xnbin>nlimit?true:fals 3717 //}} 3718 3719 bool _bar_chart = false; 3720 3721 //char sid_bin[128]; 3722 //::sprintf(sid_bin,"SbBin1D/0x%lx",( 3723 3724 if((modeling==modeling_points())||(mo 3725 //if(oneNode) { 3726 // rep_bins1D_xy_points_one(binsNo 3727 // bins,a_box 3728 //} else { 3729 rep_bins1D_xy_points(a_out,a_data 3730 *(m_bins_cma 3731 bins,a_box_x 3732 //} 3733 } else if(modeling==modeling_boxes()) 3734 //if(oneNode) { 3735 // rep_bins1D_xy_boxes_one(binsNod 3736 // bins,a_box_ 3737 //} else { 3738 rep_bins1D_xy_boxes(a_data_style, 3739 *(m_bins_cmap 3740 bins,a_box_x, 3741 ); 3742 //} 3743 3744 } else if(modeling==modeling_wire_box 3745 //if(oneNode) { 3746 // rep_bins1D_xy_wire_boxes_one(bi 3747 // bins,a 3748 //} else { 3749 rep_bins1D_xy_wire_boxes(a_data_s 3750 //} 3751 } else if(modeling==modeling_bar_char 3752 _bar_chart = true; 3753 //if(oneNode) { 3754 // rep_bins1D_xy_wire_boxes_one(bi 3755 // bins,a 3756 //} else { 3757 rep_bins1D_xy_wire_boxes(a_data_s 3758 //} 3759 3760 } else if(modeling==modeling_lines()) 3761 rep_bins1D_xy_lines_one(a_data_styl 3762 } else if(modeling==modeling_curve()) 3763 rep_bins1D_xy_curve_one(a_out,a_dat 3764 3765 } else if(modeling==modeling_top_line 3766 style _style;_style.color = colorf_ 3767 rep_bins1D_xy_boxes(_style,*(m_bins 3768 rep_bins1D_xy_top_lines(a_data_styl 3769 3770 } else { //default modeling==modeling 3771 rep_bins1D_xy_top_lines(a_data_styl 3772 3773 } 3774 3775 hatching_policy hatching = a_data_sty 3776 //::printf("debug : bins1D %d hatching : %d 3777 if(hatching!=hatching_none) { 3778 // WARNING : must come AFTER rep_bi 3779 if((hatching==hatching_right)||((ha 3780 //if(oneNode) { 3781 //repHatch1D_xy_one(binsNode,aR 3782 //} else { 3783 rep_hatch1D_xy(a_right_hatch_st 3784 //} 3785 } 3786 if((hatching==hatching_left)||((hat 3787 //if(oneNode) { 3788 //repHatch1D_xy_one(binsNode,aL 3789 //} else { 3790 rep_hatch1D_xy(a_left_hatch_sty 3791 //} 3792 } 3793 } 3794 3795 } //end !is_profile. 3796 } //end data_style visible 3797 3798 // Errors : 3799 if(errors_visible) { 3800 std::vector<float> bars(xnbin); 3801 for(size_t ibin=0;ibin<xnbin;ibin++) ba 3802 const std::string& modeling = a_errors_ 3803 if(modeling==modeling_plus()) { 3804 rep_errors_plus_xy(a_out,a_errors_sty 3805 } else { //modeling_I() 3806 rep_errors_I_xy(a_out,a_errors_style, 3807 } 3808 } 3809 3810 } 3811 3812 static bool bins2D_to_func(const bins2D& a_ 3813 unsigned int xn = a_bins.x_bins(); 3814 float xmn = a_bins.x_axis_min(); 3815 float xmx = a_bins.x_axis_max(); 3816 unsigned int yn = a_bins.y_bins(); 3817 float ymn = a_bins.y_axis_min(); 3818 float ymx = a_bins.y_axis_max(); 3819 3820 float dx = (xmx-xmn)/xn; 3821 float dy = (ymx-ymn)/yn; 3822 int ibin = (int)((a_X-xmn)/dx); 3823 int jbin = (int)((a_Y-ymn)/dy); 3824 3825 if((ibin<0)||(ibin>=int(xn))) {a_value=0; 3826 if((jbin<0)||(jbin>=int(yn))) {a_value=0; 3827 3828 float xx_0 = a_bins.bin_lower_edge_x(ibin 3829 //float xe_0 = a_bins.bin_upper_edge_x(ib 3830 float xx_1 = a_bins.bin_lower_edge_x(ibin 3831 //float xe_1 = a_bins.bin_upper_edge_x(ib 3832 3833 float yy_0 = a_bins.bin_lower_edge_y(jbin 3834 //float ye_0 = a_bins.bin_upper_edge_y(jb 3835 float yy_1 = a_bins.bin_lower_edge_y(jbin 3836 //float ye_1 = a_bins.bin_upper_edge_y(jb 3837 3838 float val1 = a_bins.bin_Sw(ibin,jbin); 3839 float val2 = a_bins.bin_Sw(ibin+1,jbin); 3840 //float val3 = a_bins.getBinSumOfWeights( 3841 float val4 = a_bins.bin_Sw(ibin,jbin+1); 3842 3843 // Interpolate : 3844 vec3f p1(xx_0,yy_0,val1); 3845 vec3f p2(xx_1,yy_0,val2); 3846 //vec3f p3(xx_1,yy_1,val3); 3847 vec3f p4(xx_0,yy_1,val4); 3848 3849 //FIXME : case of (x,y) in (p2,p3,p4) 3850 3851 plane<vec3f> _plane(p1,p2,p4); 3852 vec3f pt; 3853 line<vec3f> _line(vec3f(a_X,a_Y,0),vec3f( 3854 _plane.intersect(_line,pt); 3855 3856 a_value = pt[2]; 3857 return true; 3858 } 3859 3860 typedef struct { 3861 const func2D* m_func2D; 3862 const bins2D* m_bins2D; 3863 double m_limits[4]; 3864 double m_limits_in[4]; 3865 bool m_problem; 3866 } SbFunc; 3867 3868 static double bins2D_to_contour(double a_X, 3869 SbFunc* func =(SbFunc*)aData; 3870 if( (a_X<func->m_limits_in[0])|| 3871 (a_X>func->m_limits_in[1])|| 3872 (a_Y<func->m_limits_in[2])|| 3873 (a_Y>func->m_limits_in[3]) 3874 ) return -FLT_MAX; 3875 float value; 3876 if(!bins2D_to_func(*(func->m_bins2D),(flo 3877 return value; 3878 } 3879 3880 static double log_bins2D_to_contour(double 3881 SbFunc* func =(SbFunc*)aData; 3882 if( (a_X<func->m_limits_in[0])|| 3883 (a_X>func->m_limits_in[1])|| 3884 (a_Y<func->m_limits_in[2])|| 3885 (a_Y>func->m_limits_in[3]) 3886 ) return -FLT_MAX; 3887 float value; 3888 if(!bins2D_to_func(*(func->m_bins2D),(flo 3889 return take_log(value); 3890 } 3891 3892 void update_bins2D_xy(std::ostream& a_out, 3893 const bins2D& a_bins, 3894 const style& a_data_s 3895 int a_index, 3896 const rep_box& a_box_ 3897 const rep_box& a_box_ 3898 const rep_box& a_box_ 3899 float a_zz){ 3900 3901 //a_out << "tools::sg::update_bins2D_xy : 3902 3903 if(!a_data_style.visible) return; 3904 3905 //a_out << "tools::sg::update_bins2D_xy : 3906 3907 unsigned int xnbin = a_bins.x_bins(); 3908 unsigned int ynbin = a_bins.y_bins(); 3909 3910 const std::string& modeling = a_data_styl 3911 3912 if( (modeling==modeling_curve()) || (mode 3913 3914 a_out << "tools::sg::update_bins2D_xy : 3915 3916 painting_policy painting = a_data_style 3917 3918 float zmin = a_box_z.m_pos; 3919 float dz = a_box_z.m_width; 3920 bool zlog = a_box_z.m_log; 3921 3922 float xmn = m_x_axis_data.min_value(); 3923 float xmx = m_x_axis_data.max_value(); 3924 float ymn = m_y_axis_data.min_value(); 3925 float ymx = m_y_axis_data.max_value(); 3926 3927 clist_contour list_contour; 3928 //int nFir = 32; 3929 int nFir = 128; 3930 list_contour.set_first_grid(nFir,nFir); 3931 //int nSec = 256; 3932 int nSec = 512; //slower than 256 3933 list_contour.set_secondary_grid(nSec,nS 3934 3935 double limits[4]; 3936 // User limits : 3937 limits[0] = xmn; 3938 limits[1] = xmx; 3939 limits[2] = ymn; 3940 limits[3] = ymx; 3941 3942 SbFunc sbFunc; 3943 sbFunc.m_func2D = 0; 3944 sbFunc.m_problem = false; 3945 sbFunc.m_bins2D = &a_bins; 3946 sbFunc.m_limits_in[0] = limits[0]; 3947 sbFunc.m_limits_in[1] = limits[1]; 3948 sbFunc.m_limits_in[2] = limits[2]; 3949 sbFunc.m_limits_in[3] = limits[3]; 3950 3951 // Extend the grid to have some borders 3952 int n = nSec - 2 * 10; 3953 double dx = (limits[1]-limits[0]) /n; 3954 double dy = (limits[3]-limits[2]) /n; 3955 limits[0] = limits[0] - 10 * dx; 3956 limits[1] = limits[1] + 10 * dx; 3957 limits[2] = limits[2] - 10 * dy; 3958 limits[3] = limits[3] + 10 * dy; 3959 3960 sbFunc.m_limits[0] = limits[0]; 3961 sbFunc.m_limits[1] = limits[1]; 3962 sbFunc.m_limits[2] = limits[2]; 3963 sbFunc.m_limits[3] = limits[3]; 3964 3965 list_contour.set_limits(limits); 3966 3967 if(levels.size()) { 3968 size_t zn = levels.size(); 3969 std::vector<double> zs(zn); 3970 for(size_t zi=0;zi<zn;zi++) zs[zi] = 3971 list_contour.set_planes(zs); 3972 } else { 3973 unsigned int zn = number_of_levels.va 3974 if(zn<=0) zn = 1; 3975 std::vector<double> zs(zn+1); 3976 float zmax = zmin + dz; 3977 double zd = (zmax-zmin)/zn; 3978 for(unsigned int zi=0;zi<=zn;zi++) zs 3979 list_contour.set_planes(zs); 3980 } 3981 3982 if(zlog) 3983 list_contour.set_field_fcn(log_bins2D 3984 else 3985 list_contour.set_field_fcn(bins2D_to_ 3986 3987 #ifdef INLIBS_SG_PLOTTER_TIMING 3988 atime _start = atime::now(); 3989 #endif 3990 list_contour.ccontour::generate(); 3991 #ifdef INLIBS_SG_PLOTTER_TIMING 3992 a_out << "tools::sg::update_bins2D_xy : 3993 _start = atime::now(); 3994 #endif 3995 3996 if(!list_contour.compact_strips ()) { 3997 a_out << "tools::sg::plotter::updateB 3998 } else { 3999 #ifdef INLIBS_SG_PLOTTER_TIMING 4000 a_out << "tools::sg::update_bins2D_xy 4001 #endif 4002 if( (painting==painting_by_level) || 4003 m_bins_cmaps[a_index] = new by_valu 4004 //bool zlog = a_box_z.m_log; 4005 if(zlog) m_bins_cmaps[a_index]->set 4006 } else { 4007 m_bins_cmaps[a_index] = new const_c 4008 } 4009 4010 if(modeling==modeling_filled_curve()) 4011 rep_contour_xy_filled(a_out,a_data_ 4012 painting,*(m_ 4013 list_contour, 4014 } else { 4015 rep_contour_xy(a_out,a_data_style, 4016 painting,*(m_bins_cm 4017 list_contour,a_box_x 4018 } 4019 4020 } 4021 4022 if(sbFunc.m_problem) { 4023 a_out << "tools::sg::plotter::updateF 4024 << "problem when getting some functio 4025 } 4026 4027 } else { 4028 4029 bool hbe = a_bins.has_entries_per_bin() 4030 4031 float bmin = 0; 4032 float bmax = 0; 4033 4034 std::vector<rep_bin2D> bins; 4035 {bool first = true; 4036 for(int jbin=ynbin-1;jbin>=0;jbin--) { 4037 for(int ibin=xnbin-1;ibin>=0;ibin--) 4038 if(hbe && (a_bins.bin_entries(ibin, 4039 4040 float val = a_bins.bin_Sw(ibin,jbin 4041 4042 float xx = a_bins.bin_lower_edge_x( 4043 float xe = a_bins.bin_upper_edge_x( 4044 float yy = a_bins.bin_lower_edge_y( 4045 float ye = a_bins.bin_upper_edge_y( 4046 4047 bins.push_back(rep_bin2D(xx,xe,yy,y 4048 4049 if(first) { 4050 first = false; 4051 bmin = val; 4052 bmax = val; 4053 } else { 4054 bmin = mn<float>(bmin,val); 4055 bmax = mx<float>(bmax,val); 4056 } 4057 } 4058 }} 4059 size_t number = bins.size(); 4060 4061 //a_bins.bins_Sw_range(bmin,bmax,false) 4062 4063 painting_policy painting = a_data_style 4064 if(painting==painting_by_value) { 4065 m_bins_cmaps[a_index] = new by_value_ 4066 } else if( (painting==painting_grey_sca 4067 (painting==painting_grey_sca 4068 (painting==painting_violet_t 4069 {float dbins = bmax-bmin; 4070 if(dbins!=0.0F) { 4071 for(size_t index=0;index<number;ind 4072 bins[index].m_ratio = (bins[index 4073 } 4074 }} 4075 if(painting==painting_grey_scale) { 4076 m_bins_cmaps[a_index] = new grey_sc 4077 } else if(painting==painting_grey_sca 4078 m_bins_cmaps[a_index] = new grey_sc 4079 } else if(painting==painting_violet_t 4080 m_bins_cmaps[a_index] = new violet_ 4081 } 4082 } else { 4083 m_bins_cmaps[a_index] = new const_col 4084 } 4085 4086 if(modeling==modeling_solid()) { 4087 //a_out << "tools::sg::update_bins2D_ 4088 4089 rep_bins2D_xy_solid(a_data_style,*(m_ 4090 4091 } else if(modeling==modeling_points()) 4092 //a_out << "tools::sg::update_bins2D_ 4093 rep_bins2D_xy_random_one(a_data_style 4094 4095 } else if(modeling==modeling_wire_boxes 4096 //a_out << "tools::sg::update_bins2D_ 4097 4098 // one node decision : 4099 /*bool oneNode = false; 4100 {int nlimit = aGraphicStyle.multiNodeL 4101 if(nlimit!=NoLimit) { 4102 oneNode = (number>nlimit?true:false 4103 }}*/ 4104 4105 /*if(oneNode) { 4106 rep_bins2D_xy_wire_box_one(a_data_s 4107 } else {*/ 4108 rep_bins2D_xy_wire_box(a_data_style 4109 //} 4110 4111 } else if(modeling==modeling_texts()) { 4112 //a_out << "tools::sg::update_bins2D_ 4113 4114 // one node decision : 4115 //bool oneNode = false; 4116 //{int nlimit = aGraphicStyle.multiNodeL 4117 // if(nlimit!=NoLimit) { 4118 // oneNode = (number>nlimit?true:fals 4119 //}} 4120 4121 //if(oneNode) { 4122 // rep_bins2D_xy_text_one(binsNode, 4123 // aGraphicSty 4124 // bins,a_box_ 4125 //} else { 4126 rep_bins2D_xy_text(a_data_style,bin 4127 //} 4128 4129 } else { //default rep modeling==modeli 4130 //a_out << "tools::sg::update_bins2D_ 4131 4132 rep_bins2D_xy_box(a_data_style,bins,a 4133 4134 } 4135 4136 4137 } //end if modeling 4138 4139 } 4140 4141 void update_func1D_xy(std::ostream& a_out,c 4142 const style& a_style, 4143 4144 //a_out << "debug : tools::sg::plotter::u 4145 4146 if(!a_style.visible) return; 4147 4148 float xmn = m_x_axis_data.min_value(); 4149 float xmx = m_x_axis_data.max_value(); 4150 4151 unsigned int nstp = a_func.x_steps(); 4152 nstp = nstp <=0 ? curve_number_of_points. 4153 4154 float df = (xmx - xmn)/nstp; 4155 4156 bool problem = false; 4157 std::vector<vec3f> points(nstp+1); 4158 for(unsigned int ibin=0;ibin<=nstp;ibin++ 4159 float xx = xmn + ibin * df; 4160 float val; 4161 if(!a_func.value(xx,val)) problem = tru 4162 points[ibin].set_value(xx,val,a_zz); 4163 } 4164 if(problem) { 4165 a_out << "tools::sg::plotter::update_fu 4166 << " problem when getting some fu 4167 << std::endl; 4168 } 4169 4170 const std::string& modeling = a_style.mod 4171 4172 if(modeling==modeling_points()){ 4173 vertices* vtxs = new vertices; 4174 std::vector<float>& pts = vtxs->xyzs.va 4175 clip_points_2D(points,a_box_x,a_box_y,p 4176 if(pts.size()) { 4177 //a_out << "debug : tools::sg::plotte 4178 // << " ptn " << pts.size() 4179 // << std::endl; 4180 4181 separator* sep = new separator; 4182 m_func_sep.add(sep); 4183 4184 rgba* mat = new rgba(); 4185 mat->color = a_style.color; 4186 sep->add(mat); 4187 4188 draw_style* ds = new draw_style; 4189 ds->style = draw_points; 4190 ds->point_size = a_style.point_size; 4191 sep->add(ds); 4192 4193 vtxs->mode = gl::points(); 4194 sep->add(vtxs); 4195 } else { 4196 delete vtxs; 4197 } 4198 4199 } else if(modeling==modeling_markers()){ 4200 markers* _marks = new markers; 4201 std::vector<float>& pts = _marks->xyzs. 4202 clip_points_2D(points,a_box_x,a_box_y,p 4203 if(pts.size()) { 4204 //a_out << "debug : tools::sg::plotte 4205 // << " ptn " << pts.size() 4206 // << std::endl; 4207 4208 separator* sep = new separator; 4209 m_func_sep.add(sep); 4210 4211 rgba* mat = new rgba(); 4212 mat->color = a_style.color; 4213 sep->add(mat); 4214 4215 _marks->size = a_style.marker_size; 4216 _marks->style = a_style.marker_style; 4217 sep->add(_marks); 4218 } else { 4219 delete _marks; 4220 } 4221 4222 } else { 4223 4224 vertices* vtxs = new vertices; 4225 std::vector<float>& pts = vtxs->xyzs.va 4226 4227 clip_polyline_2D(points,a_box_x,a_box_y 4228 if(pts.size()) { 4229 //a_out << "debug : tools::sg::plotte 4230 4231 separator* sep = new separator; 4232 m_func_sep.add(sep); 4233 4234 rgba* mat = new rgba(); 4235 mat->color = a_style.color; 4236 sep->add(mat); 4237 4238 draw_style* ds = new draw_style; 4239 ds->style = draw_lines; 4240 ds->line_pattern = a_style.line_patte 4241 ds->line_width = a_style.line_width; 4242 sep->add(ds); 4243 4244 vtxs->mode = gl::line_strip(); 4245 sep->add(vtxs); 4246 } else { 4247 delete vtxs; 4248 } 4249 } 4250 } 4251 4252 static double function_to_contour(double a_ 4253 SbFunc* func = (SbFunc*)aData; 4254 if( (a_X<func->m_limits_in[0])|| 4255 (a_X>func->m_limits_in[1])|| 4256 (a_Y<func->m_limits_in[2])|| 4257 (a_Y>func->m_limits_in[3]) 4258 ) return -FLT_MAX; 4259 float value; 4260 if(!func->m_func2D->value((float)a_X,(flo 4261 return double(value); 4262 } 4263 static double log_function_to_contour(doubl 4264 SbFunc* func =(SbFunc*)aData; 4265 if( (a_X<func->m_limits_in[0])|| 4266 (a_X>func->m_limits_in[1])|| 4267 (a_Y<func->m_limits_in[2])|| 4268 (a_Y>func->m_limits_in[3]) 4269 ) return -FLT_MAX; 4270 float value; 4271 if(!func->m_func2D->value((float)a_X,(flo 4272 return take_log(value); 4273 } 4274 4275 void update_func2D_xy(std::ostream& a_out,c 4276 const rep_box& a_box_ 4277 //a_out << "debug : tools::sg::plotter::u 4278 if(!a_data_style.visible.value()) return; 4279 4280 // std::string sid; 4281 // {std::string sp; 4282 // if(!p2sx(&a_func,sp)){} 4283 // sid = "SbFunction2D/"+sp;} 4284 4285 const std::string& modeling = a_data_styl 4286 painting_policy painting = a_data_style.p 4287 4288 if( (modeling==modeling_curve()) || (mode 4289 4290 //a_out << "debug : tools::sg::plotter: 4291 4292 float zmin = a_box_z.m_pos; 4293 float dz = a_box_z.m_width; 4294 bool zlog = a_box_z.m_log; 4295 4296 float xmn = m_x_axis_data.min_value(); 4297 float xmx = m_x_axis_data.max_value(); 4298 float ymn = m_y_axis_data.min_value(); 4299 float ymx = m_y_axis_data.max_value(); 4300 4301 clist_contour list_contour; 4302 //int nFir = 32; 4303 int nFir = 128; 4304 list_contour.set_first_grid(nFir,nFir); 4305 //int nSec = 256; 4306 int nSec = 512; //slower than 256 4307 list_contour.set_secondary_grid(nSec,nS 4308 4309 double limits[4]; 4310 // User limits : 4311 limits[0] = xmn; 4312 limits[1] = xmx; 4313 limits[2] = ymn; 4314 limits[3] = ymx; 4315 4316 SbFunc sbFunc; 4317 sbFunc.m_func2D = &a_func; 4318 sbFunc.m_problem = false; 4319 sbFunc.m_bins2D = 0; 4320 sbFunc.m_limits_in[0] = limits[0]; 4321 sbFunc.m_limits_in[1] = limits[1]; 4322 sbFunc.m_limits_in[2] = limits[2]; 4323 sbFunc.m_limits_in[3] = limits[3]; 4324 4325 // Extend the grid to have some borders 4326 int n = nSec - 2 * 10; 4327 double dx = (limits[1]-limits[0]) /n; 4328 double dy = (limits[3]-limits[2]) /n; 4329 limits[0] = limits[0] - 10 * dx; 4330 limits[1] = limits[1] + 10 * dx; 4331 limits[2] = limits[2] - 10 * dy; 4332 limits[3] = limits[3] + 10 * dy; 4333 4334 sbFunc.m_limits[0] = limits[0]; 4335 sbFunc.m_limits[1] = limits[1]; 4336 sbFunc.m_limits[2] = limits[2]; 4337 sbFunc.m_limits[3] = limits[3]; 4338 4339 list_contour.set_limits(limits); 4340 4341 if(levels.getNum()) { 4342 size_t zn = levels.size(); 4343 std::vector<double> zs(zn); 4344 for(size_t zi=0;zi<zn;zi++) zs[zi] = 4345 list_contour.set_planes(zs); 4346 } else { 4347 unsigned int zn = number_of_levels; 4348 if(zn<=0) zn = 1; 4349 std::vector<double> zs(zn+1); 4350 float zmax = zmin + dz; 4351 double zd = (zmax-zmin)/zn; 4352 for(unsigned int zi=0;zi<=zn;zi++) zs 4353 list_contour.set_planes(zs); 4354 } 4355 4356 if(zlog) { 4357 list_contour.set_field_fcn(log_functi 4358 } else { 4359 list_contour.set_field_fcn(function_t 4360 } 4361 4362 #ifdef INLIBS_SG_PLOTTER_TIMING 4363 atime _start = atime::now(); 4364 #endif 4365 list_contour.ccontour::generate(); 4366 4367 #ifdef INLIBS_SG_PLOTTER_TIMING 4368 a_out << "tools::sg::update_func2D_xy : 4369 _start = atime::now(); 4370 #endif 4371 4372 if(!list_contour.compact_strips ()) { 4373 a_out << "tools::sg::plotter::update_ 4374 } else { 4375 #ifdef INLIBS_SG_PLOTTER_TIMING 4376 a_out << "tools::sg::update_func2D_xy 4377 #endif 4378 if( (painting==painting_by_level) || 4379 m_func_cmaps[a_index] = new by_valu 4380 //bool zlog = a_box_z.m_log; 4381 if(zlog) m_func_cmaps[a_index]->set 4382 } else { 4383 m_func_cmaps[a_index] = new const_c 4384 } 4385 4386 if(modeling==modeling_filled_curve()) 4387 rep_contour_xy_filled(a_out,a_data_ 4388 painting,*(m_ 4389 list_contour, 4390 } else { 4391 rep_contour_xy(a_out,a_data_style, 4392 painting,*(m_func_cm 4393 list_contour,a_box_x 4394 } 4395 } 4396 4397 if(sbFunc.m_problem) { 4398 a_out << "tools::sg::plotter::update_ 4399 } 4400 4401 /* 4402 } else if(modeling==SbModeling_polygon) { 4403 4404 int npoint = a_func.getNumberOfPoints() 4405 if(npoint) { 4406 4407 std::vector<vec3f> points(npoint); 4408 std::vector<int> controls; 4409 for(int count=0;count<npoint;count++) { 4410 float xx,yy; 4411 bool isControl; 4412 a_func.getIthPoint(count,xx,yy,isCont 4413 points[count] = vec3f(xx,yy,a_zz); 4414 if(isControl) controls.push_back(coun 4415 } 4416 //check closure : 4417 if((points.size()>=2) && (points[points 4418 points.push_back(points[0]); 4419 } 4420 4421 project2D(points,a_box_x,a_box_y); 4422 4423 bool editable = a_data_style.editable.g 4424 if(!editable) { 4425 clip<float> clipper; 4426 {size_t ptn = points.size(); 4427 for(size_t index=0;index<ptn;index++) 4428 4429 plane<vec3f> plane_xy_bot(vec3f(0, 1, 4430 plane<vec3f> plane_xy_top(vec3f(0,-1, 4431 plane<vec3f> plane_yz_left (vec3f( 1, 4432 plane<vec3f> plane_yz_right(vec3f(-1, 4433 4434 clipper.execute(plane_xy_bot); 4435 clipper.execute(plane_xy_top); 4436 clipper.execute(plane_yz_left); 4437 clipper.execute(plane_yz_right); 4438 4439 {int n = clipper.getNumVertices(); 4440 points.resize(n); 4441 for(int index=0;index<n;index++) { 4442 clipper.getVertex(index,points[inde 4443 }} 4444 if((points.size()>=2) && (points[poin 4445 points.push_back(points[0]); 4446 } 4447 } 4448 4449 int ptn = points.size(); 4450 if(ptn) { 4451 vec3f* pts = &(points[0]); 4452 4453 SoSceneGraph* separator = new SoSceneGr 4454 separator->setString(sid.c_str()); 4455 functionNode->addChild(separator); 4456 4457 SoSeparator* sep = new SoSeparator; 4458 separator->addChild(sep); 4459 4460 sep->addChild(fStyleCache->getFilled()) 4461 sep->addChild(fStyleCache->getNormalBin 4462 sep->addChild(fStyleCache->getNormalZ() 4463 sep->addChild(fStyleCache->getMaterial( 4464 4465 SoCoordinate3* coordinate3 = new SoCoor 4466 coordinate3->point.setValues(0,ptn,pts) 4467 sep->addChild(coordinate3); 4468 4469 SoFaceSet* faceSet = new SoFaceSet; 4470 faceSet->numVertices.set1Value(0,ptn); 4471 sep->addChild(faceSet); 4472 4473 sep->addChild(fStyleCache->getLineStyle 4474 sep->addChild(fStyleCache->getMaterial( 4475 4476 //NOTE : we could simply add faceSet ag 4477 SoLineSet* lineSet = new SoLineSet; 4478 lineSet->numVertices.set1Value(0,ptn); 4479 sep->addChild(lineSet); 4480 4481 if(editable) { 4482 SoSeparator* sep = new SoSeparator; 4483 separator->addChild(sep); 4484 4485 float scale = 0.05F; 4486 4487 for(int index=0;index<controls.size() 4488 int icontrol = controls[index]; 4489 const vec3f& pt = pts[icontrol]; 4490 4491 SoSeparator* sp = new SoSeparator; 4492 sep->addChild(sp); 4493 4494 SoTransform* tsf = new SoTransform( 4495 tsf->translation.setValue(pt); 4496 tsf->scaleFactor.setValue(scale,sca 4497 sp->addChild(tsf); 4498 4499 SoPlotter_dragger* dragger = 4500 new SoPlotter_dragger(*coordinate 4501 SoTools_setDraggerColor(*dragger,Sb 4502 sp->addChild(dragger); 4503 } 4504 } 4505 4506 } //ptn 4507 } //npoint 4508 4509 */ 4510 } else { 4511 a_out << "tools::sg::plotter::update_fu 4512 << " modeling " << modeling 4513 << " does not apply on Functi on2D in 4514 << std::endl; 4515 } 4516 4517 } 4518 4519 void update_points2D_xy(std::ostream& a_out 4520 const rep_box& a_bo 4521 4522 //a_out << "debug : tools::sg::plotter::u 4523 4524 if(!a_style.visible) return; 4525 4526 size_t number = a_points.points(); 4527 if(!number) return; 4528 4529 const std::string& modeling = a_style.mod 4530 4531 if(modeling==modeling_lines()) { 4532 rep_points2D_xy_lines(a_style,a_points, 4533 } else if(modeling==modeling_curve()) { 4534 rep_points2D_xy_curve(a_out,a_style,a_p 4535 } else { 4536 rep_points2D_xy_points(a_out,a_style,a_ 4537 } 4538 } 4539 4540 void update_points3D_xyz(std::ostream& a_ou 4541 const rep_box& a_b 4542 4543 //a_out << "debug : tools::sg::plotter::u 4544 4545 if(!a_style.visible) return; 4546 4547 size_t number = a_points.points(); 4548 if(!number) return; 4549 4550 rep_points3D_xyz_points(a_out,a_style,a_p 4551 } 4552 4553 void get_title(std::string& a_s){ 4554 a_s.clear(); 4555 bins1D* b1; 4556 bins2D* b2; 4557 func1D* f1; 4558 func2D* f2; 4559 points2D* p2; 4560 points3D* p3; 4561 if(first_bins(b1,b2)) { 4562 if(b1) { 4563 a_s = b1->title(); 4564 } else if(b2) { 4565 a_s = b2->title(); 4566 } 4567 } else if(first_points(p2,p3)) { 4568 if(p2) { 4569 a_s = p2->title(); 4570 } else if(p3) { 4571 a_s = p3->title(); 4572 } 4573 } else if(first_func(f1,f2)) { 4574 if(f1) { 4575 a_s = f1->title(); 4576 } if(f2) { 4577 a_s = f2->title(); 4578 } 4579 } 4580 } 4581 4582 void update_bins2D_xyz(std::ostream& a_out, 4583 const rep_box& a_box 4584 //a_out << "tools::sg::update_bins2D_xyz 4585 4586 if(!a_style.visible) return; 4587 4588 //a_out << "tools::sg::update_bins2D_xyz 4589 4590 unsigned int xnbin = a_bins.x_bins(); 4591 unsigned int ynbin = a_bins.y_bins(); 4592 if(!xnbin || !ynbin) return; 4593 4594 const std::string& modeling = a_style.mod 4595 4596 if(modeling==modeling_boxes()) { 4597 4598 bool hbe = a_bins.has_entries_per_bin() 4599 4600 float bmin = 0; 4601 float bmax = 0; 4602 4603 std::vector<rep_bin2D> bins; 4604 {bool first = true; 4605 for(int jbin=ynbin-1;jbin>=0;jbin--) { 4606 for(int ibin=xnbin-1;ibin>=0;ibin--) 4607 if(hbe && (a_bins.bin_entries(ibin, 4608 4609 float val = a_bins.bin_Sw(ibin,jbin 4610 4611 float xx = a_bins.bin_lower_edge_x( 4612 float xe = a_bins.bin_upper_edge_x( 4613 float yy = a_bins.bin_lower_edge_y( 4614 float ye = a_bins.bin_upper_edge_y( 4615 4616 bins.push_back(rep_bin2D(xx,xe,yy,y 4617 4618 if(first) { 4619 first = false; 4620 bmin = val; 4621 bmax = val; 4622 } else { 4623 bmin = mn<float>(bmin,val); 4624 bmax = mx<float>(bmax,val); 4625 } 4626 } 4627 }} 4628 size_t number = bins.size(); 4629 4630 //a_bins.bins_Sw_range(bmin,bmax,false) 4631 4632 painting_policy painting = a_style.pain 4633 if(painting==painting_by_value) { 4634 m_bins_cmaps[a_index] = new by_value_ 4635 } else if( (painting==painting_grey_sca 4636 (painting==painting_grey_sca 4637 (painting==painting_violet_t 4638 {float dbins = bmax-bmin; 4639 if(dbins!=0.0F) { 4640 for(size_t index=0;index<number;ind 4641 bins[index].m_ratio = (bins[index 4642 } 4643 }} 4644 if(painting==painting_grey_scale) { 4645 m_bins_cmaps[a_index] = new grey_sc 4646 } else if(painting==painting_grey_sca 4647 m_bins_cmaps[a_index] = new grey_sc 4648 } else if(painting==painting_violet_t 4649 m_bins_cmaps[a_index] = new violet_ 4650 } 4651 } else { 4652 m_bins_cmaps[a_index] = new const_col 4653 } 4654 4655 rep_bins2D_xyz_box(a_style,*m_bins_cmap 4656 4657 } else if(modeling==modeling_curve()){ // 4658 4659 float bmin = 0; 4660 float bmax = 0; 4661 4662 std::vector<rep_top_face2D> faces((xnbi 4663 {bool first = true; 4664 size_t facei = 0; 4665 unsigned int xnbin_1 = xnbin-1; 4666 unsigned int ynbin_1 = ynbin-1; 4667 for(unsigned int jbin=0;jbin<ynbin_1;jb 4668 for(unsigned int ibin=0;ibin<xnbin_1; 4669 4670 float xx_0 = a_bins.bin_lower_edge_ 4671 float xe_0 = a_bins.bin_upper_edge_ 4672 float xx_1 = a_bins.bin_lower_edge_ 4673 float xe_1 = a_bins.bin_upper_edge_ 4674 4675 float yy_0 = a_bins.bin_lower_edge_ 4676 float ye_0 = a_bins.bin_upper_edge_ 4677 float yy_1 = a_bins.bin_lower_edge_ 4678 float ye_1 = a_bins.bin_upper_edge_ 4679 4680 float xx = (xx_0+xe_0)/2; 4681 float xe = (xx_1+xe_1)/2; 4682 float yy = (yy_0+ye_0)/2; 4683 float ye = (yy_1+ye_1)/2; 4684 4685 float val1 = a_bins.bin_Sw(ibin,jbi 4686 float val2 = a_bins.bin_Sw(ibin+1,j 4687 float val3 = a_bins.bin_Sw(ibin+1,j 4688 float val4 = a_bins.bin_Sw(ibin,jbi 4689 4690 faces[facei] = rep_top_face2D(xx,xe 4691 4692 if(first) { 4693 first = false; 4694 bmin = val1; 4695 bmax = val1; 4696 } else { 4697 bmin = mn<float>(bmin,val1); 4698 bmax = mx<float>(bmax,val1); 4699 } 4700 4701 facei++; 4702 } 4703 }} 4704 4705 //a_bins.bins_Sw_range(bmin,bmax,false) 4706 4707 painting_policy painting = a_style.pain 4708 if((painting==painting_by_value)||(pain 4709 m_bins_cmaps[a_index] = new by_value_ 4710 } else { 4711 m_bins_cmaps[a_index] = new const_col 4712 } 4713 4714 if(painting==painting_by_level) { //gop 4715 rep_top_face2D_xyz_by_level(a_style,p 4716 faces,a_b 4717 bmin,bmax 4718 //if(a_style.area_style.value()==area 4719 // style gs; 4720 // gs.light_model = light_model_base 4721 // gs.line_width = 1; 4722 // rep_top_face2D_xyz_line(gs,faces, 4723 //} 4724 4725 } else { 4726 4727 //bool oneNode = false; 4728 //{int nlimit = aGraphicStyle.multiNod 4729 //if(nlimit!=NoLimit) { 4730 //oneNode = ((int)faces.size()>nlimit 4731 //}} 4732 4733 //if(oneNode) { 4734 //repTopFaces2D_xyz_one(binsNode,aGra 4735 //} else { 4736 bool zlog = a_box_z.m_log; 4737 if(zlog) m_func_cmaps[a_index]->set_P 4738 rep_top_face2D_xyz(m_bins_sep,a_style 4739 4740 if(a_style.area_style.value()==area_e 4741 style gs; 4742 gs.light_model = light_model_base_c 4743 gs.line_width = 1; 4744 rep_top_face2D_xyz_line(gs,faces,a_ 4745 } 4746 4747 if(painting==painting_uniform) { //go 4748 4749 base_colormap* cmap = new by_value_ 4750 if(cmap->colorn()<=0) { 4751 //a_out << "tools::sg::update_bin 4752 delete cmap; 4753 } else { 4754 //updateBins2D_XY(a_bins,aIndex,* 4755 4756 float zmin = a_box_z.m_pos; 4757 float dz = a_box_z.m_width; 4758 //bool zlog = a_box_z.m_log; 4759 4760 float xmn = m_x_axis_data.min_va 4761 float xmx = m_x_axis_data.max_va 4762 float ymn = m_y_axis_data.min_va 4763 float ymx = m_y_axis_data.max_va 4764 4765 clist_contour list_contour; 4766 //int nFir = 32; 4767 int nFir = 128; 4768 list_contour.set_first_grid(nFir, 4769 //int nSec = 256; 4770 int nSec = 512; 4771 list_contour.set_secondary_grid(n 4772 4773 double limits[4]; 4774 // User limits : 4775 limits[0] = xmn; 4776 limits[1] = xmx; 4777 limits[2] = ymn; 4778 limits[3] = ymx; 4779 4780 SbFunc sbFunc; 4781 sbFunc.m_func2D = 0; 4782 sbFunc.m_problem = false; 4783 sbFunc.m_bins2D = &a_bins; 4784 sbFunc.m_limits_in[0] = limits[0] 4785 sbFunc.m_limits_in[1] = limits[1] 4786 sbFunc.m_limits_in[2] = limits[2] 4787 sbFunc.m_limits_in[3] = limits[3] 4788 4789 // Extend the grid to have some b 4790 int n = nSec - 2 * 10; 4791 double dx = (limits[1]-limits[0]) 4792 double dy = (limits[3]-limits[2]) 4793 limits[0] = limits[0] - 10 * dx; 4794 limits[1] = limits[1] + 10 * dx; 4795 limits[2] = limits[2] - 10 * dy; 4796 limits[3] = limits[3] + 10 * dy; 4797 4798 sbFunc.m_limits[0] = limits[0]; 4799 sbFunc.m_limits[1] = limits[1]; 4800 sbFunc.m_limits[2] = limits[2]; 4801 sbFunc.m_limits[3] = limits[3]; 4802 4803 list_contour.set_limits(limits); 4804 4805 //int zn = numberOfLevels.getValu 4806 size_t zn = cmap->colorn(); 4807 if(zn<=0) zn = 1; 4808 4809 std::vector<double> zs(zn+1); 4810 float zmax = zmin + dz; 4811 double zd = (zmax-zmin)/zn; 4812 for(size_t zi=0;zi<=zn;zi++) zs[z 4813 list_contour.set_planes(zs); 4814 4815 if(zlog) list_contour.set_field_f 4816 else list_contour.set_field_f 4817 4818 list_contour.ccontour::generate() 4819 if(!list_contour.compact_strips ( 4820 a_out << "tools::sg::plotter::u 4821 delete cmap; 4822 } else { 4823 delete m_bins_cmaps[a_index]; 4824 m_bins_cmaps[a_index] = cmap; / 4825 4826 matrix* transf = new matrix; 4827 //contour back is at ZZ - 0.01F 4828 transf->set_translate(0,0,1.02F 4829 transf->mul_scale(1,1,0.01F); / 4830 m_bins_sep.add(transf); 4831 4832 style gs; 4833 gs.light_model = light_model_ba 4834 //FIXME gs.transparency = 0.3F; 4835 4836 float ZZ = 0.0F; 4837 4838 rep_contour_xy_filled(a_out,gs, 4839 a_box_x,a 4840 } 4841 } 4842 4843 } //uniform 4844 4845 } 4846 4847 } //end if modeling 4848 4849 } 4850 4851 void update_func2D_xyz(std::ostream& a_out, 4852 const func2D& a_func 4853 unsigned int a_index 4854 const style& a_style 4855 const rep_box& a_box 4856 const rep_box& a_box 4857 const rep_box& a_box 4858 //a_out << "tools::sg::plotter::update_fu 4859 if(!a_style.visible) return; 4860 4861 //a_out << "tools::sg::plotter::update_fu 4862 4863 float xmn = m_x_axis_data.min_value(); 4864 float xmx = m_x_axis_data.max_value(); 4865 4866 unsigned int nx = a_func.x_steps(); 4867 nx = !nx?20:nx; 4868 4869 float ymn = m_y_axis_data.min_value(); 4870 float ymx = m_y_axis_data.max_value(); 4871 4872 unsigned int ny = a_func.y_steps(); 4873 ny = !ny?20:ny; 4874 4875 float dfx = (xmx - xmn)/nx; 4876 float dfy = (ymx - ymn)/ny; 4877 4878 //printf("debug : nx %d ny %d\n",nx,ny); 4879 4880 std::vector<rep_top_face2D> faces(nx*ny); 4881 {bool problem = false; 4882 unsigned int facei = 0; 4883 float* vprev = new float[2*nx]; 4884 for(int jbin=ny-1;jbin>=0;jbin--) { 4885 float o1 = 0; 4886 float o4 = 0; 4887 for(int ibin=nx-1;ibin>=0;ibin--) { 4888 4889 float xx = xmn + ibin * dfx; 4890 float yy = ymn + jbin * dfy; 4891 float xe = xx + dfx; 4892 float ye = yy + dfy; 4893 4894 // Values at the corner : 4895 float val1; 4896 if(!a_func.value(xx,yy,val1)) problem 4897 float val2; 4898 if(ibin==int(nx-1)) { 4899 if(!a_func.value(xe,yy,val2)) probl 4900 } else { 4901 val2 = o1; 4902 } 4903 float val3,val4; 4904 if(jbin==int(ny-1)) { 4905 if(ibin==int(nx-1)) { 4906 if(!a_func.value(xe,ye,val3)) pro 4907 } else { 4908 val3 = o4; 4909 } 4910 if(!a_func.value(xx,ye,val4)) probl 4911 } else { 4912 val3 = vprev[2*ibin+1]; 4913 val4 = vprev[2*ibin]; 4914 } 4915 //printf("debug : %d %d : %g %g %g %g 4916 // ibin,jbin, 4917 // val1,val2,val3,val4); 4918 vprev[2*ibin] = val1; 4919 vprev[2*ibin+1] = val2; 4920 o4 = val4; 4921 o1 = val1; 4922 4923 faces[facei] = rep_top_face2D(xx,xe,y 4924 facei++; 4925 } 4926 } 4927 delete [] vprev; 4928 if(problem) { 4929 a_out << "tools::sg::plotter::update_fu 4930 << " problem when getting some fu 4931 << std::endl; 4932 }} 4933 4934 painting_policy painting = a_style.painti 4935 4936 if(painting==painting_by_value) { 4937 m_func_cmaps[a_index] = new by_value_co 4938 4939 } else if( (painting==painting_grey_scale 4940 (painting==painting_grey_scale 4941 (painting==painting_violet_to_ 4942 float vmin = faces[0].m_v1; 4943 float vmax = faces[0].m_v1; 4944 size_t number = faces.size(); 4945 for(size_t index=0;index<number;index++ 4946 float vmean = faces[index].m_v1; 4947 vmean += faces[index].m_v2; 4948 vmean += faces[index].m_v3; 4949 vmean += faces[index].m_v4; 4950 vmean /= 4.0f; 4951 4952 vmin = mn<float>(vmin,vmean); 4953 vmax = mx<float>(vmax,vmean); 4954 4955 faces[index].m_ratio = vmean; 4956 } 4957 4958 {float dbins = vmax-vmin; 4959 if(dbins!=0.0F) { 4960 for(size_t index=0;index<number;index 4961 faces[index].m_ratio = (faces[index 4962 } 4963 }} 4964 4965 if(painting==painting_grey_scale) { 4966 m_func_cmaps[a_index] = new grey_scal 4967 } else if(painting==painting_grey_scale 4968 m_func_cmaps[a_index] = new grey_scal 4969 } else if(painting==painting_violet_to_ 4970 m_func_cmaps[a_index] = new violet_to 4971 } 4972 4973 } else { 4974 m_func_cmaps[a_index] = new const_color 4975 } 4976 4977 // bool oneNode = false; 4978 //{int nlimit = a_data_style.multiNodeLimit 4979 // if(nlimit!=NoLimit) { 4980 // oneNode = ((int)faces.size()>nlimit?tr 4981 //}} 4982 4983 //char sid[128]; 4984 //::sprintf(sid,"SbFunction2D/0x%lx",(unsig 4985 4986 //if(oneNode) { 4987 // repTopFaces2D_xyz_one(functionNode,a_da 4988 // faces,a_box_x,a_b 4989 //} else 4990 { 4991 bool zlog = a_box_z.m_log; 4992 if(zlog) m_func_cmaps[a_index]->set_PAW 4993 rep_top_face2D_xyz(m_func_sep,a_style,* 4994 } 4995 4996 float xmin = a_box_x.m_pos; 4997 float dx = a_box_x.m_width; 4998 bool xlog = a_box_x.m_log; 4999 5000 float ymin = a_box_y.m_pos; 5001 float dy = a_box_y.m_width; 5002 bool ylog = a_box_y.m_log; 5003 5004 float zmin = a_box_z.m_pos; 5005 float dz = a_box_z.m_width; 5006 bool zlog = a_box_z.m_log; 5007 5008 if(func2D_borders_visible.value()) { 5009 // border X (Y=0) 5010 5011 {separator* sep = new separator; 5012 {normal* nm = new normal; 5013 nm->vec = vec3f(0,-1,0); 5014 sep->add(nm);} 5015 {rgba* mat = new rgba(); 5016 mat->color = colorf(0.6f,0.2f,0.2f); //br 5017 sep->add(mat);} 5018 5019 vertices* vtxs = new vertices; 5020 vtxs->mode = gl::triangle_fan(); 5021 sep->add(vtxs); 5022 5023 bool empty = true; 5024 bool problem = false; 5025 5026 {float xx = xmn; 5027 float yy = ymn; 5028 xx = verify_log(xx,xmin,dx,xlog); 5029 yy = verify_log(yy,ymin,dy,ylog); 5030 vtxs->add(xx,yy,0);} 5031 5032 {float xx = xmx; 5033 float yy = ymn; 5034 xx = verify_log(xx,xmin,dx,xlog); 5035 yy = verify_log(yy,ymin,dy,ylog); 5036 vtxs->add(xx,yy,0);} 5037 5038 {float val; 5039 {if(!a_func.value(xmx,ymn,val)) problem = 5040 val = verify_log(val,zmin,dz,zlog); 5041 if(val<0) val = 0; 5042 if(val>1) val = 1;} 5043 {float xx = xmx; 5044 float yy = ymn; 5045 xx = verify_log(xx,xmin,dx,xlog); 5046 yy = verify_log(yy,ymin,dy,ylog); 5047 vtxs->add(xx,yy,val);}} 5048 5049 for(int ibin=nx-1;ibin>=0;ibin--) { 5050 5051 float xx = xmn + ibin * dfx; 5052 //float xe = xx + dfx; 5053 float yy = ymn; 5054 5055 float val; 5056 {if(!a_func.value(xx,yy,val)) problem = 5057 val = verify_log(val,zmin,dz,zlog); 5058 if(val<0) val = 0; 5059 if(val>1) val = 1;} 5060 5061 xx = verify_log(xx,xmin,dx,xlog); 5062 yy = verify_log(yy,ymin,dy,ylog); 5063 5064 if((xx>=0)&&(xx<=1) && (yy>=0)&&(yy<=1) 5065 5066 vtxs->add(xx,yy,val); 5067 5068 empty = false; 5069 } 5070 } 5071 if(empty) { 5072 delete sep; 5073 } else { 5074 m_func_sep.add(sep); 5075 } 5076 if(problem) { 5077 a_out << "tools::sg::plotter::update_fu 5078 << " problem when getting some fu 5079 << std::endl; 5080 }} 5081 5082 // border Y (X=0) 5083 {separator* sep = new separator; 5084 {normal* nm = new normal; 5085 nm->vec = vec3f(-1,0,0); 5086 sep->add(nm);} 5087 {rgba* mat = new rgba(); 5088 mat->color = colorf(0.6f,0.2f,0.2f); //br 5089 sep->add(mat);} 5090 5091 vertices* vtxs = new vertices; 5092 vtxs->mode = gl::triangle_fan(); 5093 sep->add(vtxs); 5094 5095 {float xx = xmn; 5096 float yy = ymx; 5097 xx = verify_log(xx,xmin,dx,xlog); 5098 yy = verify_log(yy,ymin,dy,ylog); 5099 vtxs->add(xx,yy,0);} 5100 5101 {float xx = xmn; 5102 float yy = ymn; 5103 xx = verify_log(xx,xmin,dx,xlog); 5104 yy = verify_log(yy,ymin,dy,ylog); 5105 vtxs->add(xx,yy,0);} 5106 5107 bool empty = true; 5108 bool problem = false; 5109 5110 for(unsigned int jbin=0;jbin<ny;jbin++) { 5111 5112 float xx = xmn; 5113 float yy = ymn + jbin * dfy; 5114 5115 float val; 5116 {if(!a_func.value(xx,yy,val)) problem = 5117 val = verify_log(val,zmin,dz,zlog); 5118 if(val<0) val = 0; 5119 if(val>1) val = 1;} 5120 5121 xx = verify_log(xx,xmin,dx,xlog); 5122 yy = verify_log(yy,ymin,dy,ylog); 5123 5124 if((xx>=0)&&(xx<=1) && 5125 (yy>=0)&&(yy<=1) ){ 5126 5127 vtxs->add(xx,yy,val); 5128 5129 empty = false; 5130 5131 } 5132 } 5133 5134 {float val; 5135 {if(!a_func.value(xmn,ymx,val)) problem = 5136 val = verify_log(val,zmin,dz,zlog); 5137 if(val<0) val = 0; 5138 if(val>1) val = 1;} 5139 {float xx = xmn; 5140 float yy = ymx; 5141 xx = verify_log(xx,xmin,dx,xlog); 5142 yy = verify_log(yy,ymin,dy,ylog); 5143 vtxs->add(xx,yy,val);}} 5144 if(empty) { 5145 delete sep; 5146 } else { 5147 m_func_sep.add(sep); 5148 } 5149 if(problem) { 5150 a_out << "tools::sg::plotter::update_fu 5151 << " problem when getting some fu 5152 << std::endl; 5153 }} 5154 5155 5156 } //func2D_borders_visible 5157 5158 } 5159 5160 void update_title(){ 5161 if(!m_title_style.visible) return; 5162 5163 if(m_shape==xyz) return; 5164 5165 if(title.value().empty()) return; 5166 5167 // Use the XY layout transform to positio 5168 // (Else we would have to compensate the 5169 // in order to bring the title at the ri 5170 // without rotation). 5171 //titleNode->addChild(layout); 5172 5173 rgba* mat = new rgba(); 5174 mat->color = m_title_style.color; 5175 m_title_sep.add(mat); 5176 5177 float text_size = title_height * m_title_ 5178 5179 std::string font = m_title_style.font.val 5180 5181 if(font==font_hershey()) { 5182 draw_style* ds = new draw_style; 5183 ds->style = draw_lines; 5184 ds->line_pattern = m_title_style.line_p 5185 ds->line_width = m_title_style.line_wid 5186 m_title_sep.add(ds); 5187 } else { 5188 m_title_sep.add(new normal); 5189 } 5190 5191 float XSIZ = width; 5192 float XMGL = left_margin; 5193 float XMGR = right_margin; 5194 float wData = XSIZ-XMGL-XMGR; 5195 5196 float YSIZ = height; 5197 float YMGL = bottom_margin; 5198 float YMGU = top_margin; 5199 float hData = YSIZ-YMGL-YMGU; 5200 5201 float xx = wData/2; 5202 float yy = hData + title_to_axis; 5203 5204 float zz = _zinfos(); 5205 5206 vjust vjust = bottom; 5207 if(!title_up) { 5208 yy = -title_to_axis; 5209 vjust = top; 5210 } 5211 5212 //::printf("debug : %lu : %g %g : text_si 5213 // this,xx,yy,text_size,title.value().c_ 5214 5215 vec3f TX(1,0,0); 5216 vec3f TY(0,1,0); 5217 add_string(m_title_sep, 5218 font, 5219 m_title_style.font_mod 5220 m_title_style.encoding 5221 m_title_style.smoothin 5222 title.value(), 5223 xx,yy,zz, //vec 5224 TX,TY, 5225 text_size, 5226 title_hjust,vjust, 5227 m_ttf); 5228 } 5229 5230 void update_title_box(){ 5231 if(!m_title_box_style.visible) return; 5232 if(title.value().empty()) return; 5233 5234 // same plane than infos, then in front o 5235 float zz = _zinfos(); 5236 if(m_shape==xyz) zz = depth*0.5f; 5237 5238 float wbox = width*title_box_width; 5239 float hbox = height*title_box_height; 5240 5241 float xmargin = width*title_box_x_margin; 5242 float ymargin = height*title_box_y_margin 5243 5244 matrix* _tsf = new matrix; 5245 {float xx = -width*0.5f+wbox*0.5f+xmargin; 5246 float yy = height*0.5f-hbox*0.5F-ymargin; 5247 _tsf->set_translate(xx,yy,zz); 5248 _tsf->mul_scale(1,1,_zscale_text());} 5249 m_title_box_sep.add(_tsf); 5250 5251 sg::text* title_box = new sg::text(m_ttf) 5252 title_box->width = wbox; 5253 title_box->height = hbox; 5254 title_box->back_area::color = m_title_box 5255 title_box->color = m_title_box_style.colo 5256 title_box->font = m_title_box_style.font; 5257 title_box->font_modeling = m_title_box_st 5258 title_box->encoding = m_title_box_style.e 5259 title_box->line_width = m_title_box_style 5260 //title_box->front_face = m_title_box_style 5261 title_box->confine = true; 5262 title_box->back_area::shadow = m_title_bo 5263 5264 title_box->strings.add(title.value()); 5265 5266 m_title_box_sep.add(title_box); 5267 } 5268 5269 void get_infos(std::string& a_s){ 5270 // return "[<key>\n<value>]\n". 5271 a_s.clear(); 5272 const std::string& opts = infos_what.val 5273 {bins1D* b1; 5274 bins2D* b2; 5275 func1D* f1; 5276 func2D* f2; 5277 points2D* p2; 5278 points3D* p3; 5279 if(first_bins(b1,b2)) { 5280 if(b1) { 5281 b1->infos(opts,a_s); 5282 } else if(b2) { 5283 b2->infos(opts,a_s); 5284 } 5285 } else if(first_points(p2,p3)) { 5286 if(p2) { 5287 p2->infos(opts,a_s); 5288 } else if(p3) { 5289 p3->infos(opts,a_s); 5290 } 5291 } else if(first_func(f1,f2)) { 5292 if(f1) { 5293 f1->infos(opts,a_s); 5294 } if(f2) { 5295 f2->infos(opts,a_s); 5296 } 5297 }} 5298 //look for fit infos : 5299 {tools_vforcit(plottable*,m_plottables,it) 5300 plottable* object = *it; 5301 if(!object) continue; 5302 if(object->cast(s_tools_sg_fit2plot())) 5303 if(a_s.size()) a_s += "\n"; 5304 std::string _s; 5305 object->infos(opts,_s); 5306 a_s += _s; 5307 } 5308 }} 5309 } 5310 5311 matrix* get_infos_matrix() { 5312 if(m_infos_sep.empty()) return 0; 5313 return (matrix*)m_infos_sep[0]; //WARNING 5314 } 5315 sg::infos_box* get_infos_node() { 5316 if(m_infos_sep.empty()) return 0; 5317 return (sg::infos_box*)m_infos_sep[1]; // 5318 } 5319 5320 void update_infos(std::ostream&){ 5321 if(!m_infos_style.visible) return; 5322 5323 std::string sinfos; 5324 get_infos(sinfos); 5325 std::vector<std::string> ws; 5326 words(sinfos,"\n",false,ws); 5327 size_t linen = ws.size()/2; 5328 5329 float zz = _zinfos(); //xy 5330 if(m_shape==xyz) zz = depth*0.5f; 5331 5332 float _height = height; 5333 if(m_shape==xyz) _height = depth; 5334 5335 float wbox = width*infos_width; 5336 5337 matrix* infos_title_tsf = 0; 5338 sg::text* infos_title_text = 0; 5339 5340 std::string infos_title; 5341 if(m_infos_style.modeling==infos_modeling 5342 std::vector<std::string> _ws; //to rm " 5343 for(size_t index=0;index<linen;index++) 5344 const std::string& name = ws[2*index] 5345 const std::string& value = ws[2*index 5346 if(name=="Name") { 5347 infos_title = value; 5348 } else { 5349 _ws.push_back(name); 5350 _ws.push_back(value); 5351 } 5352 } 5353 ws = std::move(_ws); 5354 linen = ws.size()/2; 5355 } 5356 5357 if(infos_title.size()) { 5358 float hbox = _height*0.05f; 5359 5360 matrix* _tsf = new matrix; 5361 {float xx = width*0.5f - wbox*0.5f - w 5362 float yy = _height*0.5f - hbox*0.5F - _ 5363 _tsf->mul_translate(xx,yy,zz); 5364 _tsf->mul_scale(1,1,_zscale_text());} 5365 //in case of having infos, the tsf is r 5366 m_infos_title_sep.add(_tsf); 5367 5368 // same params as title_box. 5369 sg::text* txt = new sg::text(m_ttf); 5370 txt->width = wbox; 5371 txt->height = hbox; 5372 txt->back_area::color = m_infos_style.b 5373 txt->color = m_infos_style.color; 5374 txt->font = m_infos_style.font; 5375 txt->font_modeling = m_infos_style.font 5376 txt->encoding = m_infos_style.encoding; 5377 txt->line_width = m_infos_style.line_wi 5378 //txt->front_face = m_infos_style.front_f 5379 txt->confine = true; 5380 txt->back_area::shadow = m_infos_style. 5381 5382 txt->hjust = center; 5383 5384 txt->strings.add(infos_title); 5385 m_infos_title_sep.add(txt); 5386 5387 // to refine height below. 5388 infos_title_tsf = _tsf; 5389 infos_title_text = txt; 5390 } 5391 5392 if(sinfos.empty()) return; 5393 if(!linen) return; 5394 5395 matrix* _tsf = new matrix; 5396 m_infos_sep.add(_tsf); 5397 5398 sg::infos_box* infos = new sg::infos_box( 5399 infos->width = wbox; 5400 //infos->height is an output field, see b 5401 infos->back_area::color = m_infos_style.b 5402 infos->color = m_infos_style.color; 5403 infos->font = m_infos_style.font; 5404 infos->encoding = m_infos_style.encoding; 5405 infos->font_modeling = m_infos_style.font 5406 infos->line_width = m_infos_style.line_wi 5407 //infos->front_face = m_infos_style.front_f 5408 infos->back_area::shadow = m_infos_style. 5409 infos->border_line_width = m_infos_style. 5410 5411 {for(size_t index=0;index<linen;index++) { 5412 const std::string& name = ws[2*index]; 5413 const std::string& value = ws[2*index+1 5414 infos->lstrings.add(name); 5415 infos->rstrings.add(value); 5416 //a_out << "debug : name " << sout(name 5417 // << " value " << sout(value) << 5418 }} 5419 5420 // enforce an infos::update_sg to get inf 5421 // to place the box. 5422 infos->update_sg(); 5423 5424 // if any, set infos_title height : 5425 float title_hbox = 0; 5426 if(infos_title_tsf && infos_title_text) { 5427 title_hbox = infos->height/linen; 5428 float xx = width*0.5f - wbox*0.5f 5429 float yy = _height*0.5f - title_hbox*0. 5430 infos_title_tsf->set_identity(); 5431 infos_title_tsf->mul_translate(xx,yy,zz 5432 infos_title_tsf->mul_scale(1,1,_zscale_ 5433 5434 infos_title_text->height = title_hbox; 5435 } 5436 5437 float hbox = infos->height; 5438 {float xx = width*0.5f -wbox*0.5f -width* 5439 float yy = _height*0.5f -hbox*0.5F - _hei 5440 yy -= title_hbox; 5441 _tsf->set_translate(xx,yy,zz); 5442 _tsf->mul_scale(1,1,_zscale_text());} 5443 5444 m_infos_sep.add(infos); 5445 } 5446 5447 /* 5448 void update_legends(std::ostream& a_out){ 5449 if(!legends_visible) return; 5450 5451 if(m_legend_strings.empty()) return; 5452 if(m_legend_colors.size()!=m_legend_strin 5453 5454 //m_legend_sep contains : 5455 // one global mtx 5456 // one sep per legend. 5457 5458 {matrix* _tsf = new matrix; 5459 m_legend_sep.add(_tsf); 5460 5461 float zz = _zinfos(); 5462 5463 //set legends layout : 5464 if(legends_attached_to_infos) { 5465 _tsf->set_translate(0,0,zz); 5466 } else { 5467 if(legends_origin_unit==unit_axis) { 5468 5469 // legends_origin is in axes coordina 5470 float x = legends_origin.value()[0]; 5471 float y = legends_origin.value()[1]; 5472 5473 vec3f pos; 5474 if(!axis_2_vp(vec3f(x,y,0),pos)) { 5475 //SoDebugError::postInfo("SoPlotter 5476 // "failed for %g %g. 5477 } else { 5478 //pos is in NDC of [0,width][0,heig 5479 5480 float xx = width * (-0.5f+pos[0]); 5481 float yy = height * (-0.5f+pos[1]); 5482 5483 _tsf->set_translate(xx,yy,zz); 5484 5485 } 5486 5487 } else { //unit_percent 5488 // legends_origin is 5489 // the UR corner of legend region rel 5490 // to UR of plotter region. 5491 float xur = legends_origin.value()[0] 5492 float yur = legends_origin.value()[1] 5493 5494 vec2f ur(1-xur,1-yur); 5495 5496 float w = legends_size.value()[0]; 5497 float h = legends_size.value()[1]; 5498 5499 float x = ur[0]-w; 5500 float y = ur[1]-h; 5501 5502 float xx = width * (x-0.5f); 5503 float yy = height * (y-0.5f); 5504 5505 _tsf->set_translate(xx,yy,zz); 5506 5507 } 5508 }} 5509 5510 size_t number = m_legend_strings.size(); 5511 for(size_t index=0;index<number;index++) 5512 5513 separator* sep = new separator; 5514 m_legend_sep.add(sep); 5515 5516 matrix* _tsf = new matrix; 5517 sep->add(_tsf); 5518 5519 //sg::text* text = new sg::text; 5520 legend* text = new legend(m_ttf); 5521 //text->confine = true; 5522 text->strings.add(m_legend_strings[inde 5523 sep->add(text); 5524 text->color = m_legend_colors[index]; 5525 5526 if(legends_attached_to_infos) { 5527 // global tsf should be the identity. 5528 5529 // legend box geometry and placement 5530 // to the infos box placement and geo 5531 if(m_infos_style.visible) { 5532 sg::infos_box* inode = get_infos_no 5533 if(!inode) {delete sep;return;} 5534 matrix* imtx = get_infos_matrix(); 5535 if(!imtx) {delete sep;return;} 5536 5537 float wbox = inode->width; 5538 float hbox = inode->height/number; 5539 5540 text->width = wbox; 5541 text->height = hbox; 5542 5543 _tsf->mtx = imtx->mtx; 5544 5545 float xx = width*0.5f-wbox*0.5f; 5546 5547 float yy = height*0.5f-inode->heigh 5548 5549 _tsf->set_translate(xx,yy,0); 5550 5551 } else { 5552 float wbox = width * legends_size. 5553 float hbox = (height * legends_size 5554 5555 text->width = wbox; 5556 text->height = hbox; 5557 5558 float xx = width*0.5f-wbox*0.5f - w 5559 float yy = height*0.5f-hbox*0.5F - 5560 5561 yy -= hbox*index; 5562 5563 _tsf->set_translate(xx,yy,0); 5564 } 5565 5566 } else { 5567 5568 //legends_size is in NDC of [0,width] 5569 float w = width * legends_size.value 5570 float h = height * legends_size.value 5571 5572 text->width = w; 5573 text->height = h/number; 5574 5575 float xx = w * 0.5f; 5576 float yy = text->height * 0.5f; 5577 yy += text->height*(number-index-1); 5578 5579 _tsf->set_translate(xx,yy,0); 5580 5581 } 5582 _tsf->mul_scale(1,1,_zscale_text()); 5583 5584 } 5585 } 5586 */ 5587 5588 void update_legends(std::ostream& a_out) { 5589 //::printf("debug : update_legends : begi 5590 if(m_legend_strings.empty()) return; 5591 if(m_legend_strings.size()!=legends_origi 5592 if(legends_size.size()!=legends_origin.si 5593 if(legends_origin_unit.size()!=legends_or 5594 5595 float zz = _zinfos(); 5596 5597 {matrix* _tsf = new matrix; 5598 _tsf->mul_scale(1,1,_zscale_text()); 5599 m_legend_sep.add(_tsf);} 5600 5601 size_t number = m_legend_strings.size(); 5602 //::printf("debug : update_legends : 001 5603 for(size_t index=0;index<number;index++) 5604 const style& _style = legend_style(inde 5605 if(!_style.visible) continue; 5606 //::printf("debug : update_legends : 00 5607 5608 separator* sep = new separator; 5609 m_legend_sep.add(sep); 5610 5611 matrix* _tsf = new matrix; 5612 sep->add(_tsf); 5613 5614 //sg::text* text = new sg::text; 5615 legend* text = new legend(m_ttf); 5616 text->font = _style.font; 5617 text->font_modeling = _style.font_model 5618 text->encoding = _style.encoding; 5619 text->strings.add(m_legend_strings[inde 5620 text->color = _style.color; 5621 text->marker_style = _style.marker_styl 5622 text->marker_size = _style.marker_size; 5623 text->back_visible = false; 5624 sep->add(text); 5625 5626 //legends_size is in NDC of [0,width][0 5627 float w = width * legends_size[index][ 5628 float h = height * legends_size[index][ 5629 text->width = w; 5630 text->height = h; 5631 5632 float xxx = w * 0.5f; 5633 float yyy = h * 0.5f; 5634 5635 if(legends_origin_unit[index]==unit_axi 5636 5637 // legends_origin is in axes coordina 5638 float x = legends_origin[index][0]; 5639 float y = legends_origin[index][1]; 5640 5641 vec3f pos; 5642 if(!axis_2_vp(vec3f(x,y,0),pos)) { 5643 a_out << "tools::sg::plotter::updat 5644 } else { 5645 //pos is in NDC of [0,width][0,heig 5646 float xx = width * (-0.5f+pos[0]); 5647 float yy = height * (-0.5f+pos[1]); 5648 _tsf->set_translate(xx,yy,zz); 5649 } 5650 5651 } else { //unit_percent 5652 // legends_origin is 5653 // the UR corner of legend region rel 5654 // to UR of plotter region. 5655 float xur = legends_origin[index][0]; 5656 float yur = legends_origin[index][1]; 5657 5658 vec2f ur(1-xur,1-yur); 5659 5660 float x = width*ur[0] - w; 5661 float y = height*ur[1] - h; 5662 5663 float xx = -width*0.5f + x; 5664 float yy = -height*0.5f + y; 5665 5666 _tsf->set_translate(xx,yy,zz); 5667 } 5668 5669 _tsf->mul_translate(xxx,yyy,0); //appli 5670 5671 } 5672 } 5673 5674 void update_background(){ 5675 m_background_sep.clear(); 5676 if(!m_background_style.visible) return; 5677 5678 matrix* _tsf = new matrix; 5679 m_background_sep.add(_tsf); 5680 5681 float w2 = width*0.5F; 5682 float h2 = height*0.5F; 5683 5684 float zz = 0; //in xy, then before first 5685 if(m_shape==xyz) zz = -depth*0.5f; 5686 5687 {rgba* mat = new rgba(); 5688 if(m_background_style.line_width) { //the 5689 mat->color = m_background_style.color; 5690 } else { 5691 mat->color = m_background_style.back_co 5692 } 5693 m_background_sep.add(mat); 5694 5695 m_background_sep.add(new normal); 5696 5697 vertices* vtxs = new vertices; 5698 vtxs->mode = gl::triangle_fan(); 5699 m_background_sep.add(vtxs); 5700 5701 vtxs->add(-w2,-h2,zz); 5702 vtxs->add( w2,-h2,zz); 5703 vtxs->add( w2, h2,zz); 5704 vtxs->add(-w2, h2,zz);} 5705 5706 if(m_background_style.line_width) { //bor 5707 //WARNING : line_width should be in per 5708 5709 //NOTE : border is done by drawing a fr 5710 5711 rgba* mat = new rgba(); 5712 mat->color = m_background_style.back_co 5713 m_background_sep.add(mat); 5714 5715 vertices* vtxs = new vertices; 5716 vtxs->mode = gl::triangle_fan(); 5717 m_background_sep.add(vtxs); 5718 5719 //float d = width*0.005; 5720 float d = width*m_background_style.line 5721 5722 zz += _zoffset()*0.5f; 5723 5724 vtxs->add(-w2+d,-h2+d,zz); 5725 vtxs->add( w2-d,-h2+d,zz); 5726 vtxs->add( w2-d, h2-d,zz); 5727 vtxs->add(-w2+d, h2-d,zz); 5728 } 5729 5730 } 5731 5732 void update_inner_frame_XY(){ 5733 if(!m_inner_frame_style.visible) return; 5734 5735 rgba* mat = new rgba(); 5736 mat->color = m_inner_frame_style.color; 5737 m_inner_frame_sep.add(mat); 5738 5739 draw_style* ds = new draw_style; 5740 ds->style = draw_lines; 5741 ds->line_pattern = m_inner_frame_style.li 5742 ds->line_width = m_inner_frame_style.line 5743 m_inner_frame_sep.add(ds); 5744 5745 vertices* vtxs = new vertices; 5746 vtxs->mode = gl::line_strip(); 5747 m_inner_frame_sep.add(vtxs); 5748 5749 float zz = _zgrid(); 5750 5751 vtxs->add(0,0,zz); 5752 vtxs->add(1,0,zz); 5753 vtxs->add(1,1,zz); 5754 vtxs->add(0,1,zz); 5755 vtxs->add(0,0,zz); 5756 } 5757 5758 void update_inner_frame_XYZ(){ 5759 if(!m_inner_frame_style.visible) return; 5760 5761 rgba* mat = new rgba(); 5762 mat->color = m_inner_frame_style.color; 5763 m_inner_frame_sep.add(mat); 5764 5765 draw_style* ds = new draw_style; 5766 ds->style = draw_lines; 5767 ds->line_pattern = m_inner_frame_style.li 5768 ds->line_width = m_inner_frame_style.line 5769 m_inner_frame_sep.add(ds); 5770 5771 vertices* ls = new vertices; 5772 ls->mode = gl::lines(); 5773 m_inner_frame_sep.add(ls); 5774 5775 // z bottom : 5776 ls->add(0,0,0);ls->add(1,0,0); 5777 ls->add(1,0,0);ls->add(1,1,0); 5778 ls->add(1,1,0);ls->add(0,1,0); 5779 ls->add(0,1,0);ls->add(0,0,0); 5780 5781 // z top : 5782 ls->add(0,0,1);ls->add(1,0,1); 5783 ls->add(1,0,1);ls->add(1,1,1); 5784 ls->add(1,1,1);ls->add(0,1,1); 5785 ls->add(0,1,1);ls->add(0,0,1); 5786 5787 // sides along z : 5788 ls->add(0,0,0);ls->add(0,0,1); 5789 ls->add(1,0,0);ls->add(1,0,1); 5790 ls->add(1,1,0);ls->add(1,1,1); 5791 ls->add(0,1,0);ls->add(0,1,1); 5792 } 5793 5794 void update_grid_XY(){ 5795 if(!m_grid_style.visible) return; 5796 5797 unsigned int number = m_x_axis.tick_numbe 5798 if(number<=0) return; 5799 5800 bool draw_vertical = true; 5801 bool draw_horizontal = true; 5802 if(m_grid_style.options.value()=="vertica 5803 if(m_grid_style.options.value()=="horizon 5804 5805 rgba* mat = new rgba(); 5806 mat->color = m_grid_style.color; 5807 m_grid_sep.add(mat); 5808 5809 draw_style* ds = new draw_style; 5810 ds->style = draw_lines; 5811 ds->line_pattern = line_solid; 5812 ds->line_width = m_grid_style.line_width; 5813 m_grid_sep.add(ds); 5814 5815 float zz = _zgrid(); 5816 5817 vertices* vtxs = new vertices; 5818 vtxs->mode = gl::lines(); 5819 m_grid_sep.add(vtxs); 5820 5821 std::vector<float>& pts = vtxs->xyzs.valu 5822 5823 bool is_solid = m_grid_style.line_pattern 5824 5825 if(draw_vertical) { 5826 float _width = m_y_axis.width; 5827 float xx; 5828 {size_t _number = m_x_axis.coords.size() 5829 if(is_solid) { 5830 pts.reserve(_number*6); 5831 for(size_t count=0;count<_number;coun 5832 xx = m_x_axis.coords[count]; 5833 vtxs->add(xx, 0 ,zz); 5834 vtxs->add(xx, _width,zz); 5835 } 5836 } else { 5837 pts.reserve(_number*100*6); 5838 for(size_t count=0;count<_number;coun 5839 xx = m_x_axis.coords[count]; 5840 vtxs->add_dashed_line(xx,0,zz,xx,_w 5841 } 5842 }} 5843 if(m_x_axis.is_log) { 5844 size_t _number = m_x_axis.sub_coords. 5845 if(is_solid) { 5846 pts.reserve(_number*6); 5847 for(size_t count=0;count<_number;co 5848 xx = m_x_axis.sub_coords[count]; 5849 vtxs->add(xx, 0 ,zz); 5850 vtxs->add(xx,_width,zz); 5851 } 5852 } else { 5853 pts.reserve(_number*100*6); 5854 for(size_t count=0;count<_number;co 5855 xx = m_x_axis.sub_coords[count]; 5856 vtxs->add_dashed_line(xx,0,zz,xx, 5857 } 5858 } 5859 } 5860 } 5861 5862 if(draw_horizontal) { 5863 float _width = m_x_axis.width; 5864 float yy; 5865 {size_t _number = m_y_axis.coords.size() 5866 if(is_solid) { 5867 pts.reserve(_number*6); 5868 for(size_t count=0;count<_number;coun 5869 yy = m_y_axis.coords[count]; 5870 vtxs->add(0,yy ,zz); 5871 vtxs->add(_width,yy,zz); 5872 } 5873 } else { 5874 pts.reserve(_number*100*6); 5875 for(size_t count=0;count<_number;coun 5876 yy = m_y_axis.coords[count]; 5877 vtxs->add_dashed_line(0,yy,zz,_widt 5878 } 5879 }} 5880 if(m_y_axis.is_log) { 5881 size_t _number = m_y_axis.sub_coords. 5882 if(is_solid) { 5883 pts.reserve(_number*6); 5884 for(size_t count=0;count<_number;co 5885 yy = m_y_axis.sub_coords[count]; 5886 vtxs->add(0,yy, zz); 5887 vtxs->add(_width,yy,zz); 5888 } 5889 } else { 5890 pts.reserve(_number*100*6); 5891 for(size_t count=0;count<_number;co 5892 yy = m_y_axis.sub_coords[count]; 5893 vtxs->add_dashed_line(0,yy,zz,_wi 5894 } 5895 } 5896 } 5897 } 5898 5899 } 5900 5901 void update_grid_XYZ(){ 5902 if(!m_grid_style.visible) return; 5903 5904 rgba* mat = new rgba(); 5905 mat->color = m_grid_style.color; 5906 m_grid_sep.add(mat); 5907 5908 draw_style* ds = new draw_style; 5909 ds->style = draw_lines; 5910 ds->line_pattern = m_grid_style.line_patt 5911 ds->line_width = m_grid_style.line_width; 5912 m_grid_sep.add(ds); 5913 5914 /* 5915 vertices* vtxs = new vertices; 5916 vtxs->mode = gl::line_strip(); 5917 m_grid_sep.add(vtxs); 5918 5919 float z = 0.5F; 5920 5921 vtxs->add(0,0,z); 5922 vtxs->add(1,0,z); 5923 vtxs->add(1,1,z); 5924 vtxs->add(0,1,z); 5925 vtxs->add(0,0,z); 5926 */ 5927 /* 5928 int ntick = m_z_axis.tickNumber; 5929 if(ntick<=0) return; 5930 5931 SoSeparator* sep = (SoSeparator*)gridSepara 5932 5933 sep->addChild(fStyleCache->getMaterial 5934 (style->color.value(), 5935 style->transparency.value())) 5936 5937 sep->addChild(getLineStyle(*style)); 5938 5939 vec3f* points = new vec3f[4 * ntick]; 5940 int pos = 0; 5941 for(int count=0;count<ntick;count++) { 5942 float xe = m_x_axis.width.value(); 5943 float ye = m_y_axis.width.value(); 5944 float zz = m_z_axis.coords[count]; 5945 LIST_SET(points,pos,0 ,ye,zz);pos++; 5946 LIST_SET(points,pos,xe,ye,zz);pos++; 5947 LIST_SET(points,pos,xe,ye,zz);pos++; 5948 LIST_SET(points,pos,xe,0 ,zz);pos++; 5949 } 5950 if(pos>0) { 5951 SoCoordinate3* coordinate3 = new SoCoordi 5952 int32_t pointn = pos; 5953 coordinate3->point.setValues(0,pointn,poi 5954 sep->addChild(coordinate3); 5955 5956 SoLineSet* lineSet = new SoLineSet; 5957 int segmentn = pointn/2; 5958 int32_t* vertices = new int32_t[segmentn] 5959 for (int count=0;count<segmentn;count++) 5960 lineSet->numVertices.setValues(0,segmentn 5961 delete [] vertices; 5962 sep->addChild(lineSet); 5963 } 5964 5965 delete [] points; 5966 */ 5967 } 5968 5969 protected: //rep 5970 /////////////////////////////////////////// 5971 // reps xy //////////////////////////////// 5972 /////////////////////////////////////////// 5973 void rep_bins1D_xy_top_lines(const style& a 5974 const base_col 5975 const std::vec 5976 const rep_box& 5977 const rep_box& 5978 float a_zz/*, 5979 const std::str 5980 painting_policy painting = a_style.painti 5981 5982 float xmin = a_box_x.m_pos; 5983 float dx = a_box_x.m_width; 5984 bool xlog = a_box_x.m_log; 5985 5986 float ymin = a_box_y.m_pos; 5987 float dy = a_box_y.m_width; 5988 bool ylog = a_box_y.m_log; 5989 5990 float y0 = 0; 5991 y0 = verify_log(y0,ymin,dy,ylog); 5992 if(y0<0) y0 = 0; 5993 if(y0>1) y0 = 1; 5994 5995 separator* _sep = new separator(); 5996 5997 draw_style* ds = new draw_style; 5998 ds->style = draw_lines; 5999 ds->line_pattern = a_style.line_pattern; 6000 ds->line_width = a_style.line_width; 6001 _sep->add(ds); 6002 6003 bool empty = true; 6004 colorf clr; 6005 6006 float yp = 0; 6007 size_t xnbin = a_bins.size(); 6008 for(size_t index=0;index<xnbin;index++) { 6009 float xx = a_bins[index].m_x_min; 6010 float xe = a_bins[index].m_x_max; 6011 float y = a_bins[index].m_val; 6012 6013 float val = a_bins[index].m_val; 6014 6015 xx = verify_log(xx,xmin,dx,xlog); 6016 xe = verify_log(xe,xmin,dx,xlog); 6017 y = verify_log(y,ymin,dy,ylog); 6018 6019 // Clipping : 6020 if(xe<0) continue; 6021 if(xx>1) continue; 6022 if(xx<0) xx = 0; 6023 if(xe>1) xe = 1; 6024 if(y<0) y = 0; 6025 if(y>1) y = 1; 6026 6027 separator* sep = new separator(); 6028 _sep->add(sep); 6029 6030 /*uuu 6031 a_bins[index].fSeparator = sep; 6032 6033 {char s[128]; 6034 //::sprintf(s,"%d",index); 6035 sep->setInfos(s); 6036 //::sprintf(s,"/0x%lx",(unsigned long)s 6037 std::string sid = aID; 6038 sid += std::string(s); 6039 sep->setString(sid);}*/ 6040 6041 if(painting==painting_by_value) { 6042 a_cmap.get_color(val,clr); 6043 } else if( (painting==painting_grey_sca 6044 (painting==painting_grey_sca 6045 (painting==painting_violet_t 6046 a_cmap.get_color(a_bins[index].m_rati 6047 } else { 6048 clr = a_style.color; 6049 } 6050 6051 rgba* mat = new rgba(); 6052 mat->color = clr; 6053 sep->add(mat); 6054 6055 vertices* vtxs = new vertices; 6056 vtxs->mode = gl::line_strip(); 6057 sep->add(vtxs); 6058 6059 vtxs->add(xx,yp,a_zz); 6060 vtxs->add(xx,y,a_zz); 6061 vtxs->add(xe,y,a_zz); 6062 if(index==xnbin-1){ 6063 vtxs->add(xe,y0,a_zz); 6064 } 6065 6066 empty = false; 6067 yp = y; 6068 } 6069 6070 if(empty) { 6071 delete _sep; 6072 } else { 6073 m_bins_sep.add(_sep); 6074 } 6075 } 6076 6077 void rep_bins1D_xy_points(std::ostream& a_o 6078 const style& a_st 6079 const base_colorm 6080 const std::vector 6081 const rep_box& a_ 6082 const rep_box& a_ 6083 float a_zz/*, 6084 const std::string 6085 //::printf("debug : tools::sg::plotter::r 6086 float xmin = a_box_x.m_pos; 6087 float dx = a_box_x.m_width; 6088 bool xlog = a_box_x.m_log; 6089 6090 float ymin = a_box_y.m_pos; 6091 float dy = a_box_y.m_width; 6092 bool ylog = a_box_y.m_log; 6093 6094 painting_policy painting = a_style.painti 6095 6096 separator* _sep = new separator(); 6097 6098 if(a_style.modeling==modeling_points()) { 6099 draw_style* ds = new draw_style; 6100 ds->style = draw_points; 6101 ds->point_size = a_style.point_size; 6102 _sep->add(ds); 6103 } 6104 6105 bool empty = true; 6106 colorf clr; 6107 size_t xnbin = a_bins.size(); 6108 for(size_t index=0;index<xnbin;index++) { 6109 float x = (a_bins[index].m_x_min + a_bi 6110 float y = a_bins[index].m_val; 6111 float val = a_bins[index].m_val; 6112 6113 x = verify_log(x,xmin,dx,xlog); 6114 y = verify_log(y,ymin,dy,ylog); 6115 6116 if((x<0)||(x>1)||(y<0)||(y>1)) continue 6117 6118 //::printf("debug : tools::sg::plotter: 6119 6120 separator* sep = new separator(); 6121 _sep->add(sep); 6122 6123 //a_bins[index].fSeparator = sep; 6124 6125 //{char s[128]; 6126 // ::sprintf(s,"%d",index); 6127 // sep->setInfos(s); 6128 // ::sprintf(s,"/0x%lx",(unsigned long)s 6129 // std::string sid = aID; 6130 // sid += std::string(s); 6131 // sep->setString(sid);} 6132 6133 if(painting==painting_by_value) { 6134 a_cmap.get_color(val,clr); 6135 } else if( (painting==painting_grey_sca 6136 (painting==painting_grey_sca 6137 (painting==painting_violet_t 6138 a_cmap.get_color(a_bins[index].m_rati 6139 } else { 6140 clr = a_style.color; 6141 } 6142 6143 rgba* mat = new rgba(); 6144 mat->color = clr; 6145 sep->add(mat); 6146 6147 if(a_style.modeling==modeling_points()) 6148 vertices* vtxs = new vertices; 6149 vtxs->mode = gl::points(); 6150 vtxs->add(x,y,a_zz); 6151 sep->add(vtxs); 6152 } else if(a_style.modeling==modeling_ma 6153 markers* _marks = new markers; 6154 _marks->size = a_style.marker_size; 6155 _marks->style = a_style.marker_style; 6156 _marks->add(x,y,a_zz); 6157 sep->add(_marks); 6158 } else { 6159 a_out << "tools::sg::plotter::rep_bin 6160 << " bad modeling style " << to 6161 delete _sep; 6162 return; 6163 } 6164 6165 empty = false; 6166 } 6167 6168 if(empty) { 6169 delete _sep; 6170 } else { 6171 m_bins_sep.add(_sep); 6172 } 6173 } 6174 6175 void rep_bins1D_xy_boxes(const style& a_sty 6176 const base_colorma 6177 const std::vector< 6178 const rep_box& a_b 6179 const rep_box& a_b 6180 float a_zz //,cons 6181 ){ 6182 painting_policy painting = a_style.painti 6183 6184 float xmin = a_box_x.m_pos; 6185 float dx = a_box_x.m_width; 6186 bool xlog = a_box_x.m_log; 6187 6188 float ymin = a_box_y.m_pos; 6189 float dy = a_box_y.m_width; 6190 bool ylog = a_box_y.m_log; 6191 6192 separator* _sep = new separator(); 6193 6194 _sep->add(new normal); 6195 6196 bool empty = true; 6197 colorf clr; 6198 6199 tools_vforcit(rep_bin1D,a_bins,it) { 6200 const rep_bin1D& rbin = *it; 6201 6202 float xx = rbin.m_x_min; 6203 float xe = rbin.m_x_max; 6204 float yy = rbin.m_v_min; 6205 float ye = rbin.m_val; 6206 if(ye<yy) { 6207 yy = rbin.m_val; 6208 ye = rbin.m_v_min; 6209 } 6210 6211 float val = rbin.m_val; 6212 6213 xx = verify_log(xx,xmin,dx,xlog); 6214 xe = verify_log(xe,xmin,dx,xlog); 6215 yy = verify_log(yy,ymin,dy,ylog); 6216 ye = verify_log(ye,ymin,dy,ylog); 6217 6218 // Clipping : 6219 if(xx>1) continue; 6220 if(xe<0) continue; 6221 if(xx<0) xx = 0; 6222 if(xe>1) xe = 1; 6223 if(yy>1) continue; 6224 if(ye<0) continue; 6225 if(yy<0) yy = 0; 6226 if(ye>1) ye = 1; 6227 6228 //FIXME if(ye<=yy) continue; //Else we 6229 6230 separator* sep = new separator(); 6231 _sep->add(sep); 6232 6233 //a_bins[index].fSeparator = sep; 6234 //{char s[128]; 6235 //::sprintf(s,"%d",index); 6236 //sep->setInfos(s); 6237 //::sprintf(s,"/0x%lx",(unsigned long)sep 6238 //std::string sid = aID; 6239 //sid += std::string(s); 6240 //sep->setString(sid);} 6241 6242 if(painting==painting_by_value) { 6243 a_cmap.get_color(val,clr); 6244 } else if( (painting==painting_grey_sca 6245 (painting==painting_grey_sca 6246 (painting==painting_violet_t 6247 a_cmap.get_color(rbin.m_ratio,clr); 6248 } else { 6249 clr = a_style.color; 6250 } 6251 6252 rgba* mat = new rgba(); 6253 mat->color = clr; 6254 sep->add(mat); 6255 6256 vertices* vtxs = new vertices; 6257 vtxs->mode = gl::triangle_fan(); 6258 sep->add(vtxs); 6259 6260 vtxs->add(xx,yy,a_zz); 6261 vtxs->add(xe,yy,a_zz); 6262 vtxs->add(xe,ye,a_zz); 6263 vtxs->add(xx,ye,a_zz); 6264 6265 empty = false; 6266 } 6267 6268 if(empty) { 6269 delete _sep; 6270 } else { 6271 m_bins_sep.add(_sep); 6272 } 6273 } 6274 6275 void rep_bins1D_xy_wire_boxes(const style& 6276 const base_co 6277 const std::ve 6278 const rep_box 6279 float a_zz, 6280 bool a_bar_ch 6281 const std::st 6282 6283 painting_policy painting = a_style.painti 6284 6285 float xmin = a_box_x.m_pos; 6286 float dx = a_box_x.m_width; 6287 bool xlog = a_box_x.m_log; 6288 6289 float ymin = a_box_y.m_pos; 6290 float dy = a_box_y.m_width; 6291 bool ylog = a_box_y.m_log; 6292 6293 separator* _sep = new separator(); 6294 6295 bool empty = true; 6296 colorf clr; 6297 6298 tools_vforcit(rep_bin1D,a_bins,it) { 6299 const rep_bin1D& rbin = *it; 6300 6301 float xx = rbin.m_x_min; 6302 float xe = rbin.m_x_max; 6303 float yy = rbin.m_v_min; 6304 float ye = rbin.m_val; 6305 if(ye<yy) { 6306 yy = rbin.m_val; 6307 ye = rbin.m_v_min; 6308 } 6309 6310 float val = rbin.m_val; 6311 6312 if(a_bar_chart) { 6313 bar_chart(a_style.bar_offset.value(), 6314 a_style.bar_width.value(),x 6315 } 6316 6317 xx = verify_log(xx,xmin,dx,xlog); 6318 xe = verify_log(xe,xmin,dx,xlog); 6319 yy = verify_log(yy,ymin,dy,ylog); 6320 ye = verify_log(ye,ymin,dy,ylog); 6321 6322 // Clipping : 6323 if(xx>1) continue; 6324 if(xe<0) continue; 6325 if(xx<0) xx = 0; 6326 if(xe>1) xe = 1; 6327 if(yy>1) continue; 6328 if(ye<0) continue; 6329 if(yy<0) yy = 0; 6330 if(ye>1) ye = 1; 6331 6332 separator* sep = new separator(); 6333 _sep->add(sep); 6334 6335 //{char s[128]; 6336 //::sprintf(s,"%d",index); 6337 //sep->setInfos(s); 6338 //::sprintf(s,"/0x%lx",(unsigned long)sep 6339 //std::string sid = aID; 6340 //sid += std::string(s); 6341 //sep->setString(sid);} 6342 6343 if(painting==painting_by_value) { 6344 a_cmap.get_color(val,clr); 6345 } else if( (painting==painting_grey_sca 6346 (painting==painting_grey_sca 6347 (painting==painting_violet_t 6348 a_cmap.get_color(rbin.m_ratio,clr); 6349 } else { 6350 clr = a_style.color; 6351 } 6352 6353 rgba* mat = new rgba(); 6354 mat->color = clr; 6355 sep->add(mat); 6356 6357 vertices* vtxs = new vertices; 6358 vtxs->mode = gl::line_strip(); 6359 sep->add(vtxs); 6360 6361 vtxs->add(xx,yy,a_zz); 6362 vtxs->add(xe,yy,a_zz); 6363 vtxs->add(xe,ye,a_zz); 6364 vtxs->add(xx,ye,a_zz); 6365 vtxs->add(xx,yy,a_zz); 6366 6367 empty = false; 6368 } 6369 6370 if(empty) { 6371 delete _sep; 6372 } else { 6373 m_bins_sep.add(_sep); 6374 } 6375 } 6376 6377 void rep_bins1D_xy_lines_one(const style& a 6378 const rep_box& 6379 // Draw lines connecting top middle of bi 6380 6381 //::printf("debug : rep_bins2D_lines_one\ 6382 6383 size_t xnbin = a_bins.size(); 6384 std::vector<vec3f> points(xnbin); 6385 for(size_t index=0;index<xnbin;index++) { 6386 float x = (a_bins[index].m_x_min + a_bi 6387 float y = a_bins[index].m_val; 6388 points[index] = vec3f(x,y,a_zz); 6389 } 6390 6391 vertices* vtxs = new vertices; 6392 std::vector<float>& pts = vtxs->xyzs.valu 6393 6394 clip_polyline_2D(points,a_box_x,a_box_y,p 6395 if(pts.size()) { 6396 sg::separator* separator = new sg::sepa 6397 //separator->setString(aID); 6398 6399 rgba* mat = new rgba(); 6400 mat->color = a_style.color; 6401 separator->add(mat); 6402 6403 draw_style* ds = new draw_style; 6404 ds->style = draw_lines; 6405 ds->line_pattern = a_style.line_pattern 6406 ds->line_width = a_style.line_width; 6407 separator->add(ds); 6408 6409 vtxs->mode = gl::line_strip(); 6410 separator->add(vtxs); 6411 6412 m_bins_sep.add(separator); 6413 } else { 6414 delete vtxs; 6415 } 6416 } 6417 6418 void rep_bins1D_xy_curve_one(std::ostream& 6419 const rep_box& 6420 //::printf("debug : rep_bins1D_curve_one\ 6421 6422 size_t number = a_bins.size(); 6423 if(!number) return; 6424 6425 double* xs = new double[number]; 6426 double* ys = new double[number]; 6427 float x,y; 6428 for(size_t index=0;index<number;index++) 6429 x = (a_bins[index].m_x_min + a_bins[ind 6430 y = a_bins[index].m_val; 6431 xs[index] = x;ys[index] = y; 6432 } 6433 spline::cubic _spline(a_out,number,xs,ys) 6434 //spline::quintic _spline(a_out,number,xs,y 6435 delete [] xs;delete [] ys; 6436 6437 float xmn = m_x_axis_data.min_value(); 6438 float xmx = m_x_axis_data.max_value(); 6439 unsigned int nstp = curve_number_of_point 6440 float step = (xmx - xmn)/nstp; 6441 std::vector<vec3f> points(nstp+1); 6442 for(unsigned int ibin=0;ibin<=nstp;ibin++ 6443 float xx = xmn + ibin * step; 6444 double val = _spline.eval(xx); 6445 points[ibin].set_value(xx,float(val),a_ 6446 } 6447 6448 vertices* vtxs = new vertices; 6449 std::vector<float>& pts = vtxs->xyzs.valu 6450 6451 clip_polyline_2D(points,a_box_x,a_box_y,p 6452 if(pts.size()) { 6453 sg::separator* separator = new sg::sepa 6454 //separator->setString(aID); 6455 6456 rgba* mat = new rgba(); 6457 mat->color = a_style.color; 6458 separator->add(mat); 6459 6460 draw_style* ds = new draw_style; 6461 ds->style = draw_lines; 6462 ds->line_pattern = a_style.line_pattern 6463 ds->line_width = a_style.line_width; 6464 separator->add(ds); 6465 6466 vtxs->mode = gl::line_strip(); 6467 separator->add(vtxs); 6468 6469 m_bins_sep.add(separator); 6470 } else { 6471 delete vtxs; 6472 } 6473 6474 } 6475 6476 6477 void rep_bins2D_xy_box(const style& a_style 6478 const rep_box& a_box 6479 // Draw box of size proportionnal to bin 6480 6481 //std::cout << "debug : tools::sg::plotte 6482 6483 separator* _sep = new separator(); 6484 6485 _sep->add(new normal); 6486 6487 rgba* mat = new rgba(); 6488 mat->color = a_style.color; 6489 _sep->add(mat); 6490 6491 float xmin = a_box_x.m_pos; 6492 float dx = a_box_x.m_width; 6493 bool xlog = a_box_x.m_log; 6494 6495 float ymin = a_box_y.m_pos; 6496 float dy = a_box_y.m_width; 6497 bool ylog = a_box_y.m_log; 6498 6499 bool empty = true; 6500 float range = a_bmax - a_bmin; 6501 6502 tools_vforcit(rep_bin2D,a_bins,it) { 6503 const rep_bin2D& rbin = *it; 6504 6505 float xx = rbin.m_x_min; 6506 float xe = rbin.m_x_max; 6507 float yy = rbin.m_y_min; 6508 float ye = rbin.m_y_max; 6509 float val = rbin.m_val; 6510 6511 float xsize,ysize; 6512 if(range>0) { 6513 // If val = bmax, the box maps the ce 6514 xsize = (val - a_bmin) * (xe - xx) / 6515 ysize = (val - a_bmin) * (ye - yy) / 6516 } else { 6517 //If range is 0. ; then all bins that 6518 // entries have same values. Draw box 6519 xsize = xe - xx; 6520 ysize = ye - yy; 6521 } 6522 6523 xx = xx + ((xe-xx) - xsize)/2; 6524 xe = xx + xsize; 6525 yy = yy + ((ye-yy) - ysize)/2; 6526 ye = yy + ysize; 6527 6528 xx = verify_log(xx ,xmin,dx ,xlog); 6529 xe = verify_log(xe ,xmin,dx ,xlog); 6530 yy = verify_log(yy ,ymin,dy ,ylog); 6531 ye = verify_log(ye ,ymin,dy ,ylog); 6532 6533 // Clipping : 6534 if(xx>1) continue; 6535 if(xe<0) continue; 6536 if(xx<0) xx = 0; 6537 if(xe>1) xe = 1; 6538 if(yy>1) continue; 6539 if(ye<0) continue; 6540 if(yy<0) yy = 0; 6541 if(ye>1) ye = 1; 6542 6543 //sg::separator* sep = new separator(); 6544 //_sep->add(sep); 6545 6546 /*{char s[128]; 6547 //::sprintf(s,"%d %d",rbin.fI,rbin.fJ); 6548 sep->setInfos(s); 6549 //::sprintf(s,"/0x%lx",(unsigned long)s 6550 std::string sid = aID; 6551 sid += std::string(s); 6552 sep->setString(sid);}*/ 6553 6554 vertices* vtxs = new vertices; 6555 vtxs->mode = gl::triangle_fan(); 6556 //sep->add(vtxs); 6557 _sep->add(vtxs); 6558 6559 vtxs->add(xx,yy,a_zz); 6560 vtxs->add(xe,yy,a_zz); 6561 vtxs->add(xe,ye,a_zz); 6562 vtxs->add(xx,ye,a_zz); 6563 6564 empty = false; 6565 } 6566 6567 if(empty) { 6568 delete _sep; 6569 } else { 6570 m_bins_sep.add(_sep); 6571 } 6572 } 6573 6574 void rep_bins2D_xy_wire_box(const style& a_ 6575 const std::vect 6576 const rep_box& a_box_x,const rep_ 6577 float a_bmin,float a_bmax,float a 6578 /*,const SbStri 6579 // Draw box of size proportionnal to bin 6580 6581 sg::separator* separator = new sg::separa 6582 6583 rgba* mat = new rgba(); 6584 mat->color = a_style.color; 6585 separator->add(mat); 6586 6587 draw_style* ds = new draw_style; 6588 ds->style = draw_lines; 6589 ds->line_pattern = a_style.line_pattern; 6590 ds->line_width = a_style.line_width; 6591 separator->add(ds); 6592 6593 vertices* vtxs = new vertices; 6594 vtxs->mode = gl::lines(); 6595 separator->add(vtxs); 6596 6597 bool empty = true; 6598 6599 float xmin = a_box_x.m_pos; 6600 float dx = a_box_x.m_width; 6601 bool xlog = a_box_x.m_log; 6602 6603 float ymin = a_box_y.m_pos; 6604 float dy = a_box_y.m_width; 6605 bool ylog = a_box_y.m_log; 6606 6607 float range = a_bmax - a_bmin; 6608 size_t number = a_bins.size(); 6609 for(size_t index=0;index<number;index++) 6610 6611 float xx = a_bins[index].m_x_min; 6612 float xe = a_bins[index].m_x_max; 6613 float yy = a_bins[index].m_y_min; 6614 float ye = a_bins[index].m_y_max; 6615 float val = a_bins[index].m_val; 6616 6617 float xsize,ysize; 6618 if(range>0) { 6619 // If val = bmax, the box maps the ce 6620 xsize = (val - a_bmin) * (xe - xx) / 6621 ysize = (val - a_bmin) * (ye - yy) / 6622 } else { 6623 //If range is 0. ; then all bins that 6624 // entries have same values. Draw box 6625 xsize = xe - xx; 6626 ysize = ye - yy; 6627 } 6628 6629 xx = xx + ((xe-xx) - xsize)/2; 6630 xe = xx + xsize; 6631 yy = yy + ((ye-yy) - ysize)/2; 6632 ye = yy + ysize; 6633 6634 xx = verify_log(xx ,xmin,dx ,xlog); 6635 xe = verify_log(xe ,xmin,dx ,xlog); 6636 yy = verify_log(yy ,ymin,dy ,ylog); 6637 ye = verify_log(ye ,ymin,dy ,ylog); 6638 6639 // Clipping : 6640 if(xx>1) continue; 6641 if(xe<0) continue; 6642 if(xx<0) xx = 0; 6643 if(xe>1) xe = 1; 6644 if(yy>1) continue; 6645 if(ye<0) continue; 6646 if(yy<0) yy = 0; 6647 if(ye>1) ye = 1; 6648 6649 //::printf("debug : zzzzuu : %g %g %g % 6650 6651 //{char s[128]; 6652 // ::sprintf(s,"%d %d",a_bins[index].fI, 6653 // sep->setInfos(s);} 6654 //{std::string sp; 6655 // if(!p2sx(sep->getInfos(),sp)){} 6656 // std::string sid(aID.getString()); 6657 // sid += "/"+sp; 6658 // sep->setString(sid.c_str());} 6659 6660 //vertices* vtxs = new vertices; 6661 //vtxs->mode = gl::line_strip(); 6662 //separator->add(vtxs); 6663 //vtxs->add(xx,yy,a_zz); 6664 //vtxs->add(xe,yy,a_zz); 6665 //vtxs->add(xe,ye,a_zz); 6666 //vtxs->add(xx,ye,a_zz); 6667 //vtxs->add(xx,yy,a_zz); 6668 6669 vtxs->add(xx,yy,a_zz); 6670 vtxs->add(xe,yy,a_zz); 6671 6672 vtxs->add(xe,yy,a_zz); 6673 vtxs->add(xe,ye,a_zz); 6674 6675 vtxs->add(xe,ye,a_zz); 6676 vtxs->add(xx,ye,a_zz); 6677 6678 vtxs->add(xx,ye,a_zz); 6679 vtxs->add(xx,yy,a_zz); 6680 6681 empty = false; 6682 } 6683 6684 if(empty) { 6685 delete separator; 6686 } else { 6687 m_bins_sep.add(separator); 6688 } 6689 } 6690 6691 void rep_bins2D_xy_solid(const style& a_sty 6692 const rep_box& a_b 6693 painting_policy painting = a_style.painti 6694 6695 separator* _sep = new separator(); 6696 6697 _sep->add(new normal); 6698 6699 float xmin = a_box_x.m_pos; 6700 float dx = a_box_x.m_width; 6701 bool xlog = a_box_x.m_log; 6702 6703 float ymin = a_box_y.m_pos; 6704 float dy = a_box_y.m_width; 6705 bool ylog = a_box_y.m_log; 6706 6707 bool empty = true; 6708 colorf clr; 6709 6710 tools_vforcit(rep_bin2D,a_bins,it) { 6711 const rep_bin2D& rbin = *it; 6712 6713 float xx = rbin.m_x_min; 6714 float xe = rbin.m_x_max; 6715 float yy = rbin.m_y_min; 6716 float ye = rbin.m_y_max; 6717 float val = rbin.m_val; 6718 6719 xx = verify_log(xx ,xmin,dx ,xlog); 6720 xe = verify_log(xe ,xmin,dx ,xlog); 6721 yy = verify_log(yy ,ymin,dy ,ylog); 6722 ye = verify_log(ye ,ymin,dy ,ylog); 6723 6724 // Clipping : 6725 if(xx>1) continue; 6726 if(xe<0) continue; 6727 if(xx<0) xx = 0; 6728 if(xe>1) xe = 1; 6729 if(yy>1) continue; 6730 if(ye<0) continue; 6731 if(yy<0) yy = 0; 6732 if(ye>1) ye = 1; 6733 6734 if(painting==painting_by_value) { 6735 a_cmap.get_color(val,clr); 6736 } else if( (painting==painting_grey_sca 6737 (painting==painting_grey_sca 6738 (painting==painting_violet_t 6739 a_cmap.get_color(rbin.m_ratio,clr); 6740 } else { 6741 clr = a_style.color; 6742 } 6743 6744 rgba* mat = new rgba(); 6745 mat->color = clr; 6746 _sep->add(mat); 6747 6748 vertices* vtxs = new vertices; 6749 vtxs->mode = gl::triangle_fan(); 6750 //sep->add(vtxs); 6751 _sep->add(vtxs); 6752 6753 vtxs->add(xx,yy,a_zz); 6754 vtxs->add(xe,yy,a_zz); 6755 vtxs->add(xe,ye,a_zz); 6756 vtxs->add(xx,ye,a_zz); 6757 6758 empty = false; 6759 } 6760 6761 if(empty) { 6762 delete _sep; 6763 } else { 6764 m_bins_sep.add(_sep); 6765 } 6766 } 6767 6768 void rep_bins2D_xy_random_one(const style& 6769 const rep_box 6770 /*,const SbSt 6771 //::printf("debug : rep_bins2D_xy_random_ 6772 6773 sg::separator* separator = new sg::separa 6774 6775 rgba* mat = new rgba(); 6776 mat->color = a_style.color; 6777 separator->add(mat); 6778 6779 draw_style* ds = new draw_style; 6780 ds->style = draw_points; 6781 ds->point_size = a_style.point_size; 6782 separator->add(ds); 6783 6784 float xmin = a_box_x.m_pos; 6785 float dx = a_box_x.m_width; 6786 bool xlog = a_box_x.m_log; 6787 6788 float ymin = a_box_y.m_pos; 6789 float dy = a_box_y.m_width; 6790 bool ylog = a_box_y.m_log; 6791 6792 // Draw for each bins a number of random 6793 // points proportiannal to bins range. 6794 6795 float range = a_bmax - a_bmin; 6796 6797 bool empty = true; 6798 6799 size_t number = a_bins.size(); 6800 for(size_t index=0;index<number;index++) 6801 6802 float xx = a_bins[index].m_x_min; 6803 float xe = a_bins[index].m_x_max; 6804 float yy = a_bins[index].m_y_min; 6805 float ye = a_bins[index].m_y_max; 6806 float val = a_bins[index].m_val; 6807 6808 // If range is 0. ; then all bins that 6809 // have same values. Draw one point. 6810 6811 int nmin = 1; 6812 int nmax = 50; 6813 int npt = range>0. ? (int)((val - a_bmi 6814 if(npt>0) { 6815 vertices* vtxs = new vertices; 6816 vtxs->mode = gl::points(); 6817 separator->add(vtxs); 6818 6819 float xdbin = xe - xx; 6820 float ydbin = ye - yy; 6821 for(int count=0;count<npt;count++) { 6822 float xxx = xx + xdbin * m_rtausmef 6823 float yyy = yy + ydbin * m_rtausmef 6824 xxx = verify_log(xxx ,xmin,dx ,xlo 6825 yyy = verify_log(yyy ,ymin,dy ,ylo 6826 if((xxx>=0)&&(xxx<=1) && 6827 (yyy>=0)&&(yyy<=1) ) { 6828 vtxs->add(xxx,yyy,a_zz); 6829 empty = false; 6830 } 6831 } 6832 } 6833 6834 }//end for 6835 6836 if(empty) { 6837 delete separator; 6838 } else { 6839 m_bins_sep.add(separator); 6840 } 6841 } 6842 6843 void rep_bins2D_xy_text( 6844 const style& //a_style 6845 ,const std::vector<rep_bin2D>& //a_bins 6846 ,const rep_box& //a_box_x 6847 ,const rep_box& //a_box_y 6848 //,const SbString& aID 6849 ){ 6850 //Draw box and text for number of entries 6851 ::printf("debug : rep_bins2D_xy_text : du 6852 6853 /* 6854 sg::separator* separator = new sg::separa 6855 6856 //bool drawWireBoxe = false; 6857 6858 bool empty = true; 6859 6860 float xmin = a_box_x.m_pos; 6861 float dx = a_box_x.m_width; 6862 bool xlog = a_box_x.m_log; 6863 6864 float ymin = a_box_y.m_pos; 6865 float dy = a_box_y.m_width; 6866 bool ylog = a_box_y.m_log; 6867 6868 vec3f points[5]; 6869 6870 for(unsigned int index=0;index<a_bins.siz 6871 6872 float xx = a_bins[index].m_x_min; 6873 float xe = a_bins[index].m_x_max; 6874 float yy = a_bins[index].m_y_min; 6875 float ye = a_bins[index].m_y_max; 6876 float val = a_bins[index].m_val; 6877 6878 int ival = (int)val; 6879 if(ival==0) continue; 6880 6881 xx = VerifyLog(xx ,xmin,dx ,xlog); 6882 xe = VerifyLog(xe ,xmin,dx ,xlog); 6883 yy = VerifyLog(yy ,ymin,dy ,ylog); 6884 ye = VerifyLog(ye ,ymin,dy ,ylog); 6885 6886 // Clipping : 6887 if(xx>1) continue; 6888 if(xe<0) continue; 6889 if(xx<0) xx = 0; 6890 if(xe>1) xe = 1; 6891 if(yy>1) continue; 6892 if(ye<0) continue; 6893 if(yy<0) yy = 0; 6894 if(ye>1) ye = 1; 6895 6896 char sval[32]; 6897 //::sprintf (sval,"%d",ival); 6898 SbString sbval(sval); 6899 int charn = sbval.getLength(); 6900 if(charn<=0) continue; 6901 6902 SoSceneGraph* sep = new SoSceneGraph; 6903 separator->addChild(sep); 6904 6905 {char s[128]; 6906 //::sprintf(s,"%d %d",a_bins[index].fI, 6907 sep->setInfos(s);} 6908 {std::string sp; 6909 if(!p2sx(sep->getInfos(),sp)){} 6910 std::string sid(aID.getString()); 6911 sid += "/"+sp; 6912 sep->setString(sid.c_str());} 6913 6914 SoMaterial* material = 6915 fStyleCache->getMaterial(a_style.colo 6916 a_style.tran 6917 sep->addChild(material); 6918 6919 sep->addChild(getLineStyle(a_style)); 6920 6921 float dx = xe-xx; 6922 float dy = ye-yy; 6923 6924 if(drawWireBoxe) { 6925 LIST_SET(points,0,xx,yy,0); 6926 LIST_SET(points,1,xe,yy,0); 6927 LIST_SET(points,2,xe,ye,0); 6928 LIST_SET(points,3,xx,ye,0); 6929 LIST_SET(points,4,xx,yy,0); 6930 coordIndex[0] = icoord + 0; 6931 coordIndex[1] = icoord + 1; 6932 coordIndex[2] = icoord + 2; 6933 coordIndex[3] = icoord + 3; 6934 coordIndex[4] = icoord + 4; 6935 coordIndex[5] = SO_END_LINE_INDEX; 6936 6937 coordinate3->point.setValues(icoord,5 6938 icoord += 5; 6939 6940 SoIndexedLineSet* lineSet = new SoInd 6941 lineSet->coordIndex.setValues(0,6,coo 6942 sep->addChild(lineSet); 6943 } 6944 6945 float x = xx + 0.1F * dx; 6946 float y = yy + 0.1F * dy; 6947 float z = 0; 6948 float w = dx * 0.5F; 6949 float h = dy * 0.5F; 6950 6951 SoTransform* transform = new SoTransfor 6952 transform->scaleFactor.setValue(vec3f(w 6953 transform->translation.setValue(x,y,z); 6954 sep->addChild(transform); 6955 6956 SoTextHershey* text = new SoTextHershey 6957 text->string.setValue(sbval); 6958 sep->addChild (text); 6959 6960 empty = false; 6961 } 6962 6963 if(empty) { 6964 delete separator; 6965 } else { 6966 m_bins_sep.add(separator); 6967 } 6968 */ 6969 } 6970 6971 void rep_contour_xy(std::ostream& a_out,con 6972 const base_colormap& a_ 6973 const rep_box& a_box_x,const rep_bo 6974 /*,const std::string& a 6975 //a_out << "debug : rep_contour_xy :" << 6976 6977 float xmin = a_box_x.m_pos; 6978 float dx = a_box_x.m_width; 6979 bool xlog = a_box_x.m_log; 6980 6981 float ymin = a_box_y.m_pos; 6982 float dy = a_box_y.m_width; 6983 bool ylog = a_box_y.m_log; 6984 6985 float zmin = a_box_z.m_pos; 6986 float dz = a_box_z.m_width; 6987 //bool zlog = a_box_z.m_log; 6988 6989 sg::separator* separator = new sg::separa 6990 //separator->setString(aID); 6991 6992 draw_style* ds = new draw_style; 6993 ds->style.value(draw_lines); 6994 ds->line_pattern.value(a_style.line_patte 6995 ds->line_width.value(a_style.line_width); 6996 separator->add(ds); 6997 6998 atb_vertices* vtxs = new atb_vertices; 6999 vtxs->mode = gl::lines(); //segments 7000 separator->add(vtxs); 7001 7002 bool empty = true; 7003 7004 for (unsigned int i=0;i<a_contour.get_num 7005 cline_strip_list* pStripList = a_contou 7006 if(!pStripList) { 7007 a_out << "tools::sg;:plotter::rep_con 7008 delete separator; 7009 return; 7010 } 7011 7012 //If zlog true, zz is already in log. 7013 float val = (float)a_contour.get_plane( 7014 float zz = val; 7015 7016 zz = verify_log(zz,zmin,dz,false); 7017 if(zz>1) continue; 7018 if(zz<0) continue; 7019 7020 colorf _color; 7021 if(a_painting==painting_by_value) { 7022 a_cmap.get_color(val,_color); 7023 } else if(a_painting==painting_by_level 7024 size_t icol = a_cmap.colorn() ? (i % 7025 _color = a_cmap.color(icol); 7026 } else { 7027 _color = a_style.color; 7028 } 7029 7030 tools_lforcit(cline_strip*,*pStripList, 7031 cline_strip* pStrip = (*pos); 7032 if(!pStrip) { 7033 a_out << "tools::sg;:plotter::rep_c 7034 delete separator; 7035 return; 7036 } 7037 if (pStrip->empty()) continue; 7038 7039 //// putting point at start and end o 7040 //// retreiving index 7041 //unsigned int index=pStrip->front(); 7042 //double xb=a_contour.get_xi(index); 7043 //double yb=a_contour.get_yi(index); 7044 //// retreiving index 7045 ////glColor4f(0,0,1,.8f); 7046 //index=pStrip->back(); 7047 //double xe=a_contour.get_xi(index); 7048 //double ye=a_contour.get_yi(index); 7049 7050 bool first = true; 7051 float xprev = 0; 7052 float yprev = 0; 7053 float xx,yy; 7054 7055 tools_lforcit(unsigned int,*pStrip,po 7056 xx = (float)a_contour.get_xi(*pos2) 7057 yy = (float)a_contour.get_yi(*pos2) 7058 xx = verify_log(xx,xmin,dx,xlog); 7059 yy = verify_log(yy,ymin,dy,ylog); 7060 if( 7061 (xx<0) || (xx>1) || 7062 (yy<0) || (yy>1) 7063 ) { 7064 // Throw away this strip : 7065 } 7066 if(first) { 7067 first = false; 7068 } else { 7069 vtxs->add(xprev,yprev,a_zz+zz); 7070 vtxs->add(xx,yy,a_zz+zz); 7071 vtxs->add_color(_color); 7072 vtxs->add_color(_color); 7073 } 7074 xprev = xx; 7075 yprev = yy; 7076 7077 empty = false; 7078 } 7079 } 7080 7081 } 7082 7083 if(empty) { 7084 delete separator; 7085 } else { 7086 m_bins_sep.add(separator); 7087 } 7088 } 7089 7090 void rep_contour_xy_filled(std::ostream& a_ 7091 const base_color 7092 const rep_box& a_box_x,const rep_b 7093 /*,const std::st 7094 //a_out << "debug : rep_contour_xy_filled 7095 7096 float xmin = a_box_x.m_pos; 7097 float dx = a_box_x.m_width; 7098 bool xlog = a_box_x.m_log; 7099 7100 float ymin = a_box_y.m_pos; 7101 float dy = a_box_y.m_width; 7102 bool ylog = a_box_y.m_log; 7103 7104 float zmin = a_box_z.m_pos; 7105 float dz = a_box_z.m_width; 7106 //bool zlog = a_box_z.m_log; 7107 7108 sg::separator* separator = new sg::separa 7109 //separator->setString(aID); 7110 7111 vec3f AB,BC,vcross; 7112 7113 {// Draw background : 7114 sg::separator* sep = new sg::separator; 7115 separator->add(sep); 7116 7117 float zz = a_zz - 0.01F; 7118 7119 colorf _color; 7120 if(a_cmap.colorn()) { 7121 _color = a_cmap.color(0); 7122 } else { 7123 _color = a_style.color; 7124 } 7125 7126 rgba* mat = new rgba(); 7127 mat->color = _color; 7128 sep->add(mat); 7129 7130 float xx = xmin; 7131 float xe = xmin+dx; 7132 float yy = ymin; 7133 float ye = ymin+dy; 7134 7135 xx = verify_log(xx,xmin,dx,xlog); 7136 xe = verify_log(xe,xmin,dx,xlog); 7137 yy = verify_log(yy,ymin,dy,ylog); 7138 ye = verify_log(ye,ymin,dy,ylog); 7139 7140 vertices* vtxs = new vertices; 7141 vtxs->mode = gl::triangle_fan(); 7142 vtxs->add(xx,yy,zz); 7143 vtxs->add(xe,yy,zz); 7144 vtxs->add(xe,ye,zz); 7145 vtxs->add(xx,ye,zz); 7146 sep->add(vtxs); 7147 7148 } // End background. 7149 7150 bool empty = true; 7151 7152 for (unsigned int i=0;i<a_contour.get_num 7153 7154 cline_strip_list* pStripList = a_contou 7155 if(!pStripList) { 7156 a_out << "tools::sg;:plotter::rep_con 7157 delete separator; 7158 return; 7159 } 7160 7161 sg::separator* sep = new sg::separator; 7162 separator->add(sep); 7163 7164 //If zlog true, zz is already in log. 7165 float val = (float)a_contour.get_plane( 7166 float zz = val; 7167 7168 zz = verify_log(zz,zmin,dz,false); 7169 if(zz>1) continue; 7170 if(zz<0) continue; 7171 7172 std::vector< std::vector<vec3f> > conto 7173 7174 tools_lforcit(cline_strip*,*pStripList, 7175 cline_strip* pStrip = (*pos); 7176 if(pStrip->size() >2) { 7177 std::vector<vec3f> v; 7178 for (cline_strip::iterator pos2=pSt 7179 unsigned int index=(*pos2); 7180 float xx = (float)a_contour.get_x 7181 float yy = (float)a_contour.get_y 7182 xx = verify_log(xx,xmin,dx,xlog); 7183 yy = verify_log(yy,ymin,dy,ylog); 7184 v.push_back(vec3f(xx,yy,a_zz+zz)) 7185 } 7186 contourVector.push_back(std::move(v 7187 } 7188 } 7189 7190 std::vector<tess_triangle> tris; 7191 tess_contour tessContour(a_out,tris); / 7192 tessContour.getFilledArea(contourVector 7193 if(!tris.size()) continue; 7194 7195 colorf _color; 7196 if(a_painting==painting_by_value) { 7197 a_cmap.get_color(val,_color); 7198 } else if(a_painting==painting_by_level 7199 int icol = a_cmap.colorn() ? (i % a_c 7200 _color = a_cmap.color(icol); 7201 } else { 7202 _color = a_style.color; 7203 } 7204 7205 atb_vertices* vtxs = new atb_vertices; 7206 vtxs->mode = gl::triangles(); 7207 sep->add(vtxs); 7208 7209 for(size_t itri=0;itri<tris.size();itri 7210 tess_triangle& tri = tris[itri]; 7211 AB.set_value((float)(tri.pointB[0]-tri.poin 7212 (float)(tri.pointB[1]-tr 7213 (float)(tri.pointB[2]-tr 7214 BC.set_value((float)(tri.pointC[0]-tr 7215 (float)(tri.pointC[1]-tr 7216 (float)(tri.pointC[2]-tr 7217 AB.cross(BC,vcross); 7218 if(vcross.z()>=0) { 7219 vtxs->add((float)tri.pointA[0],(flo 7220 vtxs->add((float)tri.pointB[0],(flo 7221 vtxs->add((float)tri.pointC[0],(flo 7222 } else { 7223 vtxs->add((float)tri.pointA[0],(flo 7224 vtxs->add((float)tri.pointC[0],(flo 7225 vtxs->add((float)tri.pointB[0],(flo 7226 } 7227 vtxs->add_color(_color); 7228 vtxs->add_color(_color); 7229 vtxs->add_color(_color); 7230 } 7231 7232 empty = false; 7233 7234 } 7235 7236 if(empty) { 7237 delete separator; 7238 } else { 7239 m_bins_sep.add(separator); 7240 } 7241 } 7242 7243 void rep_errors_plus_xy(std::ostream& /*a_o 7244 const rep_box& a_bo 7245 //a_out << "debug : rep_erros_plus_xy : b 7246 separator* _sep = new separator(); 7247 //_sep->setString(aID); 7248 7249 rgba* mat = new rgba(); 7250 mat->color = a_style.color; 7251 _sep->add(mat); 7252 7253 draw_style* ds = new draw_style; 7254 ds->style.value(draw_lines); 7255 ds->line_pattern.value(a_style.line_patte 7256 ds->line_width.value(a_style.line_width); 7257 _sep->add(ds); 7258 7259 vertices* vtxs = new vertices; 7260 vtxs->mode = gl::lines(); 7261 _sep->add(vtxs); 7262 7263 float xmin = a_box_x.m_pos; 7264 float dx = a_box_x.m_width; 7265 bool xlog = a_box_x.m_log; 7266 7267 float ymin = a_box_y.m_pos; 7268 float dy = a_box_y.m_width; 7269 bool ylog = a_box_y.m_log; 7270 7271 size_t xnbin = a_bins.size(); 7272 7273 for(size_t index=0;index<xnbin;index++) { 7274 7275 //Need all bins modeled for fitting. 7276 7277 float val = a_bins[index].m_val; 7278 float bar_height = a_bars[index]; 7279 7280 float bar_min = val - bar_height/2; 7281 float bar_max = val + bar_height/2; 7282 7283 float xx = a_bins[index].m_x_min; 7284 float xe = a_bins[index].m_x_max; 7285 7286 xx = verify_log(xx,xmin,dx,xlog); 7287 xe = verify_log(xe,xmin,dx,xlog); 7288 val = verify_log(val,ymin,dy,ylog); 7289 7290 bar_min = verify_log(bar_min,ymin,dy,yl 7291 bar_max = verify_log(bar_max,ymin,dy,yl 7292 7293 if(xe<0) continue; 7294 if(xx>1) continue; 7295 if(xx<0) xx = 0; 7296 if(xe>1) xe = 1; 7297 //if(val<0) val = 0; 7298 //if(val>1) val = 1; 7299 7300 float ex = (xe+xx)/2; 7301 //if( (ex >=0)&&(ex <=1) ) { //FIXME : 7302 7303 float edx = 0.3F * (xe-xx); 7304 7305 if((val>=0)&&(val<=1)) { 7306 vtxs->add(ex-edx,val,aZ); 7307 vtxs->add(ex+edx,val,aZ); 7308 } 7309 7310 if(bar_min >1) { 7311 // do nothing 7312 } else if(bar_max <0) { 7313 // do nothing 7314 } else if(bar_min <0) { 7315 if(bar_max >1) { 7316 vtxs->add(ex,0,aZ); 7317 vtxs->add(ex,1,aZ); 7318 } else { 7319 vtxs->add(ex,0,aZ); 7320 vtxs->add(ex,bar_max,aZ); 7321 } 7322 } else if(bar_max >1) { 7323 vtxs->add(ex,bar_min,aZ); 7324 vtxs->add(ex,1,aZ); 7325 } else { 7326 vtxs->add(ex ,bar_min,aZ); 7327 vtxs->add(ex ,bar_max,aZ); 7328 } 7329 7330 } 7331 7332 if(vtxs->number()) { 7333 m_errors_sep.add(_sep); 7334 } else { 7335 delete _sep; 7336 } 7337 } 7338 7339 void rep_errors_I_xy(std::ostream& /*a_out* 7340 const rep_box& a_box_x 7341 //a_out << "debug : rep_erros_I_xy : begi 7342 separator* _sep = new separator(); 7343 //_sep->setString(aID); 7344 7345 rgba* mat = new rgba(); 7346 mat->color = a_style.color; 7347 _sep->add(mat); 7348 7349 draw_style* ds = new draw_style; 7350 ds->style.value(draw_lines); 7351 ds->line_pattern.value(a_style.line_patte 7352 ds->line_width.value(a_style.line_width); 7353 _sep->add(ds); 7354 7355 vertices* vtxs = new vertices; 7356 vtxs->mode = gl::lines(); 7357 _sep->add(vtxs); 7358 7359 float xmin = a_box_x.m_pos; 7360 float dx = a_box_x.m_width; 7361 bool xlog = a_box_x.m_log; 7362 7363 float ymin = a_box_y.m_pos; 7364 float dy = a_box_y.m_width; 7365 bool ylog = a_box_y.m_log; 7366 7367 size_t xnbin = a_bins.size(); 7368 7369 for(size_t index=0;index<xnbin;index++) { 7370 7371 //Need all bins modeled for fitting. 7372 7373 float val = a_bins[index].m_val; 7374 float bar_height = a_bars[index]; 7375 7376 float bar_min = val - bar_height/2; 7377 float bar_max = val + bar_height/2; 7378 7379 float xx = a_bins[index].m_x_min; 7380 float xe = a_bins[index].m_x_max; 7381 7382 xx = verify_log(xx,xmin,dx,xlog); 7383 xe = verify_log(xe,xmin,dx,xlog); 7384 val = verify_log(val,ymin,dy,ylog); 7385 7386 bar_min = verify_log(bar_min,ymin,dy,yl 7387 bar_max = verify_log(bar_max,ymin,dy,yl 7388 7389 if(xe<0) continue; 7390 if(xx>1) continue; 7391 if(xx<0) xx = 0; 7392 if(xe>1) xe = 1; 7393 if(val<0) val = 0; 7394 if(val>1) val = 1; 7395 7396 float ex = (xe+xx)/2; 7397 //if( (ex >=0)&&(ex <=1) ) { //FIXME : 7398 7399 float edx = 0.3F * (xe-xx); 7400 7401 if(bar_min >1) { 7402 // do nothing 7403 } else if(bar_max <0) { 7404 // do nothing 7405 } else if(bar_min <0) { 7406 if(bar_max >1) { 7407 vtxs->add(ex,0,aZ); 7408 vtxs->add(ex,1,aZ); 7409 } else { 7410 vtxs->add(ex,0,aZ); 7411 vtxs->add(ex,bar_max,aZ); 7412 vtxs->add(ex-edx,bar_max,aZ); 7413 vtxs->add(ex+edx,bar_max,aZ); 7414 } 7415 } else if(bar_max >1) { 7416 vtxs->add(ex-edx,bar_min,aZ); 7417 vtxs->add(ex+edx,bar_min,aZ); 7418 vtxs->add(ex,bar_min,aZ); 7419 vtxs->add(ex,1,aZ); 7420 } else { 7421 vtxs->add(ex-edx,bar_min,aZ); 7422 vtxs->add(ex+edx,bar_min,aZ); 7423 vtxs->add(ex ,bar_min,aZ); 7424 vtxs->add(ex ,bar_max,aZ); 7425 vtxs->add(ex-edx,bar_max,aZ); 7426 vtxs->add(ex+edx,bar_max,aZ); 7427 } 7428 7429 } 7430 7431 if(vtxs->number()) { 7432 m_errors_sep.add(_sep); 7433 } else { 7434 delete _sep; 7435 } 7436 } 7437 7438 void rep_hatch1D_xy(const style& a_style, 7439 const std::vector<rep_b 7440 const rep_box& a_box_x,const rep_bo 7441 bool a_bar_chart){ 7442 //printf("debug : tools::sg;:plotter::rep 7443 7444 separator* _sep = new separator; 7445 7446 rgba* mat = new rgba(); 7447 mat->color = a_style.color; 7448 _sep->add(mat); 7449 7450 draw_style* ds = new draw_style; 7451 if(a_style.strip_width.value()==0) { 7452 ds->style = draw_lines; 7453 ds->line_pattern = line_solid; 7454 ds->line_width = a_style.line_width; 7455 } else { 7456 ds->style = draw_filled; 7457 //ds->cull_face = true; 7458 } 7459 _sep->add(ds); 7460 7461 float xmin = a_box_x.m_pos; 7462 float dx = a_box_x.m_width; 7463 bool xlog = a_box_x.m_log; 7464 7465 float ymin = a_box_y.m_pos; 7466 float dy = a_box_y.m_width; 7467 bool ylog = a_box_y.m_log; 7468 7469 bool empty = true; 7470 7471 vec3f points[5]; 7472 size_t xnbin = a_bins.size(); 7473 for(size_t index=0;index<xnbin;index++) { 7474 float xx = a_bins[index].m_x_min; 7475 float xe = a_bins[index].m_x_max; 7476 float yy = a_bins[index].m_v_min; 7477 float ye = a_bins[index].m_val; 7478 if(ye<yy) { 7479 yy = a_bins[index].m_val; 7480 ye = a_bins[index].m_v_min; 7481 } 7482 7483 if(a_bar_chart) bar_chart(a_style.bar_o 7484 7485 xx = verify_log(xx,xmin,dx,xlog); 7486 xe = verify_log(xe,xmin,dx,xlog); 7487 yy = verify_log(yy,ymin,dy,ylog); 7488 ye = verify_log(ye,ymin,dy,ylog); 7489 7490 // Clipping : 7491 if(xx>1) continue; 7492 if(xe<0) continue; 7493 if(xx<0) xx = 0; 7494 if(xe>1) xe = 1; 7495 if(yy>1) continue; 7496 if(ye<0) continue; 7497 if(yy<0) yy = 0; 7498 if(ye>1) ye = 1; 7499 7500 points[0].set_value(xx,yy,a_zz); 7501 points[1].set_value(xe,yy,a_zz); 7502 points[2].set_value(xe,ye,a_zz); 7503 points[3].set_value(xx,ye,a_zz); 7504 points[4].set_value(xx,yy,a_zz); 7505 7506 //FIXME : have picking a hatch picks al 7507 7508 hatcher _hatcher; 7509 _hatcher.set_offset_point(vec3f(0,0,a_z 7510 _hatcher.set_angle(a_style.angle.value( 7511 _hatcher.set_spacing(a_style.spacing.va 7512 if(!_hatcher.set_strip_width(a_style.st 7513 7514 bool res = _hatcher.check_polyline(poin 7515 if(res) res = _hatcher.compute_polyline 7516 7517 size_t numPoints = _hatcher.points().si 7518 size_t numVertices = _hatcher.vertices( 7519 if((res) && numPoints && numVertices) { 7520 7521 const std::vector<vec3f>& _points = 7522 7523 if(a_style.strip_width.value()==0) 7524 7525 size_t ipt = 0; 7526 tools_vforcit(unsigned int,_hatcher.ver 7527 vertices* vtxs = new vertices; 7528 vtxs->mode = gl::line_strip(); 7529 for(size_t _index=0;_index<(*it 7530 vtxs->add(_points[ipt]); 7531 ipt++; 7532 } 7533 _sep->add(vtxs); 7534 empty = false; 7535 } 7536 7537 } else { 7538 size_t ipt = 0; 7539 tools_vforcit(unsigned int,_hatcher.ver 7540 vertices* vtxs = new vertices; 7541 vtxs->mode = gl::triangle_fan() 7542 for(size_t _index=0;_index<(*it 7543 vtxs->add(_points[ipt]); 7544 ipt++; 7545 } 7546 _sep->add(vtxs); 7547 empty = false; 7548 } 7549 } 7550 7551 } 7552 } 7553 if(empty) { 7554 delete _sep; 7555 } else { 7556 m_bins_sep.add(_sep); 7557 } 7558 } 7559 7560 void rep_points2D_xy_lines(const style& a_s 7561 const rep_box& a 7562 //::printf("debug : rep_points2D_xy_lines 7563 float xmin = a_box_x.m_pos; 7564 float dx = a_box_x.m_width; 7565 bool xlog = a_box_x.m_log; 7566 7567 float ymin = a_box_y.m_pos; 7568 float dy = a_box_y.m_width; 7569 bool ylog = a_box_y.m_log; 7570 7571 separator* _sep = new separator(); 7572 7573 rgba* mat = new rgba(); 7574 mat->color = a_style.color; 7575 _sep->add(mat); 7576 7577 draw_style* ds = new draw_style; 7578 ds->style.value(draw_lines); 7579 ds->line_pattern.value(a_style.line_patte 7580 ds->line_width.value(a_style.line_width); 7581 _sep->add(ds); 7582 7583 vertices* vtxs = new vertices; 7584 vtxs->mode = gl::line_strip(); 7585 _sep->add(vtxs); 7586 7587 bool empty = true; 7588 7589 float x,y; 7590 unsigned int number = a_points.points(); 7591 for(unsigned int index=0;index<number;ind 7592 a_points.ith_point(index,x,y); 7593 x = verify_log(x,xmin,dx,xlog); 7594 y = verify_log(y,ymin,dy,ylog); 7595 if((x<0)||(x>1)||(y<0)||(y>1)) continue 7596 vtxs->add(x,y,a_zz); 7597 empty = false; 7598 } 7599 7600 if(empty) { 7601 delete _sep; 7602 } else { 7603 m_points_sep.add(_sep); 7604 } 7605 } 7606 7607 void rep_points2D_xy_curve(std::ostream& a_ 7608 const rep_box& a 7609 //::printf("debug : rep_points2D_xy_curve 7610 unsigned int number = a_points.points(); 7611 if(!number) return; 7612 7613 double* xs = new double[number]; 7614 double* ys = new double[number]; 7615 float x,y; 7616 {for(unsigned int index=0;index<number;ind 7617 a_points.ith_point(index,x,y); 7618 xs[index] = x;ys[index] = y; 7619 }} 7620 spline::cubic _spline(a_out,number,xs,ys) 7621 //spline::quintic _spline(a_out,number,xs,y 7622 delete [] xs;delete [] ys; 7623 7624 float xmn = m_x_axis_data.min_value(); 7625 float xmx = m_x_axis_data.max_value(); 7626 unsigned int nstp = curve_number_of_point 7627 float step = (xmx - xmn)/nstp; 7628 std::vector<vec3f> points(nstp+1); 7629 for(unsigned int ibin=0;ibin<=nstp;ibin++ 7630 float xx = xmn + ibin * step; 7631 double val = _spline.eval(xx); 7632 points[ibin].set_value(xx,float(val),a_ 7633 } 7634 7635 vertices* vtxs = new vertices; 7636 std::vector<float>& pts = vtxs->xyzs.valu 7637 7638 clip_polyline_2D(points,a_box_x,a_box_y,p 7639 if(pts.size()) { 7640 sg::separator* separator = new sg::sepa 7641 //separator->setString(aID); 7642 7643 rgba* mat = new rgba(); 7644 mat->color = a_style.color; 7645 separator->add(mat); 7646 7647 draw_style* ds = new draw_style; 7648 ds->style = draw_lines; 7649 ds->line_pattern = a_style.line_pattern 7650 ds->line_width = a_style.line_width; 7651 separator->add(ds); 7652 7653 vtxs->mode = gl::line_strip(); 7654 separator->add(vtxs); 7655 7656 m_points_sep.add(separator); 7657 } else { 7658 delete vtxs; 7659 } 7660 7661 } 7662 7663 void rep_points2D_xy_points(std::ostream& a 7664 const style& a_ 7665 const rep_box& 7666 float xmin = a_box_x.m_pos; 7667 float dx = a_box_x.m_width; 7668 bool xlog = a_box_x.m_log; 7669 7670 float ymin = a_box_y.m_pos; 7671 float dy = a_box_y.m_width; 7672 bool ylog = a_box_y.m_log; 7673 7674 separator* _sep = new separator(); 7675 7676 rgba* mat = new rgba(); 7677 mat->color = a_style.color; 7678 _sep->add(mat); 7679 7680 mf<float>* _xyzs = 0; 7681 7682 if(a_style.modeling==modeling_markers()) 7683 markers* _marks = new markers; 7684 _marks->size = a_style.marker_size; 7685 _marks->style = a_style.marker_style; 7686 _xyzs = &(_marks->xyzs); 7687 _sep->add(_marks); 7688 7689 } else if(a_style.modeling==modeling_poin 7690 draw_style* ds = new draw_style; 7691 ds->style = draw_points; 7692 ds->point_size = a_style.point_size; 7693 _sep->add(ds); 7694 7695 vertices* vtxs = new vertices; 7696 vtxs->mode = gl::points(); 7697 _xyzs = &(vtxs->xyzs); 7698 _sep->add(vtxs); 7699 } else { 7700 a_out << "tools::sg::plotter::rep_point 7701 << " bad modeling style " << tool 7702 delete _sep; 7703 return; 7704 } 7705 7706 float x,y; 7707 7708 // first round trip to get number of floa 7709 size_t npts = 0; 7710 {unsigned int number = a_points.points(); 7711 for(unsigned int index=0;index<number;ind 7712 a_points.ith_point(index,x,y); 7713 //float val = a_bins[index].m_val; 7714 x = verify_log(x,xmin,dx,xlog); 7715 y = verify_log(y,ymin,dy,ylog); 7716 if((x<0)||(x>1)||(y<0)||(y>1)) continue 7717 npts += 3; 7718 }} 7719 7720 _xyzs->values().resize(npts); 7721 size_t xyz_pos = 0; 7722 7723 bool empty = true; 7724 7725 {unsigned int number = a_points.points(); 7726 for(unsigned int index=0;index<number;ind 7727 a_points.ith_point(index,x,y); 7728 //float val = a_bins[index].m_val; 7729 x = verify_log(x,xmin,dx,xlog); 7730 y = verify_log(y,ymin,dy,ylog); 7731 if((x<0)||(x>1)||(y<0)||(y>1)) continue 7732 _xyzs->add_allocated(xyz_pos,x,y,a_zz); 7733 empty = false; 7734 }} 7735 7736 if(empty) { 7737 delete _sep; 7738 } else { 7739 m_points_sep.add(_sep); 7740 } 7741 } 7742 7743 void rep_points3D_xyz_points(std::ostream& 7744 const style& a 7745 const rep_box& 7746 float xmin = a_box_x.m_pos; 7747 float dx = a_box_x.m_width; 7748 bool xlog = a_box_x.m_log; 7749 7750 float ymin = a_box_y.m_pos; 7751 float dy = a_box_y.m_width; 7752 bool ylog = a_box_y.m_log; 7753 7754 float zmin = a_box_z.m_pos; 7755 float dz = a_box_z.m_width; 7756 bool zlog = a_box_z.m_log; 7757 7758 separator* _sep = new separator(); 7759 7760 rgba* mat = new rgba(); 7761 mat->color = a_style.color; 7762 _sep->add(mat); 7763 7764 mf<float>* _xyzs = 0; 7765 7766 if(a_style.modeling==modeling_markers()) 7767 markers* _marks = new markers; 7768 _marks->size = a_style.marker_size; 7769 _marks->style = a_style.marker_style; 7770 _xyzs = &(_marks->xyzs); 7771 _sep->add(_marks); 7772 7773 } else if(a_style.modeling==modeling_poin 7774 draw_style* ds = new draw_style; 7775 ds->style = draw_points; 7776 ds->point_size = a_style.point_size; 7777 _sep->add(ds); 7778 7779 vertices* vtxs = new vertices; 7780 vtxs->mode = gl::points(); 7781 _xyzs = &(vtxs->xyzs); 7782 _sep->add(vtxs); 7783 } else { 7784 a_out << "tools::sg::plotter::rep_point 7785 << " bad modeling style " << tool 7786 delete _sep; 7787 return; 7788 } 7789 7790 float x,y,z; 7791 7792 // first round trip to get number of floa 7793 size_t npts = 0; 7794 {unsigned int number = a_points.points(); 7795 for(unsigned int index=0;index<number;ind 7796 a_points.ith_point(index,x,y,z); 7797 //float val = a_bins[index].m_val; 7798 x = verify_log(x,xmin,dx,xlog); 7799 y = verify_log(y,ymin,dy,ylog); 7800 z = verify_log(z,zmin,dz,zlog); 7801 if((x<0)||(x>1)||(y<0)||(y>1)||(z<0)||( 7802 npts += 3; 7803 }} 7804 7805 _xyzs->values().resize(npts); 7806 size_t xyz_pos = 0; 7807 7808 bool empty = true; 7809 7810 {unsigned int number = a_points.points(); 7811 for(unsigned int index=0;index<number;ind 7812 a_points.ith_point(index,x,y,z); 7813 //float val = a_bins[index].m_val; 7814 x = verify_log(x,xmin,dx,xlog); 7815 y = verify_log(y,ymin,dy,ylog); 7816 z = verify_log(z,zmin,dz,zlog); 7817 if((x<0)||(x>1)||(y<0)||(y>1)||(z<0)||( 7818 _xyzs->add_allocated(xyz_pos,x,y,z); 7819 empty = false; 7820 }} 7821 7822 if(empty) { 7823 delete _sep; 7824 } else { 7825 m_points_sep.add(_sep); 7826 } 7827 } 7828 7829 void rep_bins2D_xyz_box(const style& a_styl 7830 const rep_box& a_bo 7831 float xmin = a_box_x.m_pos; 7832 float dx = a_box_x.m_width; 7833 bool xlog = a_box_x.m_log; 7834 7835 float ymin = a_box_y.m_pos; 7836 float dy = a_box_y.m_width; 7837 bool ylog = a_box_y.m_log; 7838 7839 float zmin = a_box_z.m_pos; 7840 float dz = a_box_z.m_width; 7841 bool zlog = a_box_z.m_log; 7842 7843 painting_policy painting = a_style.painti 7844 7845 separator* _sep = new separator(); 7846 7847 bool empty = true; 7848 //float range = a_bmax - a_bmin; 7849 colorf clr; 7850 7851 tools_vforcit(rep_bin2D,a_bins,it) { 7852 const rep_bin2D& rbin = *it; 7853 7854 float xx = rbin.m_x_min; 7855 float xe = rbin.m_x_max; 7856 float yy = rbin.m_y_min; 7857 float ye = rbin.m_y_max; 7858 float val = rbin.m_val; 7859 float zz = a_bmin; 7860 float ze = val; 7861 7862 xx = verify_log(xx ,xmin,dx ,xlog); 7863 xe = verify_log(xe ,xmin,dx ,xlog); 7864 yy = verify_log(yy ,ymin,dy ,ylog); 7865 ye = verify_log(ye ,ymin,dy ,ylog); 7866 zz = verify_log(zz ,zmin,dz ,zlog); 7867 ze = verify_log(ze ,zmin,dz ,zlog); 7868 7869 // Clipping : 7870 if(xx>1) continue; 7871 if(xe<0) continue; 7872 if(xx<0) xx = 0; 7873 if(xe>1) xe = 1; 7874 7875 if(yy>1) continue; 7876 if(ye<0) continue; 7877 if(yy<0) yy = 0; 7878 if(ye>1) ye = 1; 7879 7880 if(zz>1) continue; 7881 if(ze<0) continue; 7882 if(zz<0) zz = 0; 7883 if(ze>1) ze = 1; 7884 7885 if(yy>=ye) continue; 7886 if(xx>=xe) continue; 7887 if(zz>=ze) continue; 7888 7889 separator* sep = new separator(); 7890 _sep->add(sep); 7891 7892 if(painting==painting_by_value) { 7893 a_cmap.get_color(val,clr); 7894 } else if( (painting==painting_grey_sca 7895 (painting==painting_grey_sca 7896 (painting==painting_violet_t 7897 a_cmap.get_color(rbin.m_ratio,clr); 7898 } else { 7899 clr = a_style.color; 7900 } 7901 7902 rgba* mat = new rgba(); 7903 mat->color = clr; 7904 sep->add(mat); 7905 7906 /*{char s[128]; 7907 //::sprintf(s,"%d %d",rbin.fI,rbin.fJ); 7908 sep->setInfos(s); 7909 //::sprintf(s,"/0x%lx",(unsigned long)s 7910 std::string sid = aID; 7911 sid += std::string(s); 7912 sep->setString(sid);}*/ 7913 7914 float sx = xe-xx; 7915 float sy = ye-yy; 7916 float sz = ze-zz; 7917 7918 matrix* _tsf = new matrix; 7919 _tsf->set_translate(xx+sx/2,yy+sy/2,sz/ 7920 sep->add(_tsf); 7921 7922 cube* _cube = new cube; 7923 _cube->width = sx; 7924 _cube->height = sy; 7925 _cube->depth = sz; 7926 sep->add(_cube); 7927 7928 empty = false; 7929 } 7930 7931 if(empty) { 7932 delete _sep; 7933 } else { 7934 m_bins_sep.add(_sep); 7935 } 7936 } 7937 7938 void rep_top_face2D_xyz(separator& a_sep,co 7939 const std::vector<r 7940 const rep_box& a_box_x,const rep_box& 7941 float xmin = a_box_x.m_pos; 7942 float dx = a_box_x.m_width; 7943 bool xlog = a_box_x.m_log; 7944 7945 float ymin = a_box_y.m_pos; 7946 float dy = a_box_y.m_width; 7947 bool ylog = a_box_y.m_log; 7948 7949 float zmin = a_box_z.m_pos; 7950 float dz = a_box_z.m_width; 7951 bool zlog = a_box_z.m_log; 7952 7953 bool empty = true; 7954 7955 painting_policy painting = a_style.painti 7956 7957 separator* _sep = new separator(); 7958 7959 //draw_style* ds = new draw_style; 7960 //ds->style = draw_filled; 7961 //ds->cull_face = true; 7962 //_sep->add(ds); 7963 7964 atb_vertices* vtxs = new atb_vertices; 7965 vtxs->mode = gl::triangles(); 7966 vtxs->do_back = true; 7967 vtxs->epsilon = 1e-6f; 7968 _sep->add(vtxs); 7969 7970 colorf clr; 7971 vec3f nm; 7972 7973 size_t number = a_faces.size(); 7974 for(size_t index=0;index<number;index++) 7975 float xx = a_faces[index].m_x_min; 7976 float xe = a_faces[index].m_x_max; 7977 float yy = a_faces[index].m_y_min; 7978 float ye = a_faces[index].m_y_max; 7979 float val1 = a_faces[index].m_v1; 7980 float val2 = a_faces[index].m_v2; 7981 float val3 = a_faces[index].m_v3; 7982 float val4 = a_faces[index].m_v4; 7983 7984 float val = val1; 7985 7986 val1 = verify_log(val1,zmin,dz,zlog); 7987 val2 = verify_log(val2,zmin,dz,zlog); 7988 val3 = verify_log(val3,zmin,dz,zlog); 7989 val4 = verify_log(val4,zmin,dz,zlog); 7990 xx = verify_log(xx,xmin,dx,xlog); 7991 xe = verify_log(xe,xmin,dx,xlog); 7992 yy = verify_log(yy,ymin,dy,ylog); 7993 ye = verify_log(ye,ymin,dy,ylog); 7994 7995 if(val1<0) val1 = 0; 7996 if(val1>1) val1 = 1; 7997 7998 if(val2<0) val2 = 0; 7999 if(val2>1) val2 = 1; 8000 8001 if(val3<0) val3 = 0; 8002 if(val3>1) val3 = 1; 8003 8004 if(val4<0) val4 = 0; 8005 if(val4>1) val4 = 1; 8006 8007 if((xx>=0)&&(xx<=1) && 8008 (xe>=0)&&(xe<=1) && 8009 (yy>=0)&&(yy<=1) && 8010 (ye>=0)&&(ye<=1) ) { 8011 8012 if(painting==painting_by_value) { 8013 float v = (zlog?take_log(val):val); 8014 a_cmap.get_color(v,clr); 8015 } else if( (painting==painting_grey_s 8016 (painting==painting_grey_s 8017 (painting==painting_violet 8018 a_cmap.get_color(a_faces[index].m_r 8019 } else { 8020 clr = a_style.color; 8021 } 8022 8023 //if(a_style.area_style.getValue()==S 8024 //} 8025 8026 ///////////////////////////////////// 8027 ///////////////////////////////////// 8028 vtxs->add(xx,ye,val4); 8029 vtxs->add(xx,yy,val1); 8030 vtxs->add(xe,yy,val2); 8031 8032 vtxs->add_color(clr); 8033 vtxs->add_color(clr); 8034 vtxs->add_color(clr); 8035 8036 direction(xx,ye,val4, 8037 xx,yy,val1, 8038 xe,yy,val2,nm); 8039 nm.normalize(); 8040 vtxs->add_normal(nm[0],nm[1],nm[2]); 8041 vtxs->add_normal(nm[0],nm[1],nm[2]); 8042 vtxs->add_normal(nm[0],nm[1],nm[2]); 8043 8044 ///////////////////////////////////// 8045 ///////////////////////////////////// 8046 vtxs->add(xe,yy,val2); 8047 vtxs->add(xe,ye,val3); 8048 vtxs->add(xx,ye,val4); 8049 8050 vtxs->add_rgba(clr[0],clr[1],clr[2],c 8051 vtxs->add_rgba(clr[0],clr[1],clr[2],c 8052 vtxs->add_rgba(clr[0],clr[1],clr[2],c 8053 8054 direction(xe,yy,val2, 8055 xe,ye,val3, 8056 xx,ye,val4,nm); 8057 nm.normalize(); 8058 vtxs->add_normal(nm[0],nm[1],nm[2]); 8059 vtxs->add_normal(nm[0],nm[1],nm[2]); 8060 vtxs->add_normal(nm[0],nm[1],nm[2]); 8061 8062 empty = false; 8063 } 8064 } 8065 if(empty) { 8066 delete _sep; 8067 } else { 8068 a_sep.add(_sep); 8069 } 8070 } 8071 8072 void rep_top_face2D_xyz_line(const style& / 8073 const rep_box& 8074 //::printf("debug : rep_top_face2D_xyz_li 8075 8076 float xmin = a_box_x.m_pos; 8077 float dx = a_box_x.m_width; 8078 bool xlog = a_box_x.m_log; 8079 8080 float ymin = a_box_y.m_pos; 8081 float dy = a_box_y.m_width; 8082 bool ylog = a_box_y.m_log; 8083 8084 float zmin = a_box_z.m_pos; 8085 float dz = a_box_z.m_width; 8086 bool zlog = a_box_z.m_log; 8087 8088 sg::separator* separator = new sg::separa 8089 bool empty = true; 8090 8091 rgba* mat = new rgba(); 8092 mat->color = colorf_black(); 8093 separator->add(mat); 8094 8095 draw_style* ds = new draw_style; 8096 ds->style = draw_lines; 8097 ds->line_pattern = line_solid; 8098 ds->line_width = 1; 8099 separator->add(ds); 8100 8101 vertices* vtxs = new vertices; 8102 vtxs->mode = gl::lines(); 8103 separator->add(vtxs); 8104 8105 float zepsilon = 0.02f; //for pawex9.kuma 8106 8107 size_t number = a_top_faces.size(); 8108 for(size_t index=0;index<number;index++) 8109 float xx = a_top_faces[index].m_x_min; 8110 float xe = a_top_faces[index].m_x_max; 8111 float yy = a_top_faces[index].m_y_min; 8112 float ye = a_top_faces[index].m_y_max; 8113 float val1 = a_top_faces[index].m_v1; 8114 float val2 = a_top_faces[index].m_v2; 8115 float val3 = a_top_faces[index].m_v3; 8116 float val4 = a_top_faces[index].m_v4; 8117 8118 //float val = val1; 8119 8120 val1 = verify_log(val1,zmin,dz,zlog); 8121 val2 = verify_log(val2,zmin,dz,zlog); 8122 val3 = verify_log(val3,zmin,dz,zlog); 8123 val4 = verify_log(val4,zmin,dz,zlog); 8124 xx = verify_log(xx,xmin,dx,xlog); 8125 xe = verify_log(xe,xmin,dx,xlog); 8126 yy = verify_log(yy,ymin,dy,ylog); 8127 ye = verify_log(ye,ymin,dy,ylog); 8128 8129 if(val1<0) val1 = 0; 8130 if(val1>1) val1 = 1; 8131 8132 if(val2<0) val2 = 0; 8133 if(val2>1) val2 = 1; 8134 8135 if(val3<0) val3 = 0; 8136 if(val3>1) val3 = 1; 8137 8138 if(val4<0) val4 = 0; 8139 if(val4>1) val4 = 1; 8140 8141 if((xx>=0)&&(xx<=1) && 8142 (xe>=0)&&(xe<=1) && 8143 (yy>=0)&&(yy<=1) && 8144 (ye>=0)&&(ye<=1) ) { 8145 8146 vtxs->add(xx,ye,val4+zepsilon); 8147 vtxs->add(xx,yy,val1+zepsilon); 8148 8149 vtxs->add(xx,yy,val1+zepsilon); 8150 vtxs->add(xe,yy,val2+zepsilon); 8151 8152 vtxs->add(xe,yy,val2+zepsilon); 8153 vtxs->add(xe,ye,val3+zepsilon); 8154 8155 vtxs->add(xe,ye,val3+zepsilon); 8156 vtxs->add(xx,ye,val4+zepsilon); 8157 8158 empty = false; 8159 8160 } 8161 } 8162 if(empty) { 8163 delete separator; 8164 } else { 8165 m_bins_sep.add(separator); 8166 } 8167 } 8168 8169 void rep_top_face2D_xyz_by_level(const styl 8170 const std: 8171 const rep_ 8172 float a_bm 8173 //::printf("debug : rep_top_face2D_xyz_by 8174 8175 size_t ncol = a_cmap.colorn(); 8176 if(!ncol) return; 8177 8178 float xmin = a_box_x.m_pos; 8179 float dx = a_box_x.m_width; 8180 bool xlog = a_box_x.m_log; 8181 8182 float ymin = a_box_y.m_pos; 8183 float dy = a_box_y.m_width; 8184 bool ylog = a_box_y.m_log; 8185 8186 float zmin = a_box_z.m_pos; 8187 float dz = a_box_z.m_width; 8188 bool zlog = a_box_z.m_log; 8189 8190 float zz = a_bmin; 8191 zz = verify_log(zz,zmin,dz,zlog); 8192 float zmx = a_bmax; 8193 zmx = verify_log(zmx,zmin,dz,zlog); 8194 8195 bool empty = true; 8196 8197 sg::separator* separator = new sg::separa 8198 //separator->setString(aID); 8199 8200 atb_vertices* tris = new atb_vertices; 8201 tris->mode = gl::triangles(); 8202 tris->do_back = true; 8203 tris->epsilon = 1e-6f; 8204 separator->add(tris); 8205 8206 colorf _color; 8207 vec3f _point; 8208 8209 float d_z = (zmx-zz)/ncol; 8210 8211 size_t number = a_top_faces.size(); 8212 8213 for(size_t icol=0;icol<ncol;icol++) { 8214 8215 //sg::separator* sep = new sg::separato 8216 //bool sep_empty = true; 8217 8218 _color = a_cmap.color(icol); 8219 8220 for(size_t index=0;index<number;index++ 8221 float xx = a_top_faces[index].m_x_min 8222 float xe = a_top_faces[index].m_x_max 8223 float yy = a_top_faces[index].m_y_min 8224 float ye = a_top_faces[index].m_y_max 8225 float val1 = a_top_faces[index].m_v1; 8226 float val2 = a_top_faces[index].m_v2; 8227 float val3 = a_top_faces[index].m_v3; 8228 float val4 = a_top_faces[index].m_v4; 8229 8230 //float val = val1; 8231 8232 val1 = verify_log(val1,zmin,dz,zlog); 8233 val2 = verify_log(val2,zmin,dz,zlog); 8234 val3 = verify_log(val3,zmin,dz,zlog); 8235 val4 = verify_log(val4,zmin,dz,zlog); 8236 xx = verify_log(xx,xmin,dx,xlog); 8237 xe = verify_log(xe,xmin,dx,xlog); 8238 yy = verify_log(yy,ymin,dy,ylog); 8239 ye = verify_log(ye,ymin,dy,ylog); 8240 8241 if(val1<0) val1 = 0; 8242 if(val1>1) val1 = 1; 8243 8244 if(val2<0) val2 = 0; 8245 if(val2>1) val2 = 1; 8246 8247 if(val3<0) val3 = 0; 8248 if(val3>1) val3 = 1; 8249 8250 if(val4<0) val4 = 0; 8251 if(val4>1) val4 = 1; 8252 8253 if((xx>=0)&&(xx<=1) && 8254 (xe>=0)&&(xe<=1) && 8255 (yy>=0)&&(yy<=1) && 8256 (ye>=0)&&(ye<=1) ) { 8257 8258 /////////////////////////////////// 8259 /////////////////////////////////// 8260 {clip<vec3f> clipper; 8261 clipper.add(vec3f(xx,ye,val4)); 8262 clipper.add(vec3f(xx,yy,val1)); 8263 clipper.add(vec3f(xe,yy,val2)); 8264 //val[n] had been z normalized. 8265 float z1 = zz+d_z*icol; 8266 float z2 = z1+d_z; 8267 plane<vec3f> plane_z_bot(vec3f(0,0, 8268 plane<vec3f> plane_z_top(vec3f(0,0, 8269 clipper.execute(plane_z_bot); 8270 clipper.execute(plane_z_top); 8271 8272 const std::vector<vec3f>& result = 8273 if(result.size()) { 8274 plane<vec3f> plane1(vec3f(xx,ye,v 8275 if(result.size()==3) { 8276 tools_vforcit(vec3f,result,it) 8277 tris->add(*it); 8278 tris->add_color(_color); 8279 tris->add_normal(plane1.norma 8280 } 8281 } else { 8282 atb_vertices* vtxs = new atb_ve 8283 vtxs->mode = gl::triangle_fan() 8284 vtxs->do_back = true; 8285 vtxs->epsilon = 1e-6f; 8286 separator->add(vtxs); 8287 tools_vforcit(vec3f,result,it) 8288 vtxs->add(*it); 8289 vtxs->add_color(_color); 8290 vtxs->add_normal(plane1.norma 8291 } 8292 } 8293 empty = false; 8294 //sep_empty = false; 8295 }} 8296 8297 /////////////////////////////////// 8298 /////////////////////////////////// 8299 {clip<vec3f> clipper; 8300 clipper.add(vec3f(xe,yy,val2)); 8301 clipper.add(vec3f(xe,ye,val3)); 8302 clipper.add(vec3f(xx,ye,val4)); 8303 //val[n] had been z normalized. 8304 float z1 = zz+d_z*icol; 8305 float z2 = z1+d_z; 8306 plane<vec3f> plane_z_bot(vec3f(0,0, 8307 plane<vec3f> plane_z_top(vec3f(0,0, 8308 clipper.execute(plane_z_bot); 8309 clipper.execute(plane_z_top); 8310 8311 const std::vector<vec3f>& result = 8312 if(result.size()) { 8313 plane<vec3f> plane2(vec3f(xe,yy,v 8314 if(result.size()==3) { 8315 tools_vforcit(vec3f,result,it) 8316 tris->add(*it); 8317 tris->add_color(_color); 8318 tris->add_normal(plane2.norma 8319 } 8320 } else { 8321 atb_vertices* vtxs = new atb_ve 8322 vtxs->mode = gl::triangle_fan() 8323 vtxs->do_back = true; 8324 vtxs->epsilon = 1e-6f; 8325 separator->add(vtxs); 8326 tools_vforcit(vec3f,result,it) 8327 vtxs->add(*it); 8328 vtxs->add_color(_color); 8329 vtxs->add_normal(plane2.norma 8330 } 8331 } 8332 empty = false; 8333 //sep_empty = false; 8334 }} 8335 } 8336 8337 } //index faces 8338 8339 //if(sep_empty) { 8340 // delete sep; 8341 //} else { 8342 // separator->add(sep); 8343 //} 8344 8345 } //icol 8346 8347 if(empty) { 8348 delete separator; 8349 } else { 8350 m_bins_sep.add(separator); 8351 } 8352 } 8353 8354 // for OpenPAW /GRAPHICS/PRIMITIVES/TEXT 8355 // for OpenPAW /GRAPHICS/PRIMITIVES/ITX 8356 void update_primitive_text(const plottable_ 8357 if(a_obj.m_TEXT.empty()) return; 8358 8359 float z = xy_depth.value()*1.1F; 8360 8361 vec3f pos; 8362 axis_2_data_frame(vec3f(a_obj.m_X,a_obj.m 8363 xx_2_yy(pos,pos); 8364 8365 separator* sep = new separator; 8366 8367 rgba* mat = new rgba(); 8368 mat->color = a_obj.m_TXCI; 8369 sep->add(mat); 8370 8371 matrix* _tsf = new matrix; 8372 _tsf->set_translate(pos); 8373 _tsf->mul_rotate(0,0,1,a_obj.m_ANGLE*fpi( 8374 _tsf->mul_scale(a_obj.m_SCALE,a_obj.m_SCA 8375 sep->add(_tsf); 8376 8377 //SIZE is in page coordinate YSIZ. 8378 //float YSIZ = height.value(); 8379 //if(YSIZ<=0) YSIZ = 1; 8380 8381 //::printf("debug : tools::sg::plotter::u 8382 // a_obj.m_TEXT.c_str(),a_obj.m_X,a_ob 8383 // pos[0],pos[1],pos[2]); 8384 8385 if(a_obj.m_text_mode==plottable_text::tex 8386 8387 vec3f pos2; 8388 axis_2_data_frame(vec3f(a_obj.m_X+a_obj 8389 xx_2_yy(pos2,pos2); 8390 8391 float _width = pos2.x()-pos.x(); 8392 8393 text* _text = new text(m_ttf); 8394 _text->enforce_front_width = true; //i 8395 _text->front_width = _width; 8396 _text->back_visible = false; 8397 8398 _text->encoding = encoding_PAW(); 8399 _text->strings.add(a_obj.m_TEXT); 8400 _text->line_width = a_obj.m_line_width; 8401 _text->font = a_obj.m_FONT; 8402 _text->font_modeling = a_obj.m_font_mod 8403 8404 if(a_obj.m_HJUST=='R') { 8405 _text->hjust = right; 8406 } else if(a_obj.m_HJUST=='C') { 8407 _text->hjust = center; 8408 } else { 8409 _text->hjust = left; 8410 } 8411 if(a_obj.m_VJUST=='T') { 8412 _text->vjust = top; 8413 } else if(a_obj.m_VJUST=='M') { 8414 _text->vjust = middle; 8415 } else { 8416 _text->vjust = bottom; 8417 } 8418 8419 sep->add(_text); 8420 8421 } else if(a_obj.m_text_mode==plottable_te 8422 8423 vec3f pos2; 8424 axis_2_data_frame(vec3f(a_obj.m_X,a_obj 8425 xx_2_yy(pos2,pos2); 8426 8427 float _height = pos2.y()-pos.y(); 8428 8429 text* _text = new text(m_ttf); 8430 _text->enforce_front_height = true; // 8431 _text->front_height = _height; 8432 _text->back_visible = false; //if true 8433 8434 _text->encoding = encoding_PAW(); 8435 _text->strings.add(a_obj.m_TEXT); 8436 _text->line_width = a_obj.m_line_width; 8437 _text->font = a_obj.m_FONT; 8438 _text->font_modeling = a_obj.m_font_mod 8439 8440 if(a_obj.m_HJUST=='R') { 8441 _text->hjust = right; 8442 } else if(a_obj.m_HJUST=='C') { 8443 _text->hjust = center; 8444 } else { 8445 _text->hjust = left; 8446 } 8447 if(a_obj.m_VJUST=='T') { 8448 _text->vjust = top; 8449 } else if(a_obj.m_VJUST=='M') { 8450 _text->vjust = middle; 8451 } else { 8452 _text->vjust = bottom; 8453 } 8454 8455 sep->add(_text); 8456 8457 } else { //text_as_it (for gopaw/pagpri.c 8458 _tsf->mul_scale(a_obj.m_SIZE,a_obj.m_SI 8459 8460 if(a_obj.m_FONT==font_hershey()) { 8461 //::printf("debug : tools::sg::plotte 8462 draw_style* ds = new draw_style; 8463 ds->style = draw_lines; 8464 ds->line_pattern = line_solid; 8465 ds->line_width = a_obj.m_line_width; 8466 //ds->line_pattern = m_title_style.li 8467 //ds->line_width = m_title_style.line 8468 sep->add(ds); 8469 8470 text_hershey* text = new text_hershey 8471 text->encoding = encoding_PAW(); 8472 text->strings.add(a_obj.m_TEXT); 8473 if(a_obj.m_HJUST=='R') { 8474 text->hjust = right; 8475 } else if(a_obj.m_HJUST=='C') { 8476 text->hjust = center; 8477 } else { 8478 text->hjust = left; 8479 } 8480 if(a_obj.m_VJUST=='T') { 8481 text->vjust = top; 8482 } else if(a_obj.m_VJUST=='M') { 8483 text->vjust = middle; 8484 } else { 8485 text->vjust = bottom; 8486 } 8487 sep->add(text); 8488 8489 } else { 8490 //::printf("debug : tools::sg::plotte 8491 base_freetype* text = base_freetype:: 8492 8493 text->font = a_obj.m_FONT; 8494 if(a_obj.m_HJUST=='R') { 8495 text->hjust = right; 8496 } else if(a_obj.m_HJUST=='C') { 8497 text->hjust = center; 8498 } else { 8499 text->hjust = left; 8500 } 8501 if(a_obj.m_VJUST=='T') { 8502 text->vjust = top; 8503 } else if(a_obj.m_VJUST=='M') { 8504 text->vjust = middle; 8505 } else { 8506 text->vjust = bottom; 8507 } 8508 8509 text->modeling = a_obj.m_font_modelin 8510 8511 //text->encoding = encoding_PAW() 8512 //text->smooting = a_obj.m_SMOOTHING; 8513 //text->hinting = a_obj.m_HINTING; 8514 text->strings.add(a_obj.m_TEXT); 8515 //text->hjust.value(a_hjust); 8516 //text->vjust.value(a_vjust); 8517 8518 sep->add(text); 8519 } 8520 8521 } //text_mode. 8522 8523 m_primitives_sep.add(sep); 8524 } 8525 8526 // for OpenPAW /GRAPHICS/PRIMITIVES/BOX 8527 void PAW_hatch(int aHTYP,hatching_policy& a 8528 // PAW hatching encoding (paw.pdf 1.14(19 8529 8530 a_policy = hatching_none; 8531 a_spacing = 0; 8532 a_angle_right = 0; 8533 a_angle_left = 0; 8534 8535 int code = aHTYP; 8536 if(code==0) return; 8537 8538 // From PAW FAQ web page. 8539 // special code from code [1,25] 8540 if(code==1) { 8541 a_policy = hatching_left_and_right; 8542 a_spacing = 0.04F; 8543 a_angle_right = 3.0F*fpi()/4.0F; 8544 a_angle_left = fpi()/4.0F; 8545 return; 8546 } else if(code==2) { 8547 a_policy = hatching_left_and_right; 8548 a_spacing = 0.08F; 8549 a_angle_right = 3.0F*fpi()/4.0F; 8550 a_angle_left = fpi()/4.0F; 8551 return; 8552 } else if(code==3) { 8553 a_policy = hatching_left_and_right; 8554 a_spacing = 1.6f*0.07F; //cooking 8555 a_angle_right = 3.0F*fpi()/4.0F; 8556 a_angle_left = fpi()/4.0F; 8557 return; 8558 } else if(code==4) { 8559 code = 354; 8560 } else if(code==5) { 8561 code = 345; 8562 } else if(code==6) { 8563 code = 359; 8564 } else if(code==7) { 8565 code = 350; 8566 } else if(code<=25) { 8567 //FIXME : seems to be done with pattern 8568 a_policy = hatching_none; 8569 return; 8570 } else if(code<=99) { 8571 //FIXME 8572 a_policy = hatching_none; 8573 return; 8574 } 8575 8576 //code >=100 8577 8578 // code = ijk 8579 8580 int i = code / 100; 8581 int j = (code - i * 100)/10; 8582 int k = code - i * 100 - j * 10; 8583 8584 // j-hatching on rightHatchStyle : 8585 // k-hatching on leftHatchStyle : 8586 8587 if((j==5)&&(k==5)) 8588 a_policy = hatching_none; 8589 else if((j!=5)&&(k==5)) 8590 a_policy = hatching_right; 8591 else if((j==5)&&(k!=5)) 8592 a_policy = hatching_left; 8593 else if((j!=5)&&(k!=5)) 8594 a_policy = hatching_left_and_right; 8595 8596 unsigned int NY = 1; 8597 8598 a_spacing = float(NY) * float(i) * 0.07F; 8599 8600 if(j!=5) { 8601 float angle = float(j==4?45:j*10); 8602 angle = 180.0F - angle; 8603 angle *= fpi() / 180.0F; 8604 8605 a_angle_right = angle; 8606 } 8607 8608 if(k!=5) { 8609 float angle = float(k==4?45:k*10); 8610 angle *= fpi() / 180.0F; 8611 a_angle_left = angle; 8612 } 8613 8614 } 8615 8616 void rep_box_hatch(separator& a_parent,floa 8617 float xx,float yy,float 8618 8619 //printf("debug : SoPlotter::repHatch1D_x 8620 sg::separator* separator = new sg::separa 8621 8622 bool empty = true; 8623 8624 vec3f points[5]; 8625 8626 points[0].set_value(xx,yy,a_zz); 8627 points[1].set_value(xe,yy,a_zz); 8628 points[2].set_value(xe,ye,a_zz); 8629 points[3].set_value(xx,ye,a_zz); 8630 points[4].set_value(xx,yy,a_zz); 8631 8632 //We can have multiple hatching for a bin 8633 hatcher _hatcher; 8634 _hatcher.set_offset_point(vec3f(0,0,a_zz) 8635 _hatcher.set_angle(a_angle); 8636 _hatcher.set_spacing(a_spacing); 8637 if(!_hatcher.set_strip_width(a_strip_widt 8638 8639 bool res = _hatcher.check_polyline(points 8640 if(res) res = _hatcher.compute_polyline(p 8641 8642 size_t numPoints = _hatcher.points().size 8643 size_t numVertices = _hatcher.vertices(). 8644 if((res) && numPoints && numVertices) { 8645 8646 const std::vector<vec3f>& _points = _ha 8647 8648 if(a_strip_width==0) { 8649 size_t ipt = 0; 8650 tools_vforcit(unsigned int,_hatcher.v 8651 vertices* vtxs = new vertices; 8652 vtxs->mode = gl::line_strip(); 8653 for(size_t index=0;index<(*itv);ind 8654 vtxs->add(_points[ipt]); 8655 ipt++; 8656 } 8657 separator->add(vtxs); 8658 empty = false; 8659 } 8660 8661 } else { 8662 size_t ipt = 0; 8663 tools_vforcit(unsigned int,_hatcher.v 8664 vertices* vtxs = new vertices; 8665 vtxs->mode = gl::triangle_fan(); 8666 for(size_t index=0;index<(*itv);ind 8667 vtxs->add(_points[ipt]); 8668 ipt++; 8669 } 8670 separator->add(vtxs); 8671 empty = false; 8672 } 8673 } 8674 8675 empty = false; 8676 } 8677 8678 if(empty) { 8679 delete separator; 8680 } else { 8681 a_parent.add(separator); 8682 } 8683 } 8684 8685 void update_primitive_box(std::ostream& a_o 8686 8687 float z = xy_depth.value()*1.1F; 8688 8689 vec3f pos1; 8690 axis_2_data_frame(vec3f(a_obj.m_X1,a_obj. 8691 xx_2_yy(pos1,pos1); 8692 8693 vec3f pos2; 8694 axis_2_data_frame(vec3f(a_obj.m_X2,a_obj. 8695 xx_2_yy(pos2,pos2); 8696 8697 z = pos1[2]; 8698 8699 // ::printf("debug : tools::sg::plotter::u 8700 // pos1.x(),pos1.y(),pos1.z(),pos2.x() 8701 8702 if(a_obj.m_FAIS==plottable_box::HOLLOW) { 8703 8704 separator* sep = new separator; 8705 8706 rgba* mat = new rgba(); 8707 mat->color = a_obj.m_PLCI; 8708 sep->add(mat); 8709 8710 draw_style* ds = new draw_style; 8711 ds->style = draw_lines; 8712 ds->line_pattern = line_solid; 8713 ds->line_width = a_obj.m_LWID; 8714 sep->add(ds); 8715 8716 vertices* vtxs = new vertices; 8717 vtxs->mode = gl::line_strip(); 8718 sep->add(vtxs); 8719 8720 vtxs->add(pos1[0],pos1[1],z); 8721 vtxs->add(pos2[0],pos1[1],z); 8722 vtxs->add(pos2[0],pos2[1],z); 8723 vtxs->add(pos1[0],pos2[1],z); 8724 vtxs->add(pos1[0],pos1[1],z); 8725 8726 m_primitives_sep.add(sep); 8727 8728 } else if(a_obj.m_FAIS==plottable_box::SO 8729 separator* sep = new separator; 8730 8731 rgba* mat = new rgba(); 8732 mat->color = a_obj.m_FACI; 8733 sep->add(mat); 8734 8735 draw_style* ds = new draw_style; 8736 ds->style = draw_filled; 8737 sep->add(ds); 8738 8739 vertices* vtxs = new vertices; 8740 vtxs->mode = gl::triangle_fan(); 8741 sep->add(vtxs); 8742 8743 vtxs->add(pos1[0],pos1[1],z); 8744 vtxs->add(pos2[0],pos1[1],z); 8745 vtxs->add(pos2[0],pos2[1],z); 8746 vtxs->add(pos1[0],pos2[1],z); 8747 8748 m_primitives_sep.add(sep); 8749 8750 } else if(a_obj.m_FAIS==plottable_box::HA 8751 8752 {separator* sep = new separator; 8753 8754 rgba* mat = new rgba(); 8755 mat->color = a_obj.m_FACI; 8756 sep->add(mat); 8757 8758 hatching_policy hatching; 8759 float spacing; 8760 float angle_right; 8761 float angle_left; 8762 PAW_hatch(a_obj.m_FASI,hatching,spacing 8763 float stripWidth = 0; 8764 8765 if((hatching==hatching_right)||((hatchi 8766 rep_box_hatch(*sep,spacing,angle_righ 8767 } 8768 if((hatching==hatching_left)||((hatchin 8769 rep_box_hatch(*sep,spacing,angle_left 8770 } 8771 8772 if(hatching==hatching_none) { 8773 draw_style* ds = new draw_style; 8774 ds->style = draw_filled; 8775 sep->add(ds); 8776 vertices* vtxs = new vertices; 8777 vtxs->mode = gl::triangle_fan(); 8778 sep->add(vtxs); 8779 vtxs->add(pos1[0],pos1[1],z); 8780 vtxs->add(pos2[0],pos1[1],z); 8781 vtxs->add(pos2[0],pos2[1],z); 8782 vtxs->add(pos1[0],pos2[1],z); 8783 } 8784 8785 m_primitives_sep.add(sep);} 8786 8787 if(a_obj.m_BORD) { 8788 separator* sep = new separator; 8789 rgba* mat = new rgba(); 8790 mat->color = a_obj.m_PLCI; 8791 sep->add(mat); 8792 8793 draw_style* ds = new draw_style; 8794 ds->style = draw_lines; 8795 ds->line_pattern = line_solid; 8796 ds->line_width = 1; 8797 sep->add(ds); 8798 8799 vertices* vtxs = new vertices; 8800 vtxs->mode = gl::line_strip(); 8801 sep->add(vtxs); 8802 8803 z *= 1.01F; 8804 vtxs->add(pos1[0],pos1[1],z); 8805 vtxs->add(pos2[0],pos1[1],z); 8806 vtxs->add(pos2[0],pos2[1],z); 8807 vtxs->add(pos1[0],pos2[1],z); 8808 vtxs->add(pos1[0],pos1[1],z); 8809 8810 m_primitives_sep.add(sep); 8811 } 8812 8813 } else if(a_obj.m_FAIS==plottable_box::PA 8814 a_out << "tools::sg::plotter::update_pl 8815 } 8816 8817 } 8818 8819 void update_primitive_ellipse(std::ostream& 8820 8821 float z = xy_depth.value()*1.1F; 8822 8823 vec3f pos; 8824 axis_2_data_frame(vec3f(a_obj.m_X,a_obj.m 8825 xx_2_yy(pos,pos); 8826 8827 vec3f pos2; 8828 axis_2_data_frame(vec3f(a_obj.m_X+a_obj.m 8829 xx_2_yy(pos2,pos2); 8830 8831 float rx = pos2[0]-pos[0]; 8832 float ry = pos2[1]-pos[1]; 8833 8834 z = pos[2]; 8835 8836 //::printf("debug : tools::sg::plotter::u 8837 // pos.x(),pos.y(),pos.z(),rx,ry) 8838 8839 if(a_obj.m_FAIS==plottable_ellipse::HOLLO 8840 8841 separator* sep = new separator; 8842 8843 matrix* _tsf = new matrix; 8844 _tsf->set_translate(pos); 8845 sep->add(_tsf); 8846 8847 rgba* mat = new rgba(); 8848 mat->color = a_obj.m_PLCI; 8849 sep->add(mat); 8850 8851 draw_style* ds = new draw_style; 8852 ds->style = draw_lines; 8853 ds->line_pattern = line_solid; 8854 ds->line_width = a_obj.m_LWID; 8855 sep->add(ds); 8856 8857 ellipse* _ellipse = new ellipse; 8858 _ellipse->rx = rx; 8859 _ellipse->ry = ry; 8860 sep->add(_ellipse); 8861 8862 m_primitives_sep.add(sep); 8863 8864 /* 8865 } else if(a_obj.m_FAIS==plottable_ellipse 8866 separator* sep = new separator; 8867 8868 rgba* mat = new rgba(); 8869 mat->color = a_obj.m_FACI; 8870 sep->add(mat); 8871 8872 draw_style* ds = new draw_style; 8873 ds->style = draw_filled; 8874 sep->add(ds); 8875 8876 vertices* vtxs = new vertices; 8877 vtxs->mode = gl::triangle_fan(); 8878 sep->add(vtxs); 8879 8880 vtxs->add(pos1[0],pos1[1],z); 8881 vtxs->add(pos2[0],pos1[1],z); 8882 vtxs->add(pos2[0],pos2[1],z); 8883 vtxs->add(pos1[0],pos2[1],z); 8884 8885 m_primitives_sep.add(sep); 8886 8887 } else if(a_obj.m_FAIS==plottable_ellipse 8888 8889 {separator* sep = new separator; 8890 8891 rgba* mat = new rgba(); 8892 mat->color = a_obj.m_FACI; 8893 sep->add(mat); 8894 8895 hatching_policy hatching; 8896 float spacing; 8897 float angle_right; 8898 float angle_left; 8899 PAW_hatch(a_obj.m_FASI,hatching,spacing 8900 float stripWidth = 0; 8901 8902 if((hatching==hatching_right)||((hatchi 8903 rep_box_hatch(*sep,spacing,angle_righ 8904 } 8905 if((hatching==hatching_left)||((hatchin 8906 rep_box_hatch(*sep,spacing,angle_left 8907 } 8908 8909 if(hatching==hatching_none) { 8910 draw_style* ds = new draw_style; 8911 ds->style = draw_filled; 8912 sep->add(ds); 8913 vertices* vtxs = new vertices; 8914 vtxs->mode = gl::triangle_fan(); 8915 sep->add(vtxs); 8916 vtxs->add(pos1[0],pos1[1],z); 8917 vtxs->add(pos2[0],pos1[1],z); 8918 vtxs->add(pos2[0],pos2[1],z); 8919 vtxs->add(pos1[0],pos2[1],z); 8920 } 8921 8922 m_primitives_sep.add(sep);} 8923 8924 if(a_obj.m_BORD) { 8925 separator* sep = new separator; 8926 rgba* mat = new rgba(); 8927 mat->color = a_obj.m_PLCI; 8928 sep->add(mat); 8929 8930 draw_style* ds = new draw_style; 8931 ds->style = draw_lines; 8932 ds->line_pattern = line_solid; 8933 ds->line_width = 1; 8934 sep->add(ds); 8935 8936 vertices* vtxs = new vertices; 8937 vtxs->mode = gl::line_strip(); 8938 sep->add(vtxs); 8939 8940 z *= 1.01F; 8941 vtxs->add(pos1[0],pos1[1],z); 8942 vtxs->add(pos2[0],pos1[1],z); 8943 vtxs->add(pos2[0],pos2[1],z); 8944 vtxs->add(pos1[0],pos2[1],z); 8945 vtxs->add(pos1[0],pos1[1],z); 8946 8947 m_primitives_sep.add(sep); 8948 } 8949 8950 } else if(a_obj.m_FAIS==plottable_ellipse 8951 a_out << "tools::sg::plotter::update_pl 8952 */ 8953 } else { 8954 a_out << "tools::sg::plotter::update_pl 8955 } 8956 8957 } 8958 8959 void update_primitive_img(std::ostream& /*a 8960 8961 float z = xy_depth.value()*1.1F; 8962 8963 vec3f pos; 8964 axis_2_data_frame(vec3f(a_obj.m_X,a_obj.m 8965 xx_2_yy(pos,pos); //pos = center of ima 8966 z = pos[2]; 8967 8968 vec3f top; 8969 axis_2_data_frame(vec3f(0,a_obj.m_Y+a_obj 8970 xx_2_yy(top,top); //top = (o,y-top) of 8971 float scale = 2.0f*(top[1]-pos[1]); 8972 //float scale = a_obj.m_HEIGHT; //m_HEIGH 8973 8974 const img<byte>& img = a_obj.m_img; 8975 8976 //::printf("debug : tools::sg::plotter::upd 8977 // img.width(),img.height(),img.bpp(), 8978 // pos.x(),pos.y(),pos.z(),a_obj.m_HEIGH 8979 8980 separator* sep = new separator; 8981 8982 rgba* mat = new rgba(); 8983 mat->color = colorf_white(); 8984 sep->add(mat); 8985 8986 normal* nm = new normal; 8987 sep->add(nm); 8988 8989 matrix* _tsf = new matrix; 8990 _tsf->set_translate(pos); 8991 _tsf->mul_rotate(0,1,0,a_obj.m_THETA*fpi( 8992 _tsf->mul_rotate(0,0,1,a_obj.m_PHI*fpi()/ 8993 _tsf->mul_scale(scale,scale,1); 8994 sep->add(_tsf); 8995 8996 tex_rect* _img = new tex_rect(); 8997 _img->img = img; 8998 sep->add(_img); 8999 9000 m_primitives_sep.add(sep); 9001 9002 } 9003 9004 protected: //etc 9005 // background is at z = 0. 9006 // last z items are text in infos, legend b 9007 9008 float _zoffset() const { 9009 // first data plane is at _zoffset. 9010 // last one at m_plottables.size()*_zoffs 9011 return xy_depth.value()/(float(m_plottabl 9012 } 9013 float _zaxis() const {return _zoffset();} 9014 float _zgrid() const {return xy_depth.value 9015 float _ztext() const {return 0.01f;} //if t 9016 float _zscale_text() const {return _zoffset 9017 float _zinfos() const {return xy_depth.valu 9018 float _zhatch() const {return _zoffset()*0. 9019 float _zerrors() const {return _zoffset()*0 9020 9021 //static void LIST_SET(vec3f a_list[],unsig 9022 9023 static float take_log(float a_x){ 9024 if(a_x<=0) { 9025 return -FLT_MAX; 9026 } else { 9027 return flog10(a_x); 9028 } 9029 } 9030 9031 static float verify_log(float a_val,float a 9032 if(a_log) { 9033 if(a_val>0.0F) { 9034 return (flog10(a_val) - a_min)/a_dx; 9035 } else { // Return a negative large num 9036 //return -FLT_MAX; 9037 return -100; 9038 } 9039 } else { 9040 // Simple protection against value that 9041 if(a_val>(a_min+100.0F * a_dx)) return 9042 if(a_val<(a_min-100.0F * a_dx)) return 9043 // Rescale : 9044 return (a_val - a_min)/a_dx; 9045 } 9046 } 9047 9048 static float verify_log_inv(float a_val,flo 9049 if(a_log) { 9050 return fpow(10,a_val*a_dx+a_min); 9051 } else { 9052 return a_val*a_dx+a_min; 9053 } 9054 } 9055 9056 style* merge_bins_style(unsigned int a_inde 9057 style& _style = bins_style(a_index); 9058 //uuu merge with a_p.infos(). 9059 return new style(_style); 9060 } 9061 9062 style* merge_left_hatch_style(unsigned int 9063 style& _style = left_hatch_style(a_index) 9064 //uuu merge with a_p.infos(). 9065 return new style(_style); 9066 } 9067 9068 style* merge_right_hatch_style(unsigned int 9069 style& _style = right_hatch_style(a_index 9070 //uuu merge with a_p.infos(). 9071 return new style(_style); 9072 } 9073 9074 style* merge_errors_style(unsigned int a_in 9075 style& _style = errors_style(a_index); 9076 //uuu merge with a_p.infos(). 9077 return new style(_style); 9078 } 9079 9080 style* merge_func_style(unsigned int a_inde 9081 style& _style = func_style(a_index); 9082 //uuu merge with a_p.infos(). 9083 return new style(_style); 9084 } 9085 9086 style* merge_points_style(unsigned int a_in 9087 style& _style = points_style(a_index); 9088 //uuu merge with a_p.infos(). 9089 return new style(_style); 9090 } 9091 9092 /* 9093 text_style* merge_legend_style(unsigned int 9094 if(a_index>=m_legend_style.size()) return 9095 return new text_style(m_legend_style[a_in 9096 //uuu merge with a_p.infos(). 9097 } 9098 */ 9099 9100 shape_type get_shape() const { 9101 if(!shape_automated) return shape.value() 9102 9103 // Guess XY or XYZ shape : 9104 /*if(f_binsList.size()) { // major bins com 9105 if(f_binsList[0]->getDimension()==1) { 9106 return XY; 9107 } else if(f_binsList[0]->getDimension() 9108 return XY; //lego is not the default. 9109 } else { 9110 return XYZ; 9111 } 9112 } else if(f_pointsList.size()) { // major 9113 if(f_pointsList[0]->getDimension()==1) 9114 return XY; 9115 } else if(f_pointsList[0]->getDimension 9116 return XY; 9117 } else { 9118 return XYZ; 9119 } 9120 } else if(f_functionList.size()) { // maj 9121 if(f_functionList[0]->getDimension()==1 9122 return XY; 9123 } else { 9124 return XYZ; 9125 } 9126 } else*/ { 9127 return xy; //Default. 9128 } 9129 } 9130 9131 void clear_plottables() { 9132 //unsigned int objn = m_plottables.size() 9133 {std::vector<plottable*>::iterator it; 9134 for(it=m_plottables.begin();it!=m_plottab 9135 m_plottables.clear();} 9136 9137 /* 9138 if(objn) { 9139 // If a title (logScale) had been given 9140 // it is probably no more pertinent for 9141 if(xAxisEnforced.value()==false) { 9142 m_x_axis.title.setValue(""); 9143 xAxisLogScale.setValue(false); 9144 } 9145 if(yAxisEnforced.value()==false) { 9146 m_y_axis.title.setValue(""); 9147 yAxisLogScale.setValue(false); 9148 } 9149 if(zAxisEnforced.value()==false) { 9150 m_z_axis.title.setValue(""); 9151 zAxisLogScale.setValue(false); 9152 } 9153 } 9154 */ 9155 9156 touch(); 9157 } 9158 void clear_primitives() { 9159 {std::vector<plotprim*>::iterator it; 9160 for(it=m_primitives.begin();it!=m_primiti 9161 m_primitives.clear();} 9162 touch(); 9163 } 9164 9165 void clear_todels() {m_todel_group.clear(); 9166 9167 bool first_bins(bins1D*& a_1,bins2D*& a_2) 9168 tools_vforcit(plottable*,m_plottables,it) 9169 plottable* object = *it; 9170 if(!object) continue; 9171 if(bins1D* b1 = safe_cast<plottable,bin 9172 a_1 = b1; 9173 a_2 = 0; 9174 return true; 9175 } else if(bins2D* b2 = safe_cast<plotta 9176 a_1 = 0; 9177 a_2 = b2; 9178 return true; 9179 } 9180 } 9181 a_1 = 0; 9182 a_2 = 0; 9183 return false; 9184 } 9185 9186 bool first_func(func1D*& a_1,func2D*& a_2) 9187 tools_vforcit(plottable*,m_plottables,it) 9188 plottable* object = *it; 9189 if(!object) continue; 9190 if(func1D* f1 = safe_cast<plottable,fun 9191 a_1 = f1; 9192 a_2 = 0; 9193 return true; 9194 } else if(func2D* f2 = safe_cast<plotta 9195 a_1 = 0; 9196 a_2 = f2; 9197 return true; 9198 } 9199 } 9200 a_1 = 0; 9201 a_2 = 0; 9202 return false; 9203 } 9204 9205 bool first_points(points2D*& a_2,points3D*& 9206 tools_vforcit(plottable*,m_plottables,it) 9207 plottable* object = *it; 9208 if(!object) continue; 9209 if(points2D* p2 = safe_cast<plottable,p 9210 a_2 = p2; 9211 a_3 = 0; 9212 return true; 9213 } else if(points3D* p3 = safe_cast<plot 9214 a_2 = 0; 9215 a_3 = p3; 9216 return true; 9217 } 9218 } 9219 a_2 = 0; 9220 a_3 = 0; 9221 return false; 9222 } 9223 9224 void clear_sg() { 9225 m_bins_sep.clear(); 9226 m_errors_sep.clear(); 9227 m_func_sep.clear(); 9228 m_points_sep.clear(); 9229 } 9230 9231 void DUMP_UPDATE_WHAT(std::ostream&,const s 9232 /* 9233 void DUMP_UPDATE_WHAT(std::ostream& a_out,c 9234 a_out << "tools::sg::plotter :" 9235 << " " << a_msg 9236 << std::endl; 9237 } 9238 */ 9239 9240 static void add_pt(std::vector<float>& a_pt 9241 a_pts.push_back(a_x); 9242 a_pts.push_back(a_y); 9243 a_pts.push_back(a_z); 9244 } 9245 9246 static void clip_points_2D(const std::vecto 9247 const rep_box& a 9248 float xmin = a_box_x.m_pos; 9249 float dx = a_box_x.m_width; 9250 bool xlog = a_box_x.m_log; 9251 9252 float ymin = a_box_y.m_pos; 9253 float dy = a_box_y.m_width; 9254 bool ylog = a_box_y.m_log; 9255 9256 a_pts.clear(); 9257 9258 float xx,yy,zz; 9259 tools_vforcit(vec3f,a_points,it) { 9260 const vec3f& _point = *it; 9261 xx = _point[0]; 9262 yy = _point[1]; 9263 zz = _point[2]; 9264 xx = verify_log(xx,xmin,dx,xlog); 9265 yy = verify_log(yy,ymin,dy,ylog); 9266 if((xx>=0)&&(xx<=1)&&(yy>=0)&&(yy<=1)) 9267 } 9268 } 9269 9270 static void clip_polyline_2D(const std::vec 9271 const rep_box& 9272 // Clip line in a_box_x, a_box_y. 9273 9274 //NOTE : it is not a general algorithm. 9275 // It is assumed that a_points are 9276 // And the algorithm clips against 9277 // (Use clip<float> for a more gene 9278 9279 float xmin = a_box_x.m_pos; 9280 float dx = a_box_x.m_width; 9281 bool xlog = a_box_x.m_log; 9282 9283 float ymin = a_box_y.m_pos; 9284 float dy = a_box_y.m_width; 9285 bool ylog = a_box_y.m_log; 9286 9287 a_pts.clear(); 9288 9289 float xprev = 0; 9290 float yprev = 0; 9291 9292 {unsigned int index = 0; 9293 std::vector<vec3f>::const_iterator it; 9294 for(it=a_points.begin();it!=a_points.end( 9295 const vec3f& _point = *it; 9296 float xx = _point[0]; 9297 float yy = _point[1]; 9298 float zz = _point[2]; 9299 //add_pt(a_pts,xx,yy,zz);continue; //de 9300 xx = verify_log(xx,xmin,dx,xlog); 9301 yy = verify_log(yy,ymin,dy,ylog); 9302 if((xx>=0)&&(xx<=1) ) { 9303 if(yy>1) { 9304 if(index==0) { 9305 add_pt(a_pts,xx,1,zz); 9306 } else { 9307 if(yprev>1) { 9308 add_pt(a_pts,xx,1,zz); 9309 } else if(yprev<0) { 9310 float a = (yy - yprev)/(xx - xp 9311 float b = yy - a * xx; 9312 add_pt(a_pts,-b/a,0,zz); 9313 add_pt(a_pts,(1 - b)/a,1,zz); 9314 add_pt(a_pts,xx,1,zz); 9315 } else { 9316 float a = (yy - yprev)/(xx - xp 9317 float b = yy - a * xx; 9318 add_pt(a_pts,(1 - b)/a,1,zz); 9319 add_pt(a_pts,xx,1,zz); 9320 } 9321 } 9322 } else if (yy < 0) { 9323 if(index==0) { 9324 add_pt(a_pts,xx,0,zz); 9325 } else { 9326 if(yprev<0) { 9327 add_pt(a_pts,xx,0,zz); 9328 } else if(yprev>1) { 9329 float a = (yy - yprev)/(xx - xp 9330 float b = yy - a * xx; 9331 add_pt(a_pts,(1 - b)/a,1,zz); 9332 add_pt(a_pts,-b/a,0,zz); 9333 add_pt(a_pts,xx,0,zz); 9334 } else { 9335 float a = (yy - yprev)/(xx - xp 9336 float b = yy - a * xx; 9337 add_pt(a_pts,-b/a,0,zz); 9338 add_pt(a_pts,xx,0,zz); 9339 } 9340 } 9341 } else { 9342 if(index==0) { 9343 add_pt(a_pts,xx,yy,zz); 9344 } else if( (yprev>1) || (yprev<0) ) 9345 // interpolate : 9346 float a = (yy - yprev)/(xx - xpre 9347 float b = yy - a * xx; 9348 if(yprev>1) { 9349 add_pt(a_pts,(1 - b)/a,1,zz); 9350 } else { 9351 add_pt(a_pts,-b/a,0,zz); 9352 } 9353 add_pt(a_pts,xx,yy,zz); 9354 } else { 9355 add_pt(a_pts,xx,yy,zz); 9356 } 9357 } 9358 } 9359 xprev = xx; 9360 yprev = yy; 9361 }} 9362 } 9363 9364 bool sto(const std::string& a_s,vec2f& a_v) 9365 std::vector<std::string> ws; 9366 words(a_s," ",false,ws); 9367 if(ws.size()!=2) return false; 9368 float x = 0; 9369 if(!to<float>(ws[0],x)) return false; 9370 float y = 0; 9371 if(!to<float>(ws[1],x)) return false; 9372 a_v.set_value(x,y); 9373 return true; 9374 } 9375 9376 bool sto(const std::string& a_s,unit_type& 9377 if(a_s=="percent") {a_v = unit_percent;re 9378 else if(a_s=="axis") {a_v = unit_axis;ret 9379 return false; 9380 } 9381 9382 void clear_cmaps() { 9383 {std::vector<base_colormap*>::iterator it; 9384 for(it=m_bins_cmaps.begin();it!=m_bins_cm 9385 m_bins_cmaps.clear();} 9386 9387 {std::vector<base_colormap*>::iterator it; 9388 for(it=m_points_cmaps.begin();it!=m_point 9389 m_points_cmaps.clear();} 9390 9391 {std::vector<base_colormap*>::iterator it; 9392 for(it=m_func_cmaps.begin();it!=m_func_cm 9393 m_func_cmaps.clear();} 9394 } 9395 9396 void bar_chart(float a_bar_offset,float a_b 9397 float& a_beg,float& a_end){ 9398 float xe = (a_end - a_beg)*a_bar_offset; 9399 float xw = (a_end - a_beg)*a_bar_width; 9400 a_end = a_beg + xe + xw; 9401 a_beg = a_beg + xe; 9402 } 9403 9404 protected: 9405 const base_freetype& m_ttf; 9406 protected: //fields for skeleton. 9407 group m_group; 9408 9409 separator m_background_sep; 9410 9411 separator m_cmap_sep; 9412 matrix m_cmap_matrix; 9413 separator m_cmap_cells_sep; 9414 matrix m_cmap_axis_matrix; 9415 sg::axis m_cmap_axis; 9416 9417 separator m_infos_title_sep; 9418 separator m_infos_sep; 9419 separator m_legend_sep; 9420 separator m_title_box_sep; 9421 9422 matrix m_tsf; 9423 matrix m_layout; 9424 9425 separator m_title_sep; 9426 9427 separator m_x_axis_sep; 9428 matrix m_x_axis_matrix; 9429 sg::axis m_x_axis; 9430 9431 separator m_y_axis_sep; 9432 matrix m_y_axis_matrix; 9433 sg::axis m_y_axis; 9434 9435 separator m_z_axis_sep; 9436 matrix m_z_axis_matrix; 9437 sg::axis m_z_axis; 9438 9439 separator m_grid_sep; 9440 9441 separator m_data_sep; 9442 torche m_data_light; 9443 matrix m_data_matrix; 9444 separator m_bins_sep; 9445 separator m_errors_sep; 9446 separator m_func_sep; 9447 separator m_points_sep; 9448 separator m_inner_frame_sep; 9449 separator m_primitives_sep; 9450 separator m_etc_sep; 9451 9452 protected: //fields 9453 shape_type m_shape; 9454 9455 data_axis m_x_axis_data; 9456 data_axis m_y_axis_data; 9457 data_axis m_z_axis_data; 9458 9459 std::vector<plottable*> m_plottables; //it 9460 9461 std::vector<style> m_bins_style; 9462 std::vector<style> m_errors_style; 9463 std::vector<style> m_func_style; 9464 std::vector<style> m_points_style; 9465 std::vector<style> m_left_hatch_style; 9466 std::vector<style> m_right_hatch_style; 9467 std::vector<style> m_legend_style; 9468 9469 text_style m_title_style; 9470 text_style m_infos_style; 9471 text_style m_title_box_style; 9472 style m_background_style; 9473 style m_wall_style; //for gopaw. 9474 style m_inner_frame_style; 9475 style m_grid_style; 9476 9477 protected: 9478 std::vector<std::string> m_legend_strings; 9479 9480 std::vector<base_colormap*> m_bins_cmaps; 9481 std::vector<base_colormap*> m_points_cmaps; 9482 std::vector<base_colormap*> m_func_cmaps; 9483 9484 group m_todel_group; 9485 std::vector<plotprim*> m_primitives; 9486 cmaps_t m_cmaps; 9487 rtausmef m_rtausmef; 9488 }; 9489 9490 }} 9491 9492 #endif