Csequence.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 CSEQUENCE
#define CSEQUENCE



//-----------------------------CIMG_NETCDF-------------------------------
#define cimg_plugin  "plugins/add_fileformat.h"
#define cimg_use_netcdf

#ifdef cimg_use_netcdf
 #include "../NetCDF.Tool/struct_parameter_NetCDF.h"
// #define     cimg_plugin1 "plugins/netcdf_file_format4CImg1.h"
// #define cimglist_plugin1 "plugins/netcdf_file_format4CImgList1.h"
 #define     cimg_plugin2 "plugins/netcdf_file_format4CImg2.h"
 #define cimglist_plugin2 "plugins/netcdf_file_format4CImgList2.h"
 #include "../CImg.Tool/CImg_NetCDF.h"
#endif
//-----------------------------CIMG_NETCDF-------------------------------


#include "Cimage.h"
#include "Cfield_factory.h"
#include "Cmesh_factory.h"
#include "CNpeak.h"
#include "CshapeFunction_factory.h"
#include "Ccorrelation_factory.h"

#include <unistd.h>

template<typename T,typename Timg> 
class Csequence
{
  
  public:
  
    std::string class_name;
    std::vector<std::string> m_sequence;
    std::vector<int> m_filter;
//     int m_reset;
    
    //mesh, field and correlation method associated to a specific sequence
    Cmesh<T,Timg>* m_pMesh;
    Ccorrelation<T,Timg>* m_pCorrel;
    Cfield<T,Timg>* m_pField;
    
    //ultimate results from a correlation sequence
    CImgList<T> m_modes, m_strain;
    CImgList<T> m_node;
    //optional
    CImgList<T> m_fields;
    CImg<T> m_residues, m_deformed, m_correlograms;
    CshapeFunction<T,Timg>* m_pShape;
    std::vector<T> m_ref, m_meanRes;

    bool m_verbose;
    

    Csequence()
    {// constructor

      class_name = "Sequence : mother";
    }
 
    void init(int argc, char *argv[])
    {// init

      //set parameter file path
      const char* paramPath;
      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(),paramPath);
      }

      NcFile file(paramPath,NcFile::ReadOnly);
      CParameterNetCDF paramFile;
      int error = paramFile.setFile(&file);

      std::string var_name = "sequence",
      att_name = "analysis";
      error = paramFile.loadAttribute(att_name,m_sequence, &var_name);
      if (this->m_verbose){std::cout<<"\tSequence analysis -> [ ";for (int i=0; i<m_sequence.size(); i++){std::cout<<m_sequence[i]<<" ";}std::cout<<"]\n";}

      att_name = "filter";//piramidal filter
      error = paramFile.loadAttribute(att_name,m_filter, &var_name);
      if (this->m_verbose){std::cout<<"\tPiramidal filter -> [ ";for (int i=0; i<m_filter.size(); i++){std::cout<<m_filter[i]<<" ";}std::cout<<"]\n";}

//       att_name = "reset";
//       error = paramFile.loadAttribute(att_name,m_reset, &var_name);
//       if (this->m_verbose){std::cout<<"\treset -> ["<<m_reset<<"]\n";}
      
      m_meanRes.clear();

    }

    
    int exec(int argc, char *argv[], Cimage<Timg> &oImage)
    {// implement a specific correlation sequence
      
      int error(0);
      
      for (int s=0; s<m_sequence.size(); s++)
      {

        printf("\n----------------------\nSequence : %i\n----------------------\n\n", s);

        preprocessing(argc, argv, s, oImage);

        processing(argc, argv, oImage, *m_pMesh, *m_pField, *m_pCorrel);

        postprocessing(s, oImage, *m_pField, *m_pCorrel, *m_pMesh);

      }

      return error;
      
    }
    

    void preprocessing(int argc, char *argv[], const int &s, Cimage<Timg> &oImage)
    {


      Cmesh_factory<T,Timg> mesh_factory(m_sequence[s].c_str());
      Cfield_factory<T,Timg> field_factory(m_sequence[s].c_str());
      Ccorrelation_factory<T,Timg> correlator_factory(m_sequence[s].c_str());

      
      if (m_verbose){printf("* Mesh preproc\n");}
      m_pMesh = mesh_factory.create(argc,argv);
      
      if (m_verbose){printf("* Field preproc\n");}
      m_pField = field_factory.create(argc,argv);
      
      if (m_verbose){printf("* Correlation preproc\n");}
      m_pCorrel = correlator_factory.create(argc,argv);
      
      if (m_verbose){cimg::tic();printf("* Image resizing for multiscale\n");}
      oImage.resize(m_filter[s]);
      if (m_verbose){cimg::toc();}
      
      printf("\n\n* Current scale : %f\n\n", std::pow(2,m_filter[s]));
      
    }

    int processing(int argc, char *argv[], Cimage<Timg> &oImage, Cmesh<T,Timg> &oMesh, Cfield<T,Timg> &oField, Ccorrelation<T,Timg> &oCorrel)
    {

      int error(0);

      //create mesh properties : m_node, m_connect and m_mask which contains
      if (m_verbose){printf("* Mesh proc\n");}
      oMesh.exec(oImage);
      
      if (m_verbose){printf("* Field proc\n");}
      oField.exec(oImage, oMesh, m_modes, *m_pShape, m_ref, m_node);//assign oField.m_field with m_dataField as init
      
      //store the current shape function object
      CshapeFunction_factory<T,Timg> shape_factory(oField.m_name.c_str());
      if (oField.m_name.compare(0,2,"IC") != 0)
      {
        m_pShape = shape_factory.create(argc,argv);
      }
      else
      {
        m_pShape = shape_factory.create(5);
      }
      
      if (m_verbose){cimg::tic();printf("* Correlation proc\n");}
      oCorrel.exec(oImage,oMesh,oField);//perform correlation
      if (m_verbose){cimg::toc();}

      return error;

    }
   
    void postprocessing(const int &s, Cimage<Timg> &oImage, Cfield<T,Timg> &oField, Ccorrelation<T,Timg> &oCorrel, Cmesh<T,Timg> &oMesh)
    {
      unsigned char color[] = {0};
    
      //store the current eigen values
      (oField.m_mode).move_to(m_modes);
      //store the current node table
      (oMesh.m_node).move_to(m_node);
  
      //store correlograms
      if (!oField.m_correlogram.is_empty()){(oField.m_correlogram).move_to(m_correlograms);}

      //store the current reference system
      m_ref = oField.m_ref;

      //convergency
//       for (int step=0; step<oField.m_meanRes.size(); step++)
//       {
//      m_meanRes.push_back(oField.m_meanRes[step]);
//       }
          
      if (s == m_sequence.size() - 1)
      {

        m_meanRes.push_back(oField.m_meanRes.back());
        
        if (!oField.m_field.is_empty())
        {(oField.m_field).move_to(m_fields);}
        if (!oField.m_res.is_empty())
        {(oField.m_res).move_to(m_residues);if(!oImage.m_curMask.is_empty()){m_residues.mul(oImage.m_curMask);}}
        if (!oField.m_def.is_empty())
        {(oField.m_def).move_to(m_deformed);if(!oImage.m_curMask.is_empty()){m_deformed.mul(oImage.m_curMask);}}
        
        if (!m_fields.is_empty())
        {
          cimglist_for(m_fields, var)
          {
             if(!oImage.m_curMask.is_empty()){m_fields[var].mul(oImage.m_curMask);}
          }
        }
     
      }

      //convert mesh location in physical units
      cimglist_for(m_node,dim){m_node[dim]*=oImage.m_pix[dim];}
      
      //clear pointers
      delete m_pMesh;
      delete m_pField;
      delete m_pCorrel;
      
    }  

    

};

#endif