qdImgRank.hpp

#ifndef QD_IMGRANK_HPP
#define QD_IMGRANK_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 imgDataRank {
      
    private :
      
      image::Image *rankImage;
      
    public :

      unsigned int rowstep;

      unsigned char *rankRawData;

      boost::numeric::ublas::matrix<bool> vMask;      
      
      imgDataRank (jafar::image::Image &img , unsigned int rRank=2, unsigned int rExclu=2, double cmThreshold=0.01) :
  vMask(img.height(),img.width())
      {
  JFR_PRECOND( img.depth()==8, "quasidense::imgdata::imgdata : image depth must be equal to 8 ");
  JFR_PRECOND( rRank<=7, "quasidense::ingDataRank::imgDataRank : 7 is the maximal radius tolarated by rank Transform");
  

  // Apply Rank Transform
  rankImage = img.rankTransform(rRank);
  rankRawData = rankImage->data();
  
  // Mask generation       
  unsigned int nbcol = img.width();
  unsigned int nbrow = img.height();
  double vmax1, vmax2, cstnormal = 1.0/255.0;
  
        jblas::mat diffv(nbrow,nbcol);
  jblas::mat diffh(nbrow,nbcol);
    
  
  rowstep = img.step();

  // Normalization, some initializations and confidence measure calculation
  //
  // 4 Steps : upper left corner / first row / first line / the rest
       
  vMask(0,0) = false;
  diffv(0,0) = 0.0;
  diffh(0,0) = 0.0;

  for (unsigned int cptr=1; cptr<nbrow;cptr++)
    {  
      vMask(cptr,0) = false;
      diffv(cptr,0) = cstnormal*fabs((double)rankRawData[cptr*rowstep]-(double)rankRawData[cptr*rowstep-rowstep]);
      diffh(cptr,0) = 0.0;
    }
  
  for (unsigned int cptc=1; cptc<nbcol;cptc++)
    {  
      vMask(0,cptc) = false;
      diffv(0,cptc) = 0.0;
      diffh(0,cptc) = cstnormal*fabs((double)rankRawData[cptc]-(double)rankRawData[cptc-1]);
    }
  
  unsigned int pos;
  for (unsigned int cptr = 1; cptr<nbrow; ++cptr)
    {
      pos = cptr*rowstep;
      {
        for (unsigned int cptc = 1; cptc<nbcol; ++cptc)
    {
      vMask(cptr,cptc) = false;
      diffv(cptr,cptc) = cstnormal*fabs((double)rankRawData[pos+cptc]-(double)rankRawData[pos-rowstep+cptc]);
      diffh(cptr,cptc) = cstnormal*fabs((double)rankRawData[pos+cptc]-(double)rankRawData[pos+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;        
      }  
  
      };
      
    }; // end of struct imgDataRank
    
    
    class imgPairRank {
      
      imgDataRank img1;
      
      imgDataRank img2;
      
      unsigned int rRank;
      
      unsigned int winwidth;
      
    public :
      imgPairRank (jafar::image::Image &img1_, jafar::image::Image &img2_, unsigned int rRank_=2, 
       unsigned int rExclu_=2, double cmThreshold_=0.01) : 
  img1(img1_, rRank_, rExclu_, cmThreshold_),
  img2(img2_, rRank_, rExclu_, cmThreshold_),
  rRank(rRank_),        
  winwidth(2*rRank_+1)       
      {  };      
      
      bool isPointValidinIma1 (int u, int v);
      bool isPointValidinIma2 (int u, int v);

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

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

}// end namespace jafar

#endif