qdImgZncc.hpp

#ifndef QD_IMGZNCC_HPP
#define QD_IMGZNCC_HPP

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>

#include <math.h>

#include "kernel/jafarMacro.hpp"
#include "jmath/jblas.hpp"
#include "image/Image.hpp"


namespace jafar {

  namespace quasidense {

    struct imgDataZncc {
           
      jblas::mat iNorm;

      boost::numeric::ublas::matrix<bool> vMask;
      
      jblas::mat iMean;
      
      jblas::mat isqMean;
      
    private :
      
      // Function used to produce 
      // image of intensity mean
      //
      //========================== 
      void lineprocess (jblas::mat &mat_in, unsigned int radius, jblas::mat &mat_out);            
      
    public :
      
      imgDataZncc (jafar::image::Image &img , unsigned int rZncc=2, unsigned int rExclu=2, double cmThreshold=0.01) :
  iNorm(img.height(),img.width()),
  vMask(img.height(),img.width()),
  iMean(img.height(),img.width()),
  isqMean(img.height(),img.width())
      {
  JFR_PRECOND( img.depth()==8, "quasidense::imgdata::imgdata : image depth must be equal to 8 ");
  
  unsigned int nbcol = img.width();
  unsigned int nbrow = img.height();

  double cstnormal = 1.0/255.0;
  double vmax1,vmax2;

  jblas::mat diffv(nbrow,nbcol);
  jblas::mat diffh(nbrow,nbcol);
  jblas::mat squaredintensity(nbrow,nbcol);
  jblas::mat mattmp(nbcol,nbrow);
    
  // Normalization, some initializations and confidence measure calculation
  //
  // 4 Steps : upper left corner / first row / first line / the rest
  
        iNorm(0,0) = cstnormal*double(img.getPixelValue<unsigned char>(0,0));
  vMask(0,0) = false;
  iMean(0,0) = 0.0;
  isqMean(0,0) = 0.0;
  diffv(0,0) = 0.0;
  diffh(0,0) = 0.0;

  for (unsigned int cptr=1; cptr<nbrow;cptr++)
    {  
      iNorm(cptr,0) = cstnormal*double(img.getPixelValue<unsigned char>(0,cptr));
      vMask(cptr,0) = false;
      iMean(cptr,0) = 0.0;
      isqMean(cptr,0) = 0.0;
      diffv(cptr,0) = fabs(iNorm(cptr,0)-iNorm(cptr-1,0));
      diffh(cptr,0) = 0.0;
    }
  
  for (unsigned int cptc=1; cptc<nbcol;cptc++)
    {  
      iNorm(0,cptc) = cstnormal*double(img.getPixelValue<unsigned char>(cptc,0));
      vMask(0,cptc) = false;
      iMean(0,cptc) = 0.0;
      isqMean(0,cptc) = 0.0;      
      diffv(0,cptc) = 0.0;
      diffh(0,cptc) = fabs(iNorm(0,cptc)-iNorm(0,cptc-1));
    }
  
  for (unsigned int cptr = 1; cptr<nbrow; ++cptr)
    for (unsigned int cptc = 1; cptc<nbcol; ++cptc)
      {
        iNorm(cptr,cptc) = cstnormal*double(img.getPixelValue<unsigned char>(cptc,cptr));
        vMask(cptr,cptc) = false;
        iMean(cptr,cptc) = 0.0;
        isqMean(cptr,cptc) = 0.0;
        diffv(cptr,cptc) = fabs(iNorm(cptr,cptc)-iNorm(cptr-1,cptc));
        diffh(cptr,cptc) = fabs(iNorm(cptr,cptc)-iNorm(cptr,cptc-1));
      }
  
        // Mask update
  // We exclude points too near of image sides
  for (unsigned int cptr=rExclu;cptr<(nbrow-rExclu);++cptr)
    for (unsigned int cptc=rExclu;cptc<(nbcol-rExclu);++cptc)
      {
        vmax1 = (diffv(cptr,cptc)<diffh(cptr,cptc))?diffh(cptr,cptc):diffv(cptr,cptc);
        vmax2 = (diffv(cptr+1,cptc)<diffh(cptr,cptc+1))?diffh(cptr,cptc+1):diffv(cptr+1,cptc);
        if ((vmax1>=cmThreshold)||(vmax2>=cmThreshold))
    vMask(cptr,cptc) = true;
        
      } 
  
  // Radiometry accumulation (mean of intensity)
  lineprocess(iNorm,rZncc,mattmp);
  lineprocess(mattmp,rZncc,iMean);
  
  // Radiometry accumulation (mean of squared intensity)
  squaredintensity = element_prod(iNorm,iNorm);
  lineprocess(squaredintensity,rZncc,mattmp);
  lineprocess(mattmp,rZncc,isqMean);

      };
      
    }; // end of struct imgDataZncc


 
      class imgPairZncc {
  
      imgDataZncc img1;
      
      imgDataZncc img2;
      
      unsigned int rZncc;
      
      unsigned int winwidth;
      
      double invNbPix;
      
    public :

      imgPairZncc (jafar::image::Image &img1_, jafar::image::Image &img2_, unsigned int rZncc_=2, 
       unsigned int rExclu_=2, double cmThreshold_=0.01) : 
  img1(img1_, rZncc_, rExclu_, cmThreshold_),
  img2(img2_, rZncc_, rExclu_, cmThreshold_),
  rZncc(rZncc_),        
  winwidth(2*rZncc+1),
  invNbPix(1.0/pow((double)winwidth,2.0))
      {  };      
      
      bool isPointValidinIma1 (int u, int v);
      bool isPointValidinIma2 (int u, int v);

      bool isMatchValid (int u1, int v1, int u2, int v2, unsigned int radius);
      bool isMatchValid (int u1, int v1, int u2, int v2);

      double matchEval (int u1, int v1, int u2, int v2, unsigned int radius);
      double matchEval (int u1, int v1, int u2, int v2);

      void confirmedMatch (int u1, int v1, int u2, int v2)
      {
  img1.vMask(v1,u1) = false;
  img2.vMask(v2,u2) = false;
      };
      
    }; // end of class imgPairZncc
            
  } // end namespace quasidense

}// end namespace jafar

#endif