qdMatches.hpp

#ifndef QD_MATCHES_HPP
#define QD_MATCHES_HPP

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

#include <math.h>

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


namespace jafar {

  namespace quasidense {

    struct pixel {
      
       int u;
       int v;
      
      pixel () :
  u(0),
  v(0)
      {};

      pixel ( int u_,  int v_):
  u(u_),
  v(v_)
      { };   
      
      pixel ( int *tab) :
  u(tab[0]),
  v(tab[1])
      {};
     
      pixel (const pixel &p)
      {
  u = p.u;
  v = p.v;
      };

      double normL1 ()
      {
  double du = (double)u, dv = (double)v;
  return(fabs(du)+fabs(dv));
      };
      
      double normL2 ()
      {
  double du = (double)u, dv = (double)v;
  return(sqrt(du*du+dv*dv));
      };
      
      double normInf ()
      {
  return(u>v?u:v);
      }

      pixel &operator+=(const pixel &pix)
      {
  u += pix.u;
  v += pix.v;
  return *this;
      }   
      
      pixel &operator-=(const pixel &pix)
      {
  u -= pix.u;
  v -= pix.v;
  return *this;
      }   
      
      pixel &operator=(const pixel &pix)
      {
  if (&pix!=this)
    {
      this->u = pix.u;
      this->v = pix.v;
    }
  return *this;
      }
      
      
    }; // end of struct pixel

    struct pixelmatch {
      
      pixel pix1;
      
      pixel pix2;

      double znccScore;     
      
      pixelmatch( int u1,  int v1,  int u2, int  v2, double score=0.0) :
  pix1(u1,v1),
  pix2(u2,v2),
  znccScore(score)
      {     };
      
      pixelmatch(pixel pix1_, pixel pix2_, double score=0.0) :
  pix1(pix1_),
  pix2(pix2_),
  znccScore(score)
      {      };

      double disparity ()
      {
  pixel ptmp(pix1.u-pix2.u,pix1.v-pix2.v);
  return ptmp.normL2();
      };
           
    }; // end of struct pixelmatch     

    std::ostream& operator <<(std::ostream& s, jafar::quasidense::pixelmatch const& pixmat);


    struct greaterSimilScore
    {
      bool operator()(const pixelmatch* match1, const pixelmatch* match2) const
      {    
  if (match1->znccScore >= match2->znccScore)
    return true;
  return false;  
      }
    };

  } // end of namespace quasidense

} // end of namespace jafar

#endif