Cpeak_factory.h

/**********************************************************************
 * Copyright (C) 2012, The YaDICs Project Developers. 
 * See the COPYRIGHT file at the top-level directory of this distribution ./COPYRIGHT.
 * See ./COPYING file for copying and redistribution conditions.
 * 
 * This file is part of YaDICs.
 * YaDICs is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * YaDICs is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with YaDICs.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * Information about how to use the software are provided at http://yadic.univ-lille1.fr/
 **********************************************************************/


#ifndef CPEAK_FACTORY
#define CPEAK_FACTORY



//-----------------------------------------------------------------------
#include "Cpeak.h"
  #include "Cpeak_max.h"
  #include "Cpeak_subPix.h"  
//     #include "Cpeak_fit.h"
//       #include "Cpeak_fitP.h"
//       #include "Cpeak_fitG.h"
    #include "Cpeak_interpBiLin.h"
    #include "Cpeak_barycenter.h"
    #include "Cpeak_interp.h"
      #include "Cpeak_interpP.h"
      #include "Cpeak_interpG.h"
      
//-----------------------------------------------------------------------


template<typename T> 
class Cpeak_factory
{
  
  public:
    
  //attributes
  std::string class_name, m_peak_name, m_peak_type;
  std::vector<std::string> m_infos;
  
  const char* m_paramPath;
  bool m_verbose;
  

  Cpeak_factory(const std::string &peak_name)
  {
    
    m_peak_name = peak_name;
    class_name="Cpeak_factory";
    
    m_infos.push_back("max");
    m_infos.push_back("interpP");
    m_infos.push_back("interpG"); 
    m_infos.push_back("interpBiLin");
    m_infos.push_back("barycenter");
    
   }//constructor

  Cpeak<T>* create(int type)
  {
    
    Cpeak<T>* pPeak;
    
    switch(type)
    {
      case 0: pPeak = new Cpeak_max<T>; break;
      case 1: pPeak = new Cpeak_interpP<T>; break;
      case 2: pPeak = new Cpeak_interpG<T>; break;
      case 3: pPeak = new Cpeak_interpBiLin<T>; break;  
      case 4: pPeak = new Cpeak_barycenter<T>; break;   
      default:
      {
        std::cerr<<class_name<<"::"<<__func__<<": error: serial type="<<type<<" is unknown\n"<<std::flush;
        return NULL; break;
      }
    }
    
//     if (m_verbose){printf("%s -> %s class loaded\n",class_name.c_str(), m_peak_type.c_str());}
    
    pPeak->m_verbose = m_verbose;// active or not the verbose mode
  
    return pPeak;// return pointer to specific correlation method
    
  }//create
 
  Cpeak<T>* create(std::string type_name)
  {
      #if cimg_debug>1
      std::cerr<<class_name<<"::"<<__func__<<"(\""<<type_name<<"\")\n"<<std::flush;
      #endif
      if(type_name==m_infos[0]) return create(0);
      else if(type_name==m_infos[1]) return create(1);
      else if(type_name==m_infos[2]) return create(2);
      else if(type_name==m_infos[3]) return create(3);
      else if(type_name==m_infos[4]) return create(4);
      else
      {
        std::cerr<<class_name<<"::"<<__func__<<": error: grab type="<<type_name<<" not handled.\n"<<std::flush;
        return NULL;
      }
    }//create
    
  Cpeak<T>* create(CParameterNetCDF &paramFile)
  {//CDL e.g. parameter.nc
    
    //variable and attribute name
    std::string attribute;
    std::string peak_type="type";
    load_attribute(paramFile, peak_type, attribute);
    
    if (m_peak_type != "none")
    {
      attribute = m_peak_type;
    };
    
    m_peak_type = attribute;
    
    return create(attribute);
    
  }//create CParameterNetCDF
 
  Cpeak<T>* create(int argc, char *argv[])
  {
     
    //read command line argument
    commandLine(argc,argv);

    // pointer toward any mesh
    Cpeak<T> *ppeak;
    int error;
    
    if(m_paramPath!="true")
    {// parameter.nc or mesh.nc location is provided
    
      // open the file and keep the object in file variable
      NcFile file(m_paramPath,NcFile::ReadOnly);
      if(m_verbose){std::cout<<" --correlator file : "<<m_paramPath<<"\n";}

      // create a CParameterNetCDF object associated to already opened file
      CParameterNetCDF paramFile;
      if ( error = paramFile.setFile(&file) !=1 )
      {
        std::cerr<< "Error while loading"<<m_paramPath<<" parameter file"<<std::endl;
        return NULL;
      }

      // associate pmesh pointer to the appropriate one following parameter.nc attribute type
      ppeak = create(paramFile);
      
      if (ppeak == NULL){return NULL;}
      
      return ppeak;
    
    }
    else
    {// mesh_option = true
    
      std::cout<<" --mesh option : Command line\n";
      std::cout<<" --building!!\n";
      
      return NULL;
      
    }


    
  }//create (argv,argc)
  
  //other methods
  template<typename Tatt>
  int load_attribute(CParameterNetCDF &paramFile, std::string &attribute_name, Tatt &attribute)
  {
    
    //load attribute
    int error = paramFile.loadAttribute(attribute_name,attribute, &m_peak_name);
    
    return error;
    
  }//load_attribute_name from parameter.nc file
 
  bool is_parameter_file(NcFile &file)
  {
    
    NcVar* pVar;
    pVar = file.get_var(m_peak_name.c_str());
    
    return ((pVar->num_dims())==0);
    
  }
 
  void commandLine(int argc, char *argv[])
  {
    
    //set parameter file path
    m_paramPath = cimg_option("-p","./parameters.nc","parameter, mesh or true");
    //set verbose mode
    m_verbose = cimg_option("-v",false,0);
    
    if(m_verbose)
    {
      printf("Mode Verbose\n");
      printf("%s : %s\n",class_name.c_str(),m_paramPath);
    }
    
  }

  void stringSplit(std::string manyString, std::vector<std::string> value)
  {
    
    char *cstr,*ptr;
    char *split=(char*)(" ,;");
    
    cstr = new char [manyString.size()+1];
    strcpy(cstr,manyString.c_str());
    ptr=strtok(cstr,split);
    while (ptr!=NULL)
    {
      value.push_back(ptr);
      ptr=strtok(NULL,split);
    }
    delete[] cstr;
    
  }
  
  void info()
  {// print the whole set of available classes within the factory
    
    printf("\nclass %s\n",class_name.c_str());
    for (int i=0; i<m_infos.size(); i++)
    {
      
         printf("\t(%i) mode : %s\n",i,m_infos[i].c_str());
      
    }
    
  }
  

};//Cpeak_factory class


#endif //FACTORY