Cimage.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 CIMAGE
#define CIMAGE

//-----------------------------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

#include "textcolor.h"
//-----------------------------CIMG_NETCDF-------------------------------


template<typename Timg> 
class Cimage
{
  
  public:

    std::string class_name;
    std::string m_name, m_type;
    
    CImgList<Timg> m_img, m_curImg;// img_ref and img_def as well as a shared or resized version
    CImg<char> m_mask, m_curMask;// store mask as well as a shared or resized version
    CImg<char> m_list;// store image path list
    
    std::vector<float> m_pix;// pixel ratio
    std::string m_maskName, m_dirPath; // paths
    int m_dim_sample, m_dim_image, m_dim;//number of image to correlate (classically 2), list size (n), image dimension (2 or 3)
    
    int m_storeImg, m_storeDef, m_storeRes, m_storeField, m_storeStr, m_storeActiv, m_display, m_mode;//store data & how to treat image sequence
    float m_Rpxmm;
    std::string m_oFormat;
    
    float m_res;
    
    bool m_verbose;
    const char* m_paramPath;
    
  
    Cimage()
    {// constructor
      
      class_name = "Image : mother";

    }    

    virtual void init(CParameterNetCDF &fp)
    {// image list parameters
      
      //dependent or separate mode
      std::string attribute_name = "mode";
      int error = fp.loadAttribute(attribute_name,m_mode);
      if (this->m_verbose){printf("\t\t separate list mode -> %i\n", m_mode);}
 
      float var(0);
      std::string m_variable = "output";
      
      //load output variable
      fp.loadVar(var,&m_variable);
      
      
      //output format
      attribute_name = "format";
      error = fp.loadAttribute(attribute_name,m_oFormat);
      if (this->m_verbose){printf("\t\t output file format -> %s\n", m_oFormat.c_str());}
      
      //display mode
      attribute_name = "display_mode";
      error = fp.loadAttribute(attribute_name,m_display);
      if (this->m_verbose){printf("\t\t display mode -> %i\n", m_display);}
      
      //save input data in netcdf
      attribute_name = "store_img";
      error = fp.loadAttribute(attribute_name,m_storeImg);
      if (this->m_verbose){printf("\t\t input data storage -> %i\n", m_storeImg);}
      
      //save corrected deformed image in netcdf
      attribute_name = "store_def";
      error = fp.loadAttribute(attribute_name,m_storeDef);
      if (this->m_verbose){printf("\t\t deformed image storage -> %i\n", m_storeDef);}
      
      //save corrected deformed image in netcdf
      attribute_name = "store_field";
      error = fp.loadAttribute(attribute_name,m_storeField);
      if (this->m_verbose){printf("\t\t field storage -> %i\n", m_storeField);}
      
      //save image residue in netcdf
      attribute_name = "store_res";
      error = fp.loadAttribute(attribute_name,m_storeRes);
      if (this->m_verbose){printf("\t\t image residue storage -> %i\n", m_storeRes);}
      
      m_storeActiv = 0; 
     
      if (m_storeRes or m_storeField or m_storeDef){m_storeActiv = 1;}
      
      //save image residue in netcdf
      attribute_name = "store_strain";
      error = fp.loadAttribute(attribute_name,m_storeStr);
      if (this->m_verbose){printf("\t\t strain field storage -> %i\n", m_storeStr);}
      
      //ratio pix mm
      m_Rpxmm = 1;
      attribute_name = "ratio_pxmm";
      error = fp.loadAttribute(attribute_name,m_Rpxmm);
      if (this->m_verbose){std::cout<<"\t\t ratio pix/mm -> "<<m_Rpxmm<<"\n";}

    }
     
    void exec(int argc, char *argv[], const int &sample = 0)
    {// exec

      load_images(m_list, m_dirPath, sample);
      if (m_maskName != ""){load_mask(m_maskName, m_dirPath);}

    }
  
  
    virtual void load_paths(CParameterNetCDF &fp) = 0;
    
    virtual void load_images(CImg<char> &list, std::string &dir, const int &sample) = 0;

    void load_mask(std::string &name, std::string &dir)
    {// load mask from path
    
      m_mask.load((dir + name).c_str());// load mask from path
      m_mask.channel(0);// enforce to use no color images
      m_mask.abs();
      m_mask.threshold(1);// enforce to use no color images
      m_mask.round(1,0);

      if (this->m_verbose){printf("\t mask : %s\n",(dir + name).c_str());}
      
    }
 
    void resize(const int &filter)
    {// resize init images to provides m_curImg if piramidal filter is active
    
      m_pix.clear();
      m_curImg.clear();
      m_curMask.clear();
      
      if (filter != 0)
      {
        
        int suElem = std::pow(2,filter);
        std::vector<int> X;
        
        for (int i=0; i<3; i++)
        {
          if (dim(i)>1){X.push_back(dim(i)/suElem);}else{X.push_back(1);}
          m_pix.push_back(((float)dim(i)/(float)X[i])*m_Rpxmm);
        }

        m_curImg.assign(m_img.size(), X[0], X[1], X[2], 1, 0);
        if (!m_mask.is_empty()){m_curMask.assign(X[0], X[1], X[2], 1, 1);}
/*
        cimglist_for(m_img, list)
        {// resizing with linear interpolation
          m_curImg[list] = m_img[list].get_resize(m_curImg[list],3);
        }
        if (!m_mask.is_empty()){m_curMask = m_mask.get_resize(m_curMask,3);}
        */
//      #pragma omp parallel if (num_dims()==3)
        #pragma omp parallel
        {
        
          int X(0), Y(0), Z(0);
          
          std::vector<double> buff0;
          double buff1(0), counter(0);
        
          #pragma omp for schedule(runtime)
          for (int pix=0; pix<m_curImg[0].size(); pix++)
          {
        
            m_curImg[0].contains(m_curImg[0][pix],X,Y,Z);
            
            buff0.assign(m_img.size(),0);
            buff1 = 0;
            counter = 0;
        
            for (int x=0; x<suElem; x++)
            {
              for (int y=0; y<suElem; y++)
              {
                for (int z=0; z<=(suElem-1)*(num_dims()-2); z++)
                {
                  
                  if (m_img[0].contains(m_img(0,X*suElem+x, Y*suElem+y, Z*suElem+z,0)))
                  {
                    
                    counter++;
                    
                    cimglist_for(m_img, list)
                    {// resizing with linear interpolation
                      buff0[list] += m_img(list, X*suElem+x, Y*suElem+y, Z*suElem+z);
                    }
                    
                    if (!m_mask.is_empty())
                    {buff1 += m_mask(X*suElem+x, Y*suElem+y, Z*suElem+z);}
                    
                  }//contains
                }//for z
              }//for y
            }//for x
            
            cimglist_for(m_curImg, list){m_curImg[list][pix] = buff0[list]/counter;}
            if (!m_mask.is_empty()){m_curMask[pix] = buff1/counter;}
            
          }//for super pixels
          
        }//parallele

      }
      else
      {
        
        m_curImg = m_img.get_shared();
        if (!m_mask.is_empty()){m_curMask = m_mask.get_shared();}
        
        for (int i=0; i<3; i++)
        {
          if (dim(i)>1){m_pix.push_back(m_Rpxmm);}else{m_pix.push_back(1);}
        }
        
      }
      
      
//       m_img.print();
//       m_curImg.print();
//       if (!m_mask.is_empty()){
//       m_mask.print();
//       m_curMask.print();}
      
      
      //reference residue between both images
      m_res = 0;
      for (int p=0; p<m_curImg[0].size(); p++)
      {m_res += std::pow((double)m_curImg[0][p]-(double)m_curImg[1][p],2);}
      m_res = std::sqrt(m_res);
      
      std::cout<<"\nreference residue at current scale : "<<m_res<<" in GL\n";
          
    }
  
  
    template<typename T>
    void save_netcdf(CImgList<T> &img, std::string name = "images", const int &sample = 0) const
    {// allow to stored any input CImgList<T>
      
      std::string path; 
      std::ostringstream sample_index;
      
      int n = std::floor(log10(img.size()) + 1);
      
      img.dim_names.clear();
      if (img[0].width() != 1 ){img.dim_names.push_back( "dimX" );}
      if (img[0].height() != 1 ){img.dim_names.push_back( "dimY" );}
      if (img[0].depth() != 1 ){img.dim_names.push_back( "dimZ" );}
      if (img[0].spectrum() != 1 ){img.dim_names.push_back( "dimC" );}
      
      img.var_names.clear();
      img.unit_names.clear();
      cimglist_for(img,L)
      {
        
        sample_index.width(n);
        sample_index.fill('0');
        sample_index << L;
        
        path = "Var_" + sample_index.str();
        
        img.var_names.push_back( path );
        img.unit_names.push_back( "none" );
        
        sample_index.str("");
        
      }
        
      std::string output_name = name + ".nc";
      
      save_unlimited(img, output_name, sample);
      
    }
    
    template<typename T>
    void save_netcdf(CImg<T> &img, std::string name = "images", const int sample = 0) const
    {// allow to stored any input CImg<T>
      
      img.dim_names.clear();
      if (img.width() != 1 ){img.dim_names.push_back( "dimX" );}
      if (img.height() != 1 ){img.dim_names.push_back( "dimY" );}
      if (img.depth() != 1 ){img.dim_names.push_back( "dimZ" );}
      if (img.spectrum() != 1 ){img.dim_names.push_back( "dimC" );}
      
      img.var_name = "Var";
      img.unit_name = "none";
      
      std::string output_name = name + ".nc";

      save_unlimited(img, output_name, sample);
      
    }
 
    template<typename T>
    void save_unlimited(CImgList<T> &imgOut, std::string &fileOut, const int &i) const
    {// add data along unlimited dimension depending on the sample number
      
      //save first
      #ifdef cimg_plugin1
        imgOut.save(fileOut.c_str());
      #else //cimg_plugin2
        if (imgOut[0].depth() == 1){// enforce z dimension
          imgOut.dim_names.push_back( "dummy_0" );}
        if (imgOut[0].spectrum() == 1){// enforce c dimension
          imgOut.dim_names.push_back( "dummy_1" );}
        imgOut.dim_time="dimS";// enfore dim_time
        if(i==0)
        {//save first
          imgOut.pNc_file=NULL;//should be in CImg constructors
          imgOut.NetCDF_init();
          imgOut.save(fileOut.c_str());
          imgOut.is_NetCDF_open=true;//should be in CImg::save_netcdf (but "const": save_netcdf(const char *filename) const)
        }//save first
        else
        {//save next
          imgOut.save(fileOut.c_str());
        }//save next
      #endif //cimg_plugin2
      
    }
 
    template<typename T>
    void save_unlimited(CImg<T> &imgOut, std::string &fileOut, const int &i) const
    {// add data along unlimited dimension depending on the sample number
      
      //save first
      #ifdef cimg_plugin1
        imgOut.save(fileOut.c_str());
      #else //cimg_plugin2
        if (imgOut.depth() == 1){// enforce z dimension
          imgOut.dim_names.push_back( "dummy_0" );}
        if (imgOut.spectrum() == 1){// enforce c dimension
          imgOut.dim_names.push_back( "dummy_1" );}
        imgOut.dim_time="dimS";// enfore dim_time
        if(i==0)
        {//save first
          imgOut.pNc_file=NULL;//should be in CImg constructors
          imgOut.NetCDF_init();
          imgOut.save(fileOut.c_str());
          imgOut.is_NetCDF_open=true;//should be in CImg::save_netcdf (but "const": save_netcdf(const char *filename) const)
        }//save first
        else
        {//save next
          imgOut.save(fileOut.c_str());
        }//save next
      #endif //cimg_plugin2
      
    }
 
 
  
    int num_var() const
    {// "num_var" provides the number of image to correlate
    
      return m_curImg.size();
      
    }  
    
    int cur_dim(const int &i) const
    {// provides spatial dimensions "X,Y,Z" and color channel dimension "C" of images to correlate
    
      switch(i)
      {
        case 0: return m_curImg[0].width(); break;
        case 1: return m_curImg[0].height(); break;
        case 2: return m_curImg[0].depth(); break;
        case 3: return m_curImg[0].spectrum(); break;
        default:
        {
          std::cerr<<class_name<<"::"<<__func__<<": error: id="<<i<<" is unknown as CImg dimensions\n"<<std::flush;
          return 0;
        }
      }
    }

    int dim(const int &i) const
    {// provides spatial dimensions "X,Y,Z" and color channel dimension "C" of images to correlate
    
      switch(i)
      {
        case 0: return m_img[0].width(); break;
        case 1: return m_img[0].height(); break;
        case 2: return m_img[0].depth(); break;
        case 3: return m_img[0].spectrum(); break;
        default:
        {
          std::cerr<<class_name<<"::"<<__func__<<": error: id="<<i<<" is unknown as CImg dimensions\n"<<std::flush;
          return 0;
        }
      }
    }

    int num_dims() const
    {// "num_dims" provides the number of active image dimensions
    
      return m_dim;
      
    } 
 
    int num_samples() const
    {// "num_samples" provides the number image within image list
    
      return m_dim_sample;
      
    } 

};

#endif