src/pivvalid.c

   1 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 c-style: "K&R" -*- */
   2
   3 /*-----------------------------------------------------------------------------
   4
   5   gpiv - Graphic program for Particle Image Velocimetry, based on gtk/gnome
   6           libraries.
   7
   8    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
   9    Gerber van der Graaf
  10
  11    This file is part of gpiv.
  12
  13    Gpiv is free software; you can redistribute it and/or modify
  14    it under the terms of the GNU General Public License as published by
  15    the Free Software Foundation; either version 2, or (at your option)
  16    any later version.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software Foundation,
  25    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26
  27 -----------------------------------------------------------------------------*/
  28
  29 /*
  30  * (callback) functions for Piv validation window/tabulator
  31  * $Log: pivvalid.c,v $
  32  * Revision 1.16  2008-04-28 12:00:57  gerber
  33  * hdf-formatted files are now with .hdf extension (previously: .gpi)
  34  *
  35  * Revision 1.15  2007-12-19 08:42:35  gerber
  36  * debugged
  37  *
  38  * Revision 1.14  2007-11-23 16:24:08  gerber
  39  * release 0.5.0: Kafka
  40  *
  41  * Revision 1.13  2007-06-06 17:00:48  gerber
  42  * Retreives images/data from URI using Gnome Virtual File System.
  43  *
  44  * Revision 1.12  2007-03-22 16:00:32  gerber
  45  * Added image processing tabulator
  46  *
  47  * Revision 1.11  2007-01-29 11:27:44  gerber
  48  * added image formats png, gif, tif png, bmp, improved buffer display
  49  *
  50  * Revision 1.10  2006/01/31 14:28:12  gerber
  51  * version 0.3.0
  52  *
  53  * Revision 1.9  2005/06/15 09:40:40  gerber
  54  * debugged, optimized
  55  *
  56  * Revision 1.8  2005/02/26 09:43:31  gerber
  57  * parameter flags (parameter_logic) defined as gboolean
  58  *
  59  * Revision 1.7  2004/10/15 19:24:05  gerber
  60  * GPIV_ and Gpiv prefix to defines and structure names of libgpiv
  61  *
  62  * Revision 1.6  2004/06/14 21:19:23  gerber
  63  * Image depth up to 16 bits.
  64  * Improvement "single int" and "drag int" in Eval tab.
  65  * Viewer's pop-up menu.
  66  * Adaption for gpiv_matrix_* and gpiv_vector_*.
  67  * Resizing console.
  68  * See Changelog for further info.
  69  *
  70  * Revision 1.5  2003/07/13 14:38:18  gerber
  71  * changed error handling of libgpiv
  72  *
  73  * Revision 1.4  2003/07/12 21:21:16  gerber
  74  * changed error handling libgpiv
  75  *
  76  * Revision 1.2  2003/07/10 11:56:07  gerber
  77  * added man page
  78  *
  79  * Revision 1.1.1.1  2003/06/17 17:10:52  gerber
  80  * Imported gpiv
  81  *
  82  */
  83
  84
  85 #include "gpiv_gui.h"
  86 #include "utils.h"
  87 #include "pivvalid.h"
  88 #include "display.h"
  89
  90
  91 /*
  92  * Public piv validation functions
  93  */
  94
  95 void
  96 exec_gradient(void
  97               )
  98 /* ----------------------------------------------------------------------------
  99  * Testing on gradient of displacements/veocity within Int. Area
 100  */
 101 {
 102     if  (display_act->pida->exist_piv && !cancel_process) {
 103         exec_process = TRUE;
 104         gpiv_valid_gradient (gl_piv_par,
 105                              display_act->pida->piv_data);
 106         update_all_vectors (display_act->pida);
 107         exec_process = FALSE;
 108     } else {
 109         warning_gpiv(_("no PIV data"));
 110     }
 111 }
 112
 113
 114
 115 void
 116 exec_errvec (PivValid * valid
 117              )
 118 /*-----------------------------------------------------------------------------
 119  * Calculates histogram of residus and resulting threshold displacement
 120  */
 121 {
 122     char *err_msg = NULL;
 123     guint i;
 124
 125     GnomeCanvasItem *bg, *bar, *fitline;
 126     GnomeCanvasPoints *points;
 127     double canvas_margin = 20.;
 128
 129     double canvas_startx = -50.;
 130     double canvas_endx = 150.;
 131     double disp_width = canvas_endx - canvas_startx - 2 * canvas_margin;
 132
 133     double canvas_starty = -50.;
 134     double canvas_endy = 150.;
 135     double disp_height = canvas_endy - canvas_starty - 2 * canvas_margin;
 136
 137     double canvas_x1 = canvas_startx + canvas_margin;
 138     double canvas_y1 = canvas_starty + canvas_margin + disp_height;
 139
 140     double x_val, y_val, x_normf, y_normf;
 141
 142
 143
 144     points = gnome_canvas_points_new (2);
 145
 146     if (display_act->pida->exist_piv && !cancel_process) {
 147         exec_process = TRUE;
 148
 149         if (gpiv_var->residu_stats == TRUE) {
 150 /*
 151  * Calculate histogram
 152  * normalizing histo between 0 and 1 and displaying histo and estimated
 153  * line curve
 154  */
 155             GpivBinData *klass = NULL;
 156             GpivLinRegData *linreg = g_new0 (GpivLinRegData, 1);
 157             double centre_max = -10.0E+9;
 158
 159
 160             if ((err_msg =
 161                  gpiv_valid_residu (display_act->pida->piv_data, gl_valid_par,
 162                                     TRUE))
 163                 != NULL) {
 164                 gpiv_error ("exec_errvec: failing gpiv_valid_residu");
 165             }
 166
 167             if ((klass =
 168                  gpiv_valid_residu_stats (display_act->pida->piv_data,
 169                                           display_act->pida->piv_data->nx
 170                                           * display_act->pida->piv_data->ny
 171                                           / GPIV_NBINS_DEFAULT,
 172                                           linreg))
 173                 == NULL) {
 174                 gpiv_error ("exec_errvec: failing gpiv_valid_residu_stats");
 175             }
 176
 177
 178             for (i = 0; i < klass->nbins; i++) {
 179                 if (klass->centre[i] > centre_max)
 180                     centre_max = klass->centre[i];
 181             }
 182
 183             x_normf =  (double) disp_width  / (klass->max - klass->min);
 184             y_normf = (double) centre_max;
 185
 186
 187             bg = gnome_canvas_item_new (gnome_canvas_root
 188                                         (GNOME_CANVAS(valid->canvas_histo)),
 189                                         gnome_canvas_rect_get_type(),
 190                                         "x1", (double) canvas_startx ,
 191                                         "y1", (double) canvas_starty,
 192                                         "x2", (double) canvas_endx ,
 193                                         "y2", (double) canvas_endy,
 194                                         "fill_color", "darkblue",
 195                                         "outline_color", "red",
 196                                         "width_units", 2.0,
 197                                         NULL);
 198
 199             for (i = 0; i < klass->nbins - 1; i++) {
 200                 x_val = (double) (klass->bound[i]) / x_normf;
 201                 y_val = (double) klass->centre[i] / y_normf;
 202                 bar =
 203                     gnome_canvas_item_new (gnome_canvas_root
 204                                            (GNOME_CANVAS (valid->canvas_histo)),
 205                                            gnome_canvas_rect_get_type(),
 206                                            "x1", canvas_x1 +
 207                                            (double) klass->bound[i]  * x_normf,
 208                                            "y1", canvas_y1 -
 209                                            (double) disp_height * y_val,
 210                                            "x2", canvas_x1 +
 211                                            (double)  klass->bound[i + 1] * x_normf,
 212                                            "y2", (double) canvas_y1,
 213                                            "fill_color", "darkgreen",
 214                                            "outline_color", "blue",
 215                                            "width_units", 2.0,
 216                                            NULL);
 217             }
 218
 219             gl_valid_par->residu_max =
 220                 gpiv_valid_threshold (display_act->pida->piv_par,
 221                                       gl_valid_par, linreg);
 222             gtk_spin_button_set_value (GTK_SPIN_BUTTON
 223                                        (valid->spinbutton_errvec_res),
 224                                        gl_valid_par->residu_max);
 225 #ifdef DEBUG
 226        g_message("gpiv_valid_errvec:: c1 = %f int_size_f = %d yield = %f residu_max = %f",
 227                   linreg->c1,
 228                   gl_piv_par->int_size_f,
 229                   gl_valid_par->data_yield,
 230                   gl_valid_par->residu_max);
 231 #endif
 232
 233             points->coords[0] = (double) canvas_x1;
 234             points->coords[1] = (double) canvas_y1
 235                 - (double) linreg->c0 / y_normf * (double) disp_height
 236                 ;
 237             points->coords[2] = (double) canvas_x1
 238                 + (double) disp_width;
 239             points->coords[3] = (double) canvas_y1
 240                 - (double) linreg->c0 / y_normf * (double) disp_height
 241                 - (double) linreg->c1 * (double) (disp_width) * (double) (disp_height)
 242                 / ( x_normf * y_normf)
 243                 ;
 244
 245
 246             fitline =
 247                 gnome_canvas_item_new (gnome_canvas_root
 248                                        (GNOME_CANVAS(valid->canvas_histo)),
 249                                        gnome_canvas_line_get_type(),
 250                                        "points", points,
 251                                        "fill_color", "red",
 252                                        "width_units", (double) 2.0,
 253                                        NULL);
 254
 255             gpiv_free_bindata (klass);
 256
 257
 258         } else {
 259             if ((err_msg =
 260                  gpiv_valid_errvec (display_act->pida->piv_data,
 261                                     display_act->img->image,
 262                                     gl_piv_par,
 263                                     gl_valid_par,
 264                                     FALSE))
 265                 != NULL) gpiv_error ("%s: %s", RCSID, err_msg);
 266             update_all_vectors (display_act->pida);
 267
 268         }
 269
 270         display_act->pida->exist_valid = TRUE;
 271
 272 /*
 273  * Copy parameters in Buffer structure for saving and, eventual,
 274  * later use
 275  */
 276         display_act->pida->valid_par->residu_max = gl_valid_par->residu_max;
 277         display_act->pida->valid_par->data_yield = gl_valid_par->data_yield;
 278         display_act->pida->valid_par->residu_type = gl_valid_par->residu_type;
 279         display_act->pida->valid_par->subst_type = gl_valid_par->subst_type;
 280         display_act->pida->valid_par->histo_type = gl_valid_par->histo_type;
 281
 282         display_act->pida->valid_par->residu_max__set = TRUE;
 283         display_act->pida->valid_par->data_yield__set =
 284             gl_valid_par->data_yield__set;
 285         display_act->pida->valid_par->residu_type__set = TRUE;
 286         display_act->pida->valid_par->subst_type__set = TRUE;
 287         display_act->pida->valid_par->histo_type__set = TRUE;
 288         exec_process = FALSE;
 289
 290     } else {
 291         warning_gpiv(_("no PIV data"));
 292     }
 293
 294     gnome_canvas_points_free(points);
 295
 296 }
 297
 298
 299
 300 void
 301 exec_peaklock (PivValid * valid
 302                )
 303 /*-----------------------------------------------------------------------------
 304  * Calculates and displays peaklocking histogram of a single PIV data set
 305  */
 306 {
 307
 308      guint i;
 309      GnomeCanvasItem *bg, *bar;
 310      double canvas_margin = 20.;
 311
 312      double canvas_startx = -50.;
 313      double canvas_endx = 150.;
 314      double d_width = canvas_endx - canvas_startx - 2 * canvas_margin;
 315
 316      double canvas_starty = -50.;
 317      double canvas_endy = 150.;
 318      double d_height = canvas_endy - canvas_starty - 2 * canvas_margin;
 319
 320      double canvas_x1 = canvas_startx + canvas_margin;
 321      double canvas_y1 = canvas_starty + canvas_margin + d_height;
 322
 323      double y_val;
 324      gint count_max = -10000;
 325      GpivBinData *klass = NULL;
 326
 327
 328
 329      if  (display_act->pida->exist_piv && !cancel_process) {
 330          exec_process = TRUE;
 331
 332 /*
 333  * Calculates and normalizes klass data between 0 and 1
 334  */
 335           if ((klass = gpiv_valid_peaklck (display_act->pida->piv_data,
 336                                            gpiv_par->console__nbins))
 337               == NULL) {
 338               gpiv_error ("exec_peaklock: failing gpiv_valid_peaklck");
 339           }
 340
 341
 342           for (i = 0; i < klass->nbins; i++) {
 343               if ((double) klass->count[i] > count_max) {
 344                    count_max = klass->count[i];
 345               }
 346           }
 347
 348
 349 /*
 350  * Displaying background and histogram
 351  */
 352           bg =
 353               gnome_canvas_item_new (gnome_canvas_root
 354                                      (GNOME_CANVAS(valid->canvas_histo)),
 355                                      gnome_canvas_rect_get_type(),
 356                                      "x1", (double) canvas_startx ,
 357                                      "y1", (double) canvas_starty,
 358                                      "x2", (double) canvas_endx ,
 359                                      "y2", (double) canvas_endy,
 360                                      "fill_color", "darkgreen",
 361                                      "outline_color", "red",
 362                                      "width_units", 2.0,
 363                                      NULL);
 364
 365           for (i = 0; i < klass->nbins; i++) {
 366               if (count_max != 0) {
 367                   y_val = (double) klass->count[i] / (double) count_max;
 368               } else {
 369                   y_val = 0.0;
 370               }
 371
 372
 373               bar =
 374                   gnome_canvas_item_new (gnome_canvas_root
 375                                          (GNOME_CANVAS(valid->canvas_histo)),
 376                                          gnome_canvas_rect_get_type(),
 377                                          "x1", canvas_x1 +
 378                                          (double) klass->bound[i] * d_width,
 379                                          "y1", canvas_y1 -
 380                                          (double) d_height * y_val,
 381                                          "x2", canvas_x1 +
 382                                          (double)  klass->bound[i+1] * d_width,
 383                                          "y2", canvas_y1,
 384                                          "fill_color", "yellow",
 385                                          "outline_color", "blue",
 386                                          "width_units", 2.0,
 387                                          NULL);
 388           }
 389
 390           gpiv_free_bindata (klass);
 391           exec_process = FALSE;
 392
 393      } else {
 394           warning_gpiv (_("no PIV data"));
 395      }
 396
 397 }
 398
 399
 400
 401 void
 402 exec_uvhisto (PivValid * valid,
 403               enum GpivVelComponent velcomp
 404               )
 405 /*-----------------------------------------------------------------------------
 406  */
 407 {
 408      guint i;
 409      GnomeCanvasItem *bg, *bar;
 410      double canvas_margin = 20.;
 411
 412      double canvas_startx = -50.;
 413      double canvas_endx = 150.;
 414      double d_width = canvas_endx - canvas_startx - 2 * canvas_margin;
 415
 416      double canvas_starty = -50.;
 417      double canvas_endy = 150.;
 418      double d_height = canvas_endy - canvas_starty - 2 * canvas_margin;
 419
 420      double canvas_x1 = canvas_startx + canvas_margin;
 421      double canvas_y1 = canvas_starty + canvas_margin + d_height;
 422
 423      double y_val;
 424      gint count_max = -10000;
 425 /*      char c_line[GPIV_MAX_LINES_C][GPIV_MAX_CHARS]; */
 426
 427
 428
 429      if (display_act->pida->exist_histo == TRUE) {
 430 /*          g_message("exec_uvhisto:: calling gpiv_free_bindata"); */
 431          gpiv_free_bindata (display_act->pida->klass);
 432      }
 433
 434      if  (display_act->pida->exist_piv && !cancel_process) {
 435          exec_process = TRUE;
 436
 437
 438 /* BUGFIX: quick hack to display u velocities */
 439 /*          g_message("::will process uhisto"); */
 440
 441           if ((display_act->pida->klass =
 442               gpiv_post_uvhisto (display_act->pida->piv_data,
 443                                  gpiv_par->console__nbins,
 444                                  velcomp))
 445               == NULL) {
 446               gpiv_error ("exec_uvhisto: failing gpiv_post_uvhisto");
 447           }
 448 /*           gpiv_print_histo(display_act->pida->klass,  */
 449 /*                            c_line,  */
 450 /*                            0, */
 451 /*                            display_act->pida->scaled_piv,  */
 452 /*                            VERSION); */
 453
 454 /*
 455  * normalizing data between 0 and 1
 456  */
 457           for (i = 0; i < display_act->pida->klass->nbins; i++) {
 458               if ((double) display_act->pida->klass->count[i] > count_max) {
 459                   count_max = display_act->pida->klass->count[i];
 460               }
 461           }
 462
 463 /*
 464  * Displaying
 465  */
 466           bg =
 467               gnome_canvas_item_new(gnome_canvas_root
 468                                     (GNOME_CANVAS(valid->canvas_histo)),
 469                                      gnome_canvas_rect_get_type(),
 470                                      "x1", (double) canvas_startx ,
 471                                      "y1", (double) canvas_starty,
 472                                      "x2", (double) canvas_endx ,
 473                                      "y2", (double) canvas_endy,
 474                                      "fill_color", "darkgreen",
 475                                      "outline_color", "red",
 476                                      "width_units", 2.0,
 477                                      NULL);
 478
 479           for (i = 0; i < display_act->pida->klass->nbins; i++) {
 480               if (count_max != 0) {
 481                   y_val = (double) display_act->pida->klass->count[i] / (double) count_max;
 482               } else {
 483                   y_val = 0.0;
 484               }
 485
 486               bar =
 487                    gnome_canvas_item_new(gnome_canvas_root
 488                                          (GNOME_CANVAS(valid->canvas_histo)),
 489                                          gnome_canvas_rect_get_type(),
 490                                          "x1", canvas_x1 +
 491                                          (double) (d_width / display_act->pida->klass->nbins * i),
 492                                          "y1", canvas_y1 -
 493                                          (double) d_height * y_val,
 494                                          "x2", canvas_x1 +
 495                                          (double)  (d_width/ display_act->pida->klass->nbins * (i+1)),
 496                                          "y2", canvas_y1,
 497                                          "fill_color", "yellow",
 498                                          "outline_color", "blue",
 499                                          "width_units", 2.0,
 500                                          NULL);
 501
 502
 503           }
 504
 505 /*           gpiv_free_bindata(display_act->pida->klass); */
 506          display_act->pida->exist_histo = TRUE;
 507          display_act->pida->saved_histo = FALSE;
 508          exec_process = FALSE;
 509
 510      } else {
 511           warning_gpiv(_("no PIV data"));
 512      }
 513
 514 }
 515
 516
 517
 518 /*
 519  * Piv validation window/tabulator callbacks
 520  */
 521
 522 void
 523 on_button_valid_gradient_enter (GtkWidget * widget,
 524                                 gpointer data
 525                                 )
 526 /*-----------------------------------------------------------------------------
 527  */
 528 {
 529     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 530     gchar *msg = _("Examines PIV data on velocity gradients");
 531     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 532
 533 }
 534
 535
 536
 537 void
 538 on_button_valid_gradient (GtkWidget * widget,
 539                           gpointer data)
 540 /*-----------------------------------------------------------------------------
 541  */
 542 {
 543     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 544     gint row, ibuf;
 545
 546     cancel_process = FALSE;
 547     if (nbufs > 0) {
 548         for (row = gpiv->first_selected_row; row <= gpiv->last_selected_row;
 549              row++) {
 550             display_act = gtk_clist_get_row_data (GTK_CLIST (gpiv->clist_buf),
 551                                                   row);
 552
 553             ibuf = display_act->id;
 554             if (display[ibuf] != NULL
 555                 && display_act->mwin != NULL
 556                 && GTK_WIDGET_VISIBLE (GTK_WIDGET (display_act->mwin)) ) {
 557                 gdk_window_show (GTK_WIDGET (display_act->mwin)->window);
 558                 gdk_window_raise (GTK_WIDGET (display_act->mwin)->window);
 559             }
 560
 561             exec_gradient ();
 562         }
 563     }
 564 }
 565
 566
 567
 568 void
 569 on_radiobutton_valid_disable_0_enter (GtkWidget * widget,
 570                                       gpointer data
 571                                       )
 572 /*-----------------------------------------------------------------------------
 573  */
 574 {
 575     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 576     gchar *msg = _("No mouse activity within displayer");
 577     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 578
 579 }
 580
 581
 582
 583 void
 584 on_radiobutton_valid_disable_1_enter (GtkWidget * widget,
 585                                       gpointer data
 586                                       )
 587 /*-----------------------------------------------------------------------------
 588  */
 589 {
 590     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 591     gchar *msg = _("Enables a single PIV data-point");
 592     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 593
 594 }
 595
 596
 597
 598 void
 599 on_radiobutton_valid_disable_2_enter (GtkWidget * widget,
 600                                       gpointer data
 601                                       )
 602 /*-----------------------------------------------------------------------------
 603  */
 604 {
 605     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 606     gchar *msg = _("Disables a single PIV data-point");
 607     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 608
 609 }
 610
 611
 612
 613 void
 614 on_radiobutton_valid_disable_3_enter (GtkWidget * widget,
 615                                       gpointer data
 616                                       )
 617 /*-----------------------------------------------------------------------------
 618  */
 619 {
 620     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 621     gchar *msg = _("Enables an area containing PIV data");
 622     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 623
 624 }
 625
 626
 627
 628 void
 629 on_radiobutton_valid_disable_4_enter (GtkWidget * widget,
 630                                       gpointer data
 631                                       )
 632 /*-----------------------------------------------------------------------------
 633  */
 634 {
 635     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 636     gchar *msg = _("Disables an area containing PIV data");
 637     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 638
 639 }
 640
 641
 642
 643 void
 644 on_radiobutton_valid_disable (GtkWidget * widget,
 645                               gpointer data
 646                               )
 647 /*-----------------------------------------------------------------------------
 648  */
 649 {
 650     m_select = atoi (gtk_object_get_data (GTK_OBJECT (widget),
 651                                           "mouse_select"));
 652 }
 653
 654
 655
 656 void
 657 on_radiobutton_valid_errvec_residu_enter (GtkWidget * widget,
 658                                           gpointer data
 659                                           )
 660 /*-----------------------------------------------------------------------------
 661  */
 662 {
 663     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 664     gchar *msg = _("Defines residu type to examine data on");
 665     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 666 }
 667
 668
 669
 670 void
 671 on_radiobutton_valid_errvec_residu (GtkWidget * widget,
 672                                     gpointer data
 673                                     )
 674 /*-----------------------------------------------------------------------------
 675  */
 676 {
 677     gl_valid_par->residu_type = atoi (gtk_object_get_data (GTK_OBJECT (widget),
 678                                                            "residu"));
 679 }
 680
 681
 682
 683 void
 684 on_button_valid_errvec_resstats_enter (GtkWidget * widget,
 685                                        gpointer data
 686                                        )
 687 /*-----------------------------------------------------------------------------
 688  */
 689 {
 690     GpivConsole * gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 691     gchar *msg = _("Displays inverse cumulative histogram of residus");
 692     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 693 }
 694
 695
 696
 697 void
 698 on_button_valid_errvec_resstats (GtkWidget * widget,
 699                                  gpointer data
 700                                  )
 701 /*-----------------------------------------------------------------------------
 702  */
 703 {
 704     PivValid * valid = gtk_object_get_data (GTK_OBJECT (widget), "valid");
 705     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 706     gint row, ibuf;
 707
 708     cancel_process = FALSE;
 709     gpiv_var->residu_stats = TRUE;
 710
 711     if (nbufs > 0) {
 712         for (row = gpiv->first_selected_row; row <= gpiv->last_selected_row;
 713              row++) {
 714             display_act = gtk_clist_get_row_data (GTK_CLIST (gpiv->clist_buf),
 715                                                   row);
 716
 717             ibuf = display_act->id;
 718             if (display[ibuf] != NULL
 719                 && display_act->mwin != NULL
 720                 && GTK_WIDGET_VISIBLE (GTK_WIDGET (display_act->mwin)) ) {
 721                 gdk_window_show (GTK_WIDGET (display_act->mwin)->window);
 722                 gdk_window_raise (GTK_WIDGET (display_act->mwin)->window);
 723             }
 724             exec_errvec (valid);
 725         }
 726
 727         gpiv_var->residu_stats = FALSE;
 728     }
 729 }
 730
 731
 732
 733 void
 734 on_spinbutton_valid_errvec_neighbors (GtkSpinButton *widget,
 735                                       GtkWidget *entry
 736                                       )
 737 /*-----------------------------------------------------------------------------
 738  */
 739 {
 740     gl_valid_par->neighbors  = gtk_spin_button_get_value_as_int (widget);
 741 }
 742
 743
 744
 745 void
 746 on_spinbutton_valid_errvec_yield (GtkSpinButton *widget,
 747                                   GtkWidget *entry
 748                                   )
 749 /*-----------------------------------------------------------------------------
 750  */
 751 {
 752     gl_valid_par->data_yield  = gtk_spin_button_get_value_as_float (widget);
 753 }
 754
 755
 756
 757 void
 758 on_spinbutton_valid_errvec_res (GtkSpinButton *widget,
 759                                 GtkWidget *entry
 760                                 )
 761 /*-----------------------------------------------------------------------------
 762  */
 763 {
 764     gl_valid_par->residu_max  = gtk_spin_button_get_value_as_float (widget);
 765     if (v_color == SHOW_SNR && display_act->pida->exist_piv) {
 766         update_all_vectors (display_act->pida);
 767     }
 768 }
 769
 770
 771
 772 void
 773 on_checkbutton_valid_errvec_disres_enter (GtkWidget * widget,
 774                                           gpointer data
 775                                           )
 776 /*-----------------------------------------------------------------------------
 777  */
 778 {
 779     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 780     gchar *msg = _("Display PIV vector colors related to residu or SNR value");
 781     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 782 }
 783
 784
 785
 786 void
 787 on_checkbutton_valid_errvec_disres (GtkSpinButton *widget,
 788                                     GtkWidget *entry
 789                                     )
 790 /*-----------------------------------------------------------------------------
 791  */
 792 {
 793     if (GTK_TOGGLE_BUTTON (widget)->active) {
 794         v_color = SHOW_SNR;
 795     } else {
 796         v_color = SHOW_PEAKNR;
 797     }
 798
 799
 800     if (display_act->pida->exist_piv && display_act->display_piv) {
 801         update_all_vectors (display_act->pida);
 802     }
 803 }
 804
 805
 806
 807 void
 808 on_radiobutton_valid_errvec_subst_enter (GtkWidget * widget,
 809                                          gpointer data
 810                                          )
 811 /*-----------------------------------------------------------------------------
 812  */
 813 {
 814     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 815     gchar *msg = NULL;
 816     gint ltype = atoi (gtk_object_get_data (GTK_OBJECT (widget), "substitute"));
 817
 818     if (ltype == GPIV_VALID_SUBSTYPE__NONE) {
 819         msg = _("Only sets peak_no (flag) to zero");
 820     } else if (ltype ==  GPIV_VALID_SUBSTYPE__L_MEAN) {
 821         msg = _("mean from surroundings");
 822     } else if (ltype ==  GPIV_VALID_SUBSTYPE__MEDIAN) {
 823         msg = _("Median (middle value) from surroundings");
 824     } else if (ltype ==  GPIV_VALID_SUBSTYPE__COR_PEAK) {
 825         msg = _("Re-interrogates and uses next corr. peak as estimator");
 826     } else {
 827         g_error ("NO valid ltype\n");
 828     }
 829
 830     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 831 }
 832
 833
 834
 835 void
 836 on_radiobutton_valid_errvec_subst (GtkWidget * widget,
 837                                    gpointer data
 838                                    )
 839 /*-----------------------------------------------------------------------------
 840  */
 841 {
 842     gl_valid_par->subst_type = atoi (gtk_object_get_data (GTK_OBJECT (widget),
 843                                                           "substitute"));
 844 }
 845
 846
 847
 848 void
 849 on_button_valid_errvec_enter (GtkWidget * widget,
 850                               gpointer data
 851                               )
 852 /*-----------------------------------------------------------------------------
 853  */
 854 {
 855     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 856     gchar *msg = _("Examines PIV data on outliers and substitutes");
 857     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 858 }
 859
 860
 861
 862 void
 863 on_button_valid_errvec (GtkWidget * widget,
 864                         gpointer data
 865                         )
 866 /*-----------------------------------------------------------------------------
 867  */
 868 {
 869     PivValid * valid = gtk_object_get_data (GTK_OBJECT (widget), "valid");
 870     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 871     gint row, ibuf;
 872
 873     cancel_process = FALSE;
 874     gpiv_var->residu_stats = FALSE;
 875
 876     if (nbufs > 0) {
 877         for (row = gpiv->first_selected_row; row <= gpiv->last_selected_row;
 878              row++) {
 879             display_act = gtk_clist_get_row_data (GTK_CLIST (gpiv->clist_buf),
 880                                                   row);
 881
 882             ibuf = display_act->id;
 883             if (display[ibuf] != NULL
 884                 && display_act->mwin != NULL
 885                 && GTK_WIDGET_VISIBLE (GTK_WIDGET (display_act->mwin)) ) {
 886                 gdk_window_show (GTK_WIDGET (display_act->mwin)->window);
 887                 gdk_window_raise (GTK_WIDGET (display_act->mwin)->window);
 888             }
 889
 890             exec_errvec (valid);
 891         }
 892     }
 893 }
 894
 895
 896
 897 void
 898 on_spinbutton_valid_peaklck_bins (GtkSpinButton * widget,
 899                                   GtkWidget * entry
 900                                   )
 901 /*-----------------------------------------------------------------------------
 902  */
 903 {
 904     gpiv_par->console__nbins = gtk_spin_button_get_value_as_int (widget);
 905 }
 906
 907
 908
 909
 910 void
 911 on_button_valid_peaklck_enter (GtkWidget * widget,
 912                                gpointer data
 913                                )
 914 /*-----------------------------------------------------------------------------
 915  */
 916 {
 917     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 918     gchar *msg = _("Calculates a histogram of sub-pixel displacements");
 919     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 920 }
 921
 922
 923
 924 void
 925 on_button_valid_peaklck (GtkWidget * widget,
 926                          gpointer data
 927                          )
 928 /*-----------------------------------------------------------------------------
 929  */
 930 {
 931     PivValid * valid = gtk_object_get_data (GTK_OBJECT (widget), "valid");
 932     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 933     gint row, ibuf;
 934
 935     cancel_process = FALSE;
 936     if (nbufs > 0) {
 937         for (row = gpiv->first_selected_row; row <= gpiv->last_selected_row;
 938              row++) {
 939             display_act = gtk_clist_get_row_data (GTK_CLIST (gpiv->clist_buf),
 940                                                   row);
 941
 942             ibuf = display_act->id;
 943             if (display[ibuf] != NULL
 944                 && display_act->mwin != NULL
 945                 && GTK_WIDGET_VISIBLE (GTK_WIDGET (display_act->mwin)) ) {
 946                 gdk_window_show (GTK_WIDGET (display_act->mwin)->window);
 947                 gdk_window_raise (GTK_WIDGET (display_act->mwin)->window);
 948             }
 949
 950             exec_peaklock (valid);
 951         }
 952     }
 953 }
 954
 955
 956
 957 void
 958 on_button_valid_uhisto_enter (GtkWidget * widget,
 959                               gpointer data
 960                               )
 961 /*-----------------------------------------------------------------------------
 962  */
 963 {
 964     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 965     gchar *msg = _ ("Calculates a histogram of horizontal displacements.");
 966     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
 967 }
 968
 969
 970
 971 void
 972 on_button_valid_uhisto (GtkWidget * widget,
 973                         gpointer data
 974                         )
 975 /*-----------------------------------------------------------------------------
 976  */
 977 {
 978     PivValid * valid = gtk_object_get_data (GTK_OBJECT (widget), "valid");
 979     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 980     gint row, ibuf;
 981
 982     cancel_process = FALSE;
 983     if (nbufs > 0) {
 984         for (row = gpiv->first_selected_row; row <= gpiv->last_selected_row;
 985              row++) {
 986             display_act = gtk_clist_get_row_data (GTK_CLIST (gpiv->clist_buf),
 987                                                   row);
 988
 989             ibuf = display_act->id;
 990             if (display[ibuf] != NULL
 991                 && display_act->mwin != NULL
 992                 && GTK_WIDGET_VISIBLE (GTK_WIDGET (display_act->mwin)) ) {
 993                 gdk_window_show (GTK_WIDGET (display_act->mwin)->window);
 994                 gdk_window_raise (GTK_WIDGET (display_act->mwin)->window);
 995             }
 996
 997             exec_uvhisto (valid, GPIV_U);
 998         }
 999     }
1000 }
1001
1002
1003
1004 void
1005 on_button_valid_vhisto_enter (GtkWidget * widget,
1006                               gpointer data
1007                               )
1008 /*-----------------------------------------------------------------------------
1009  */
1010 {
1011     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
1012     gchar *msg = _("Calculates a histogram of vertical displacements.");
1013     gnome_appbar_set_status (GNOME_APPBAR (gpiv->appbar), msg);
1014 }
1015
1016
1017
1018 void
1019 on_button_valid_vhisto (GtkWidget * widget,
1020                         gpointer data
1021                         )
1022 /*-----------------------------------------------------------------------------
1023  */
1024 {
1025     PivValid * valid = gtk_object_get_data (GTK_OBJECT (widget), "valid");
1026     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
1027     gint row, ibuf;
1028
1029     cancel_process = FALSE;
1030     if (nbufs > 0) {
1031         for (row = gpiv->first_selected_row; row <= gpiv->last_selected_row;
1032              row++) {
1033             display_act = gtk_clist_get_row_data (GTK_CLIST (gpiv->clist_buf),
1034                                                   row);
1035
1036             ibuf = display_act->id;
1037             if (display[ibuf] != NULL
1038                 && display_act->mwin != NULL
1039                 && GTK_WIDGET_VISIBLE (GTK_WIDGET (display_act->mwin)) ) {
1040                 gdk_window_show (GTK_WIDGET (display_act->mwin)->window);
1041                 gdk_window_raise (GTK_WIDGET (display_act->mwin)->window);
1042             }
1043
1044             exec_uvhisto (valid, GPIV_V);
1045         }
1046     }
1047 }