CshapeFunction_global_image.h

Go to the documentation of this file.

/**********************************************************************
 * 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 CSHAPEFUNCTION_GLOBAL_IMAGE
#define CSHAPEFUNCTION_GLOBAL_IMAGE

#include "CshapeFunction_global_rigidBody.h"

template<typename T,typename Timg> 
class CshapeFunction_global_image : public CshapeFunction_global_rigidBody<T,Timg>
{
  
  public:

    std::vector<int> m_modImg;//name set of required modes 
    CImgList<T> m_img;//images list of modes m_img[list][x,y,z,dimensions]
    CImg<char> m_img_path;
    int m_dim_space, m_dim_mode;

    CshapeFunction_global_image() : CshapeFunction_global_rigidBody<T,Timg>()
    {// constructor

      this->class_name = "CshapeFunction_global_image";
      
    }
      
    virtual void init(CParameterNetCDF &fp)
    {//fill m_mods vector with the name of required modes from parameter.nc
      
      //look for the Rigid Body set of required modes.
      CshapeFunction_global_rigidBody<T,Timg>::init(fp);
      
      //identify the Homogeneous Deformation modes withins this->m_mods[] and store them within m_modHD[]
      m_modImg.clear();
      for (int i=0; i<this->m_mods.size(); i++)
      {
        
        if (this->m_mods[i].compare(0,8,"mode_img") == 0)
        {//mode list of images
          
          //load the image and mask directory path
          m_img_path.var_name = "mode_img";
          m_img_path.load(this->m_paramPath);
          m_dim_mode = m_img_path.depth();
          m_dim_space = m_img_path.height();

          
          std::string name; 
          std::ostringstream sample_index;
          this->m_mods.pop_back();
          
          for (int j=0; j<m_dim_mode; j++)
          {
            m_modImg.push_back(i+j);

            sample_index.width(2);
            sample_index.fill('0');
            sample_index << j;
            name = "Mimg_" + sample_index.str();
            this->m_mods.push_back(name);
            sample_index.str("");
            
          }
          this->m_dof = this->m_mods.size();
          
          if (this->m_verbose)
          {
            std::cout<<"\tmodes actualized : [ ";for (int i=0; i<this->m_mods.size(); i++){std::cout<<this->m_mods[i]<<" ";}std::cout<<"]\n";
            std::cout<<"\tmodes IMG : [ ";for (int i=0; i<m_modImg.size(); i++){std::cout<<m_modImg[i]<<" ";}std::cout<<"]\n";
          }
          
          CImg<T> tmp;
          tmp.load((std::string(m_img_path.get_shared_row(0,0))).c_str());
          
          m_img.assign(this->m_dim_mode, tmp.width(), tmp.height(), tmp.depth(), this->m_dim_space);

          cimglist_for(this->m_img,md)
          {// for image ref and def and eventually more
      
            for (int dim=0; dim<m_dim_space; dim++)
            {
              
              if (this->m_verbose){std::cout<<(std::string(m_img_path.get_shared_row(dim,md))).c_str()<<"\n";}
              
              tmp.load((std::string(m_img_path.get_shared_row(dim,md))).c_str());
              
              cimg_forXYZ(tmp, x,y,z)
              {
                m_img(md,x,y,z,dim) = tmp(x,y,z);
              }
              
            }
            
          }
          
        }
        
      }
      
    }
 
    virtual void exec(const CImg<Timg> &box, const std::vector<T> &x, CImgList<T> &N)
    {
      
      //RigidBody modes
      CshapeFunction_global_rigidBody<T,Timg>::exec(box, x, N);

      /* \todo warning ref = 0 doesn't works*/
      std::vector<double> X;
      X.assign(3,0);
      X[0] = (double)(x[0]+box.width()/2.)/((double)box.width()/(double)m_img[0].width());
      X[1] = (double)(x[1]+box.height()/2.)/((double)box.height()/(double)m_img[0].height());
      X[2] = (double)(x[2]+box.depth()/2)/((double)box.depth()/(double)m_img[0].depth());
      
//       std::cout<<x[0]<<" : "<<x[1]<<" : "<<x[2]<<"\n";
//       std::cout<<box.width()<<" : "<<box.height()<<" : "<<box.depth()<<"\n";
//       std::cout<<m_img[0].width()<<" : "<<m_img[0].height()<<" : "<<m_img[0].depth()<<"\n";
//       std::cout<<X[0]<<" : "<<X[1]<<" : "<<X[2]<<"\n\n\n";
//       
      cimglist_for(m_img, mode)
      {
        cimg_forC(m_img[0], dim)
        {
          N[dim][m_modImg[mode]] = m_img[mode].linear_atXYZC(X[0],X[1],X[2],dim);
        }
      }
      
    }
    
};

#endif