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