Updated with options and some other things to get a usable binary
authorAnders Henja <anders@henjab.se>
Mon, 19 Feb 2018 21:33:55 +0000 (22:33 +0100)
committerAnders Henja <anders@henjab.se>
Mon, 19 Feb 2018 21:33:55 +0000 (22:33 +0100)
bin/wrwp_main.c
lib/wrwp.c
lib/wrwp.h

index adba623..77af222 100644 (file)
@@ -16,6 +16,87 @@ along with HLHDF.  If not, see <http://www.gnu.org/licenses/>.
 ------------------------------------------------------------------------*/
 #include "wrwp.h"
 #include "rave_debug.h"
+#include <getopt.h>
+#include <libgen.h>
+
+static void PrintUsage(char* name, int full)
+{
+  char* namecopy = RAVE_STRDUP(name);
+
+  printf("Usage: %s [options] <input volume.h5> <output verticalprofile.h5>\n", basename(namecopy));
+
+  if (full) {
+    printf("--help             - Prints this output\n");
+    printf("--verbose          - Produces some information about the generated product\n");
+    printf("--debug            - Produces some debug information during the generation\n");
+    printf("--dz=<value>       - Height interval for deriving a profile [m] (default: %d)\n", DZ);
+    printf("--nodata=<value>   - Nodata value (default: %d)\n", NODATA_VP);
+    printf("--undetect=<value> - Undetect value (default: %d)\n", UNDETECT_VP);
+    printf("--gain=<value>     - Gain value (default: %f)\n", GAIN_VP);
+    printf("--offset=<value>   - Offset value (default: %f)\n", OFFSET_VP);
+    printf("--hmax=<value>     - Maximum height of the profile [m] (default: %d)\n", HMAX);
+    printf("--dmin=<value>     - Minimum distance for deriving a profile [m] (default: %d)\n", DMIN);
+    printf("--dmax=<value>     - Maximum distance for deriving a profile [m] (default: %d)\n", DMAX);
+    printf("--emin=<value>     - Minimum elevation angle [deg] (default: %f)\n", EMIN);
+    printf("--vmin=<value>     - Radial velocity threshold [m/s] (default: %f)\n", VMIN);
+    printf("\n");
+    printf("<input volume.h>  must be a polar volume in ODIM H5 format\n");
+    printf("<output verticalprofile.h5> will be a vertical profile in ODIM H5 format");
+  }
+
+  RAVE_FREE(namecopy);
+}
+
+/**
+ * Tries to translate an string into an int value.
+ * @param[in] arg - the argument
+ * @param[in,out] pInt - the outvalue
+ * @return 1 on success otherwise 0
+ */
+int ParseInt(char* arg, int* pInt)
+{
+  if (arg != NULL) {
+    int i = 0;
+    while (arg[i] != '\0') {
+      if (arg[i] < '0' || arg[i] > '9') {
+        return 0;
+      }
+      i++;
+    }
+  }
+  if (arg != NULL && pInt != NULL && sscanf(arg, "%d",pInt) == 1) {
+    return 1;
+  }
+  return 0;
+}
+
+/**
+ * Tries to translate an string into an int value.
+ * @param[in] arg - the argument
+ * @param[in,out] pDouble - the outvalue
+ * @return 1 on success otherwise 0
+ */
+int ParseDouble(char* arg, double* pDouble)
+{
+  if (arg != NULL) {
+    int i = 0;
+    int nrDots = 0;
+    while (arg[i] != '\0') {
+      if (arg[i] < '0' || arg[i] > '9') {
+        if (arg[i] == '.' && nrDots==0) {
+          nrDots++;
+        } else {
+          return 0;
+        }
+      }
+      i++;
+    }
+  }
+  if (arg != NULL && pDouble != NULL && sscanf(arg, "%lf",pDouble) == 1) {
+    return 1;
+  }
+  return 0;
+}
 
 /** Main function for deriving weather radar wind and reflectivity profiles
  * @file
@@ -28,18 +109,158 @@ int main (int argc,char *argv[]) {
        VerticalProfile_t* result = NULL;
        Wrwp_t* wrwp = NULL;
        int exitcode = 127;
+       char* inputfile = NULL; /* do not delete */
+       char* outputfile = NULL; /* do not delete */
+
+       int verbose_flag=0;
+       int debug_flag=0;
+       int help_flag=0;
+       int dz_value = DZ;
+       int nodata_vp = NODATA_VP;
+       int undetect_vp = UNDETECT_VP;
+       double gain_vp = GAIN_VP;
+       double offset_vp = OFFSET_VP;
+       int hmax = HMAX;
+       int dmin = DMIN;
+       int dmax = DMAX;
+       double emin = EMIN;
+       double vmin = VMIN;
+
+       int getopt_ret, option_index;
+
+       struct option long_options[] = {
+           {"help", no_argument, &help_flag, 1},
+           {"verbose", no_argument, &verbose_flag, 1},
+      {"debug", no_argument, &debug_flag, 1},
+           {"dz", optional_argument, 0, 'z'},
+           {"nodata", optional_argument, 0, 'n'},
+           {"undetect", optional_argument, 0, 'u'},
+      {"gain", optional_argument, 0, 'g'},
+      {"offset", optional_argument, 0, 'o'},
+      {"hmax", optional_argument, 0, 'h'},
+      {"dmin", optional_argument, 0, 'd'},
+      {"dmax", optional_argument, 0, 'D'},
+      {"emin", optional_argument, 0, 'e'},
+      {"vmin", optional_argument, 0, 'v'},
+           {0, 0, 0, 0}
+       };
+
 
        Rave_initializeDebugger();
-       Rave_setDebugLevel(RAVE_DEBUG);
+       Rave_setDebugLevel(RAVE_INFO);
+
+  while (1) {
+      getopt_ret = getopt_long( argc, argv, "",
+                                long_options,  &option_index);
+      if (getopt_ret == -1) break;
+      if (help_flag) {
+        PrintUsage(argv[0], 1);
+        exitcode=1;
+        goto done;
+      }
+      if (verbose_flag) {
+        Rave_setDebugLevel(RAVE_DEBUG);
+      }
+
+      switch(getopt_ret) {
+      case 0:
+        /* Here all non named options will arrive */
+        /*printf("option %s\n", long_options[option_index].name);*/
+        break;
+      case 'z':
+        if (!ParseInt(optarg, &dz_value)) {
+          fprintf(stderr, "--dz=<value> must be an integer value\n");
+          PrintUsage(argv[0], 0);
+          goto done;
+        }
+        break;
+      case 'n':
+        if (!ParseInt(optarg, &nodata_vp)) {
+          fprintf(stderr, "--nodata=<value> must be an integer value\n");
+          PrintUsage(argv[0], 0);
+          goto done;
+        }
+        break;
+      case 'u':
+        if (!ParseInt(optarg, &undetect_vp)) {
+          fprintf(stderr, "--undetect=<value> must be an integer value\n");
+          PrintUsage(argv[0], 0);
+          goto done;
+        }
+        break;
+      case 'g':
+        if (!ParseDouble(optarg, &gain_vp)) {
+          fprintf(stderr, "--gain=<value> must be a double value\n");
+          PrintUsage(argv[0], 0);
+          goto done;
+        }
+        break;
+      case 'o':
+        if (!ParseDouble(optarg, &offset_vp)) {
+          fprintf(stderr, "--offset=<value> must be a double value\n");
+          PrintUsage(argv[0], 0);
+          goto done;
+        }
+        break;
+      case 'h':
+        if (!ParseInt(optarg, &hmax)) {
+          fprintf(stderr, "--hmax=<value> must be an integer value\n");
+          PrintUsage(argv[0], 0);
+          goto done;
+        }
+        break;
+      case 'd':
+        if (!ParseInt(optarg, &dmin)) {
+          fprintf(stderr, "--dmin=<value> must be an integer value\n");
+          PrintUsage(argv[0], 0);
+          goto done;
+        }
+        break;
+      case 'D':
+        if (!ParseInt(optarg, &dmax)) {
+          fprintf(stderr, "--dmax=<value> must be an integer value\n");
+          PrintUsage(argv[0], 0);
+          goto done;
+        }
+        break;
+      case 'e':
+        if (!ParseDouble(optarg, &emin)) {
+          fprintf(stderr, "--emin=<value> must be a double value\n");
+          PrintUsage(argv[0], 0);
+          goto done;
+        }
+        break;
+      case 'v':
+        if (!ParseDouble(optarg, &vmin)) {
+          fprintf(stderr, "--vmin=<value> must be a double value\n");
+          PrintUsage(argv[0], 0);
+          goto done;
+        }
+        break;
+      case '?':
+      default:
+        fprintf(stderr, "Unknown argument\n");
+        PrintUsage(argv[0], 0);
+        break;
+      }
+  }
+
+  if (argc - optind != 2) {
+    PrintUsage(argv[0], 0);
+    goto done;
+  }
 
-       if (argc<3) {
+  inputfile=argv[optind++];
+  outputfile=argv[optind++];
+
+  if (argc<3) {
                printf ("Usage: %s <input ODIM_H5 polar volume> <output ODIM_H5 polar volume> \n",argv[0]);
                exit (1);
        }
 
-       raveio = RaveIO_open(argv[1]);
+       raveio = RaveIO_open(inputfile);
        if (raveio == NULL) {
-         fprintf(stderr, "Failed to open file = %s\n", argv[1]);
+         fprintf(stderr, "Failed to open file = %s\n", inputfile);
          goto done;
        }
 
@@ -49,6 +270,17 @@ int main (int argc,char *argv[]) {
          goto done;
        }
 
+       Wrwp_setDZ(wrwp, dz_value);
+       Wrwp_setNODATA_VP(wrwp, nodata_vp);
+       Wrwp_setUNDETECT_VP(wrwp, undetect_vp);
+       Wrwp_setOFFSET_VP(wrwp, offset_vp);
+       Wrwp_setGAIN_VP(wrwp, gain_vp);
+       Wrwp_setHMAX(wrwp, hmax);
+       Wrwp_setDMIN(wrwp, dmin);
+       Wrwp_setDMAX(wrwp, dmax);
+       Wrwp_setEMIN(wrwp, emin);
+       Wrwp_setVMIN(wrwp, vmin);
+
        /*Opening of HDF5 radar input file.*/
        if (RaveIO_getObjectType(raveio)== Rave_ObjectType_PVOL) {
                inobj = (PolarVolume_t*)RaveIO_getObject(raveio);
@@ -62,14 +294,30 @@ int main (int argc,char *argv[]) {
        result = Wrwp_generate(wrwp, inobj, NULL);
        if (inobj == NULL) {
                printf ("Could not derive wind profile %s, exiting ...\n", argv[1]);
-               exit (1);
+               goto done;
        }
 
        RaveIO_setObject(raveio, (RaveCoreObject*)result);
 
-       if (!RaveIO_save(raveio, argv[2]))
+       if (!RaveIO_save(raveio, outputfile))
          goto done;
 
+  if (debug_flag) {
+    printf("Generated vertical profile...\n");
+    printf("Input file: %s\n", inputfile);
+    printf("Output file: %s\n", outputfile);
+    printf("DZ         = %d\n", Wrwp_getDZ(wrwp));
+    printf("NODATA     = %d\n", Wrwp_getNODATA_VP(wrwp));
+    printf("UNDETECT   = %d\n", Wrwp_getUNDETECT_VP(wrwp));
+    printf("GAIN       = %lf\n", Wrwp_getGAIN_VP(wrwp));
+    printf("OFFSET     = %lf\n", Wrwp_getOFFSET_VP(wrwp));
+    printf("HMAX       = %d\n", Wrwp_getHMAX(wrwp));
+    printf("DMIN       = %d\n", Wrwp_getDMIN(wrwp));
+    printf("DMAX       = %d\n", Wrwp_getDMAX(wrwp));
+    printf("EMIN       = %lf\n", Wrwp_getEMIN(wrwp));
+    printf("VMIN       = %lf\n", Wrwp_getVMIN(wrwp));
+  }
+
        exitcode = 0;
 done:
        RAVE_OBJECT_RELEASE(raveio);
index bd9dbc2..91d7283 100644 (file)
@@ -263,25 +263,25 @@ int Wrwp_getUNDETECT_VP(Wrwp_t* self)
   return self->undetect_VP;
 }
 
-void Wrwp_setGAIN_VP(Wrwp_t* self, int gain_VP)
+void Wrwp_setGAIN_VP(Wrwp_t* self, double gain_VP)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   self->gain_VP = gain_VP;
 }
 
-int Wrwp_getGAIN_VP(Wrwp_t* self)
+double Wrwp_getGAIN_VP(Wrwp_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return self->gain_VP;
 }
 
-void Wrwp_setOFFSET_VP(Wrwp_t* self, int offset_VP)
+void Wrwp_setOFFSET_VP(Wrwp_t* self, double offset_VP)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   self->offset_VP = offset_VP;
 }
 
-int Wrwp_getOFFSET_VP(Wrwp_t* self)
+double Wrwp_getOFFSET_VP(Wrwp_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return self->offset_VP;
@@ -675,6 +675,7 @@ VerticalProfile_t* Wrwp_generate(Wrwp_t* self, PolarVolume_t* inobj, const char*
 
   result = RAVE_OBJECT_NEW(&VerticalProfile_TYPE);
   if (result != NULL) {
+    VerticalProfile_setLevels(result, ysize);
     if ((uwnd_field != NULL && !VerticalProfile_setUWND(result, uwnd_field)) ||
         (vwnd_field != NULL && !VerticalProfile_setVWND(result, vwnd_field)) ||
         (nv_field != NULL && !VerticalProfile_setNV(result, nv_field)) ||
@@ -693,7 +694,6 @@ VerticalProfile_t* Wrwp_generate(Wrwp_t* self, PolarVolume_t* inobj, const char*
   VerticalProfile_setHeight(result, PolarVolume_getHeight(inobj));
   VerticalProfile_setSource(result, PolarVolume_getSource(inobj));
   VerticalProfile_setInterval(result, self->dz);
-  VerticalProfile_setLevels(result, ysize);
   VerticalProfile_setMinheight(result, 0);
   VerticalProfile_setMaxheight(result, self->hmax);
   VerticalProfile_setDate(result, PolarVolume_getDate(inobj));
index e7c2a3a..d95f4b3 100644 (file)
@@ -123,28 +123,28 @@ void Wrwp_setUNDETECT_VP(Wrwp_t* self, int nodata_vp);
  * @param[in] self - self
  * @return the gain value
  */
-int Wrwp_getGAIN_VP(Wrwp_t* self);
+double Wrwp_getGAIN_VP(Wrwp_t* self);
 
 /**
  * Sets the gain value for the vertical profile
  * @param[in] self - self
  * @param[in] gain_VP - the gain value
  */
-void Wrwp_setGAIN_VP(Wrwp_t* self, int nodata_vp);
+void Wrwp_setGAIN_VP(Wrwp_t* self, double gain_vp);
 
 /**
  * Returns the offset value used for vertical profiles
  * @param[in] self - self
  * @return the offset value
  */
-int Wrwp_getOFFSET_VP(Wrwp_t* self);
+double Wrwp_getOFFSET_VP(Wrwp_t* self);
 
 /**
  * Sets the offset value for the profile
  * @param[in] self - self
  * @param[in] offset_VP - the offset value
  */
-void Wrwp_setOFFSET_VP(Wrwp_t* self, int nodata_vp);
+void Wrwp_setOFFSET_VP(Wrwp_t* self, double offset_vp);
 
 /**
  * Returns the height interval for deriving a profile [m]