src/misc/piv2hdf.c

   1 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 c-style: "K&R" -*- */
   2
   3 /*---------------------------------------------------------------------------
   4
   5    piv2h5 - converts PIV data to hdf5 format data
   6
   7    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
   8    Gerber van der Graaf <gerber_graaf@users.sourceforge.net
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2, or (at your option)
  13    any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software Foundation,
  22    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23
  24 ------------------------------------------------------------------------*/
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <time.h>
  29 #include <gpiv.h>
  30
  31 /* #define PARFILE "scale.par"    */  /* Parameter file name */
  32 #define PARFILE "gpivrc"     /* Parameter file name */
  33 #define USAGE "\
  34 Usage: piv2hdf [-e] [-h | --help] [-i] [-p | --print] [-v | --version] \n\
  35                [-V | --verbose] filename \n\
  36 \n\
  37 keys: \n\
  38 -e:                    exclude data \n\
  39 -h | --help:           this on-line help \n\
  40 -i:                    includes image data \n\
  41 -p | --print:          print parameters to stdout \n\
  42 -v | --version:        version number \n\
  43 -V | --verbose:        program behaves more verbose \n\
  44 filename:              input PIV datafile, including .piv extension \n\
  45 "
  46
  47 #define HELP  "\
  48 piv2hdf - converts ASCII PIV-data and derived scalars to hdf5 formatted data"
  49
  50 #define RCSID "$Id: piv2hdf.c,v 1.12 2008-09-25 13:08:34 gerber Exp $"
  51
  52 gboolean print_par = FALSE,  verbose = FALSE, exclude_data = FALSE,
  53     include_image = FALSE;
  54
  55 void
  56 command_args(gint argc,
  57              gchar *argv[],
  58              gchar fname[GPIV_MAX_CHARS]
  59              )
  60 /*-----------------------------------------------------------------------------
  61  * Command line argument handling
  62  */
  63 {
  64     gchar c = '\0';
  65     gint argc_next;
  66
  67
  68     while (--argc > 0 && (*++argv)[0] == '-') {
  69
  70 /*
  71  * argc_next is set to 1 if the next cmd line argument has to be searched for;
  72  * in case that the command line argument concerns more than one char or cmd
  73  * line argument needs a parameter
  74  */
  75         argc_next = 0;
  76         while (argc_next == 0 && (c = *++argv[0]))
  77
  78             switch (c) {
  79             case 'v':
  80                 printf("%s\n", RCSID);
  81                 exit(0);
  82                 break;
  83             case 'V':
  84                 verbose = TRUE;
  85                 break;
  86             case 'e':
  87                 exclude_data = TRUE;
  88                 break;
  89             case 'h':
  90                 printf("%s\n", argv[0]);
  91                 printf("%s\n",HELP);
  92                 printf("%s\n",USAGE);
  93                 exit(0);
  94                 break;
  95             case 'i':
  96                 include_image = TRUE;
  97                 break;
  98             case 'p':
  99                 print_par = TRUE;
 100                 break;
 101
 102 /*
 103  * long option keys
 104  */
 105             case '-':
 106                 if (strcmp("-help", *argv) == 0) {
 107                     printf("\n%s", argv[0]);
 108                     printf("\n%s", HELP);
 109                     printf("\n%s", USAGE);
 110                     exit(0);
 111                 } else if (strcmp("-print", *argv) == 0) {
 112                     print_par = TRUE;
 113                 } else if (strcmp("-version", *argv) == 0) {
 114                     printf("%s\n", RCSID);
 115                     exit(0);
 116                 } else if (strcmp("-verbose", *argv) == 0) {
 117                     verbose = TRUE;
 118                 } else {
 119                     gpiv_error("%s: unknown option: %s", argv[0], *argv);
 120                 }
 121                 argc_next = 1;
 122                 break;
 123
 124             default:
 125                 gpiv_error(USAGE);
 126                 break;
 127             }
 128      }
 129
 130      if(argc != 1) {
 131           gpiv_error("%s: %s", argv[0], USAGE);
 132      }
 133      strcpy(fname, argv[0]);
 134
 135
 136 }
 137
 138
 139 gchar *
 140 make_fname(gchar *fname_in,
 141            gchar *fname_img,
 142            gchar *fname_vor,
 143            gchar *fname_nstrain,
 144            gchar *fname_sstrain,
 145            gchar *fname_out,
 146            gchar *fname_parameter
 147            )
 148 /*-----------------------------------------------------------------------------
 149  * generates filenames
 150  */
 151 {
 152     gchar *err_msg = NULL;
 153     gchar *fname_base = NULL;
 154
 155     if (fname_in == NULL ) {
 156         err_msg = "make_fname: \"fname_in == NULL\"";
 157         return (err_msg);
 158     }
 159
 160     /*
 161      * Stripping filename
 162      */
 163     fname_base = g_strdup(fname_in);
 164     strtok(fname_base, ".");
 165
 166     /*
 167      * filenames for output PIV data
 168      */
 169     if (include_image) {
 170         gpiv_io_make_fname(fname_base, GPIV_EXT_PNG_IMAGE, fname_img);
 171         if (verbose) printf("# Image data file: %s\n", fname_img);
 172     }
 173
 174     if (exclude_data == FALSE) {
 175
 176         gpiv_io_make_fname(fname_base, GPIV_EXT_VOR, fname_vor);
 177         if (verbose) printf("# Input data file: %s\n", fname_vor);
 178
 179         gpiv_io_make_fname(fname_base, GPIV_EXT_NSTR, fname_nstrain);
 180         if (verbose) printf("# Input data file: %s\n", fname_nstrain);
 181
 182         gpiv_io_make_fname(fname_base, GPIV_EXT_SSTR, fname_sstrain);
 183         if (verbose) printf("# Input data file: %s\n", fname_sstrain);
 184
 185     }
 186
 187     gpiv_io_make_fname(fname_base, GPIV_EXT_GPIV, fname_out);
 188     if (verbose) printf("# Output file: %s\n",fname_out);
 189
 190     gpiv_io_make_fname(fname_base, GPIV_EXT_PAR, fname_parameter);
 191
 192     g_free (fname_base);
 193     return (err_msg);
 194 }
 195
 196
 197
 198
 199
 200
 201
 202 int
 203 main(int argc,
 204      char *argv[]
 205      )
 206 /*-----------------------------------------------------------------------------
 207  * main routine to converts ASCII PIV-data to hdf5 formatted data
 208  */
 209 {
 210     gchar *err_msg = NULL;
 211     FILE *fp = NULL;
 212     gchar fname_piv[GPIV_MAX_CHARS],
 213         fname_out[GPIV_MAX_CHARS],
 214         fname_vor[GPIV_MAX_CHARS],
 215         fname_nstrain[GPIV_MAX_CHARS],
 216         fname_sstrain[GPIV_MAX_CHARS],
 217         fname_img[GPIV_MAX_CHARS],
 218         fname_parameter[GPIV_MAX_CHARS];
 219
 220 /*     time_t itime; */
 221 /*     gchar  c_line[GPIV_MAX_LINES_C][GPIV_MAX_CHARS]; */
 222 /*     gint nc_lines=0, var_scale=0; */
 223
 224     GpivPivPar *piv_par = g_new0 (GpivPivPar, 1);
 225     GpivValidPar *valid_par = g_new0 (GpivValidPar, 1);
 226     GpivPostPar *post_par = g_new0 (GpivPostPar, 1);
 227
 228     GpivImage *image = NULL;
 229     GpivPivData *piv_data = NULL;
 230     GpivScalarData *sc_data = NULL;
 231
 232     gboolean stored__post_par = FALSE;
 233
 234 /*
 235  * Initializing parameters
 236  */
 237     gpiv_piv_parameters_set(piv_par, FALSE);
 238     gpiv_valid_parameters_set(valid_par, FALSE);
 239     gpiv_post_parameters_set(post_par, FALSE);
 240
 241
 242     command_args(argc, argv, fname_piv);
 243     if ((err_msg =
 244          make_fname(fname_piv,  fname_img, fname_vor, fname_nstrain,
 245                     fname_sstrain, fname_out, fname_parameter))
 246         != NULL) {
 247         gpiv_error ("%s: %s\n", argv[0], err_msg);
 248     }
 249
 250 /*
 251  * Reads piv program parameters from fname_parameter
 252  */
 253     gpiv_scan_parameter (GPIV_PIVPAR_KEY, fname_parameter, piv_par,
 254                          print_par);
 255     gpiv_scan_parameter (GPIV_VALIDPAR_KEY, fname_parameter, valid_par,
 256                          print_par);
 257     gpiv_scan_parameter (GPIV_POSTPAR_KEY, fname_parameter, post_par,
 258                          print_par);
 259
 260 #undef USE_RESOURCES
 261 #ifdef USE_RESOURCES
 262     if ((err_msg =
 263          gpiv_scan_resourcefiles (GPIV_PIVPAR_KEY, piv_par, print_par))
 264         != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 265     if ((err_msg =
 266          gpiv_scan_resourcefiles (GPIV_VALIDPAR_KEY, valid_par, print_par))
 267         != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 268     if ((err_msg =
 269          gpiv_scan_resourcefiles (GPIV_POSTPAR_KEY, post_par, print_par))
 270         != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 271 #endif /* USE_RESOURCES */
 272
 273 /*
 274  * writing to output int hdf5
 275  */
 276     if ((err_msg = gpiv_fcreate_hdf5 (fname_out)) != NULL)  {
 277         gpiv_error ("%s: %s", argv[0], err_msg);
 278     }
 279
 280
 281 /*
 282  * Image
 283  */
 284     if (include_image) {
 285         if ((fp = fopen(fname_img, "r")) != NULL) {
 286             if ((image = gpiv_read_png_image (fp)) == NULL) {
 287                 fclose(fp);
 288                 gpiv_error ("%s: faling gpiv_read_png_image", argv[0]);
 289             }
 290             fclose(fp);
 291             fp = NULL;
 292
 293             if ((err_msg = gpiv_fwrite_hdf5_image (fname_out, image, TRUE))
 294                 != NULL) {
 295                 gpiv_error ("%s: %s", argv[0], err_msg);
 296             }
 297         }
 298     }
 299
 300
 301     if (exclude_data == FALSE) {
 302 /*
 303  * Piv data, PIV and validation parameters
 304  */
 305          if ((fp = fopen (fname_piv, "r")) != NULL) {
 306              if ((piv_data = gpiv_read_pivdata (fp)) == NULL) {
 307                 fclose(fp);
 308                 gpiv_error ("%s: faling gpiv_read_pivdata", argv[0]);
 309             }
 310             fclose(fp);
 311             fp = NULL;
 312
 313             if ((err_msg = gpiv_fwrite_hdf5_pivdata (fname_out, piv_data,  "PIV",
 314                                                      TRUE))
 315                 != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 316
 317
 318
 319              if (piv_par != NULL) {
 320                  if ((err_msg =
 321                       gpiv_piv_fwrite_hdf5_parameters (fname_out, piv_par))
 322                      != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 323              }
 324
 325              if (valid_par != NULL) {
 326                  if ((err_msg =
 327                       gpiv_valid_fwrite_hdf5_parameters (fname_out, valid_par))
 328                      != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 329              }
 330
 331          }
 332
 333 /*
 334  * Scalar data: vorticity
 335  */
 336          if ((fp = fopen (fname_vor, "r")) != NULL) {
 337              if ((sc_data = gpiv_read_scdata (fp)) == NULL) {
 338                  fclose(fp);
 339                  gpiv_error ("%s: faling gpiv_read_scdata", argv[0]);
 340              }
 341              fclose(fp);
 342              fp = NULL;
 343
 344              if ((err_msg = gpiv_fwrite_hdf5_scdata (fname_out, sc_data,
 345                                                      "VORTICITY", TRUE))
 346                  != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 347
 348
 349              if (post_par != NULL && stored__post_par == FALSE) {
 350                  stored__post_par = TRUE;
 351                  if ((err_msg =
 352                       gpiv_post_fwrite_hdf5_parameters (fname_out, post_par))
 353                      != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 354              }
 355          }
 356
 357 /*
 358  * Scalar data: sstrain
 359  */
 360          if ((fp = fopen (fname_sstrain, "r")) != NULL) {
 361
 362              if ((sc_data = gpiv_read_scdata (fp)) == NULL) {
 363                  fclose(fp);
 364                  gpiv_error ("%s: faling gpiv_read_scdata", argv[0]);
 365              }
 366              fclose(fp);
 367              fp = NULL;
 368
 369              if ((err_msg =
 370                   gpiv_fwrite_hdf5_scdata(fname_out, sc_data,
 371                                           "SHEAR_STRAIN", TRUE))
 372                 != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 373
 374              if (post_par != NULL && stored__post_par == FALSE) {
 375                  stored__post_par = TRUE;
 376                  if ((err_msg =
 377                       gpiv_post_fwrite_hdf5_parameters (fname_out, post_par))
 378                      != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 379              }
 380          }
 381
 382 /*
 383  * Scalar data: normal strain
 384  */
 385          if((fp=fopen(fname_nstrain, "r")) != NULL) {
 386              if ((sc_data = gpiv_read_scdata (fp)) == NULL) {
 387                  fclose(fp);
 388                  gpiv_error ("%s: faling gpiv_read_scdata", argv[0]);
 389              }
 390              fclose(fp);
 391              fp = NULL;
 392
 393
 394              if ((err_msg =
 395                   gpiv_fwrite_hdf5_scdata(fname_out, sc_data,
 396                                      "NORMAL_STRAIN", TRUE))
 397                  != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 398
 399              if (post_par != NULL && stored__post_par == FALSE) {
 400                  stored__post_par = TRUE;
 401                  if ((err_msg =
 402                       gpiv_post_fwrite_hdf5_parameters (fname_out, post_par))
 403                      != NULL)  gpiv_error ("%s: %s", argv[0], err_msg);
 404              }
 405          }
 406      }
 407
 408
 409     exit(0);
 410 }