cuiksmoothpath.c

Go to the documentation of this file.

#include "world.h"
#include "parameters.h"

#include "defines.h"
#include "error.h"
#include "filename.h"
#include "atlas.h"
#include "samples.h"
#include "random.h"

#include <stdlib.h>

int main(int argc, char **arg)
{
  TAtlasBase world;        /* The set of mechanism and obstacles.  */
  Tparameters parameters;  /* Parameters used in the Cuik process. */

  Tfilename fparam;
  Tfilename fpath;

  /* input path */
  unsigned int nvs,ns;
  double **path;

  /* smoothed path */
  unsigned int sns;
  double **spath;
  unsigned int mode;
  boolean parallel;
  unsigned int numIterations;

  unsigned int ri;
  time_t t;

  if (argc>=2)
    { 
      /*Init parameters*/
      CreateFileName(NULL,arg[1],NULL,PARAM_EXT,&fparam);
      InitParametersFromFile(GetFileFullName(&fparam),&parameters);
      fprintf(stderr,"Reading parameters from           : %s\n",GetFileFullName(&fparam));

      /*Read the world from file*/ 
      CS_WD_INIT(&parameters,arg[1],&world);

      t=time(NULL);  /* Get the time at which input files have been read */
      ri=(unsigned int)t;
      ri=1405498615;
      randomSet(ri);
      fprintf(stderr,"Random seed                       : %u\n",ri);

      mode=SMOOTH_SHORTCUT; 
      if (argc>=3)
        {
          /* Select the smoothing mode */
          switch(arg[2][0])
            {
            case 'G':
            case 'g':
              mode=SMOOTH_GRADIENT;
              break;
            case 'R':
            case 'r':
              mode=SMOOTH_RANDOM;
              break;
            case 'S':
            case 's':
              mode=SMOOTH_SHORTCUT;
              break;
            default:
              Error("Undefined smooth method");
            }
        }
      numIterations=2;
      if (argc>=4)
        numIterations=atoi(arg[3]);
      if (numIterations==0)
        numIterations=2;
      
      parallel=FALSE;
      if (argc>=5)
        parallel=atoi(arg[4]);

      CreateFileName(NULL,arg[1],"_path",SOL_EXT,&fpath);

      if (LoadSamples(fpath,&nvs,&ns,&path))
        {
          SmoothSamples(&parameters,parallel,mode,numIterations,ns,path,&sns,&spath,&world);

          SaveSamples(arg[1],TRUE,nvs,sns,spath);

          DeleteSamples(ns,path);
          DeleteSamples(sns,spath);
        }
      else
        Error("Could not read the input path file");

      DeleteParameters(&parameters);
      CS_WD_DELETE(&world);

      DeleteFileName(&fparam);
      DeleteFileName(&fpath);
    }
 else
   {
     fprintf(stderr,"  Wrong number of parameters.\n");
     fprintf(stderr,"  Use:\n");   
     fprintf(stderr,"      cuiksmoothpath <problem filename> <mode> <iterations> <parallel>\n");
     fprintf(stderr,"  where <problem filename> is the base name for the problem files.\n");
     fprintf(stderr,"        <mode> [optional] is the algorithm to use: RANDOM, GRADIENT, or SHORTCUT, The defatul is SHORTCUT.\n");
     fprintf(stderr,"        <itetarions> [optional] is the maximum number of iterations (scaled by the number of steps in the intput path). The default is 2.\n");
     fprintf(stderr,"        <parallel> [optional] 1 if the smooth has to be exectued in parallel. The default is 0.\n");
     
   }
  return(EXIT_SUCCESS);
}