cgh_scene.h

Go to the documentation of this file.

#ifndef CGH_SCENE_H
#define CGH_SCENE_H

#include <boost/numeric/ublas/vector.hpp>
#include <list>
#include <string>
#include <iostream>
#include <sstream>
#include "cgh.h"
#include "corner.h"
#include "property_image.h"
#include "canny_tool.h"
#include "corner_tool.h"
#include "cgh_wrapper.h"
#include "image_funcs.h"

namespace mimas {

template< typename T >
class cgh_scene: public object
{
 public:
  typedef boost::numeric::ublas::vector< double > Vector;
  typedef std::string string;
  typedef std::ostringstream ostringstream;
  typedef std::ofstream ofstream;
private:
    double      comparison_thres; 
    cgh_wrapper_ptr_list  cgh_list;   
    double      cgh_bin_thres;    

public:
    cgh_scene()
    {
  comparison_thres=0.75;
  cgh_bin_thres = 0.1;
    }

//     ~cgh_scene()
//     {
//  for(cgh_wrapper_ptr_list::iterator it=cgh_list.begin();
//        it!=cgh_list.end();++it)
//  {
//      cgh_wrapper *cw = (*it);

//      delete cw;
//  }

//     }

    void      setComparisonThreshold( double d )
    { comparison_thres = d; }

    void      setCGHBinThreshold( double d )
    { cgh_bin_thres = d; }


    cgh_wrapper_ptr_list getCGHList()
    {
  return &cgh_list;
    }

    void  createFromImage( image<T>& im )
    {
  createFromImage( im, 0 );
    }

    void  createFromImage( image<T>& im, double contrast_thres )
    {
  //extract edges and corners,
  //orient the edge strings and,
  //create a cgh from all corners

        canny_tool<int>   canny;
        edge_string_ptr_list edge_strings;

  //(1) first run canny to extract a set of string_el strings
        edge_strings=canny.findEdgeStrings( im );
        edge_string_op::filterWiggles( edge_strings, 0.2, 1, 35.0 );

//(1.5) contrast orient the strings?

  //(2) find the corners
        corner_image    cim;
  cim.init( im.getWidth(), im.getHeight() );
        corner_tool<int>  ctool(0.1);
        ctool.filterImage( im, cim );

  //(2.5) calculate the contrast threshold value. we could use
  //contrast values directly here, but it's very hard to just come up with
  //a number as they vary a lot. therefore, assume the given threshold value is
  //as a percentage of the max val;
  
  //(2.5b) ... new algo by stumeikle Wed 25 Sep 2002 21:10:01 CEST
  //we'll contrast order the corners and then attempt to find at least
  //100 from each image. actually we need to be able to accept a large
  //number of high contrast features so we'll allocate enough for 500
  double    contrast[500];
  corner_ptr crnrs[500];
  int   i,x,y;
  
  for(i=0;i<500;++i) {
     contrast[i]=0;
     // crnrs[i]=0;
   }
  
        for(y=0;y<cim.getHeight();++y)
        {
      for(x=0;x<cim.getWidth();++x)
      {
    if (cim.pixel(x,y))
    {
        double  c;
        corner_ptr crnr( boost::dynamic_pointer_cast< corner >
                              (cim.pixel(x,y) ) );
        
        c=crnr->getContrast();
        for (i=0;i<500;++i)
        {
      if (contrast[i]< c)
      {
        for(int j=499;j>i;j--)
        {
            contrast[j]=contrast[j-1];
            crnrs[j]=crnrs[j-1];
        }
        /*
        memcpy( &contrast[i+1],
          &contrast[i],
          sizeof(double)*(500-i-1) );
        memcpy( &crnrs[i+1],
          &crnrs[i],
          sizeof(corner*)*(500-i-1));
        */
          
          contrast[i]=c;
          crnrs[i]=crnr;

          break;
      }
        }
    }
      }
  } 


/*
  double  mv=0;
  int x,y,count=0,number=0;
        for(y=0;y<cim.getHeight();++y)
        {
      for(x=0;x<cim.getWidth();++x)
      {
    if (cim.getPixel(x,y))
    {
        corner  *crnr= ((corner*)(cim.getPixel(x,y)));
        if (crnr->getContrast() > mv)
        {
      mv = crnr->getContrast();
        }
    }
      }
  }

  mv*=contrast_thres;

  //----- this bit is purely for user info and can be removed entirely
  // if desired . stumeikle.
  if (info)
  {
        for(y=0;y<cim.getHeight();++y)
        {
      for(x=0;x<cim.getWidth();++x)
      {
    if (cim.getPixel(x,y))
    {
        corner  *crnr= ((corner*)(cim.getPixel(x,y)));
        if (crnr->getContrast() > mv)
        {
      number++;
        }
    }
      }
  }
  }
  //----- end of this bit

        //(3) find the corners and generate histograms
        for(y=0;y<cim.getHeight();++y)
        {
      for(x=0;x<cim.getWidth();++x)
      {
    if (cim.getPixel(x,y))
    {
        corner  *crnr= ((corner*)(cim.getPixel(x,y)));

        if (crnr->getContrast()<mv)
      continue;

        cgh *cgh = new cgh;

        cgh->setBinThreshold( cgh_bin_thres );
        cgh->createFromStrings( edge_strings,crnr->getPosition() );

        cgh_wrapper *cw = new cgh_wrapper;
        cw->cgh = cgh;
        cw->position = crnr->getPosition();
        cw->contrast = crnr->getContrast();

        cgh_list.push_back(cw);

        if (info)
      mm->Message() << "Created cgh number " << ++count << "("
              << number << ")" << std::endl;
    }
      }
        }
*/
#ifndef NDEBUG
   int count=0;
#endif
  for(i=0;i<500;++i)
  {
      if (crnrs[i]==0)  break;

      cgh_ptr c( new cgh );
      c->setBinThreshold( cgh_bin_thres );
      c->createFromStrings( edge_strings,crnrs[i]->getPosition() );

      cgh_wrapper_ptr cw( new cgh_wrapper );
      cw->cgh = c;
      cw->position = crnrs[i]->getPosition();
      cw->contrast = crnrs[i]->getContrast();

      cgh_list.push_back(cw);

#ifndef NDEBUG
       std::cerr << "Created cgh number " << ++count
                 << " contrast=" << cw->contrast
                 << " position=" << cw->position(0) << " "
                 << cw->position(1) << std::endl;
#endif
  }

        //(4) delete the strings
  //edge_string_ptr_list::iterator  sit;
  // for(sit=edge_strings.begin();sit!=edge_strings.end();++sit)
   // delete (*sit);
    }

    /*
    void  dumpAsPGMs( string basename ) ///< dump all generated cghs as .pgm files so they can be checked
    {
  //primarily for visual inspection -> the histograms are scaled and
  //the rest of the wrappers are ignored.
      cgh_wrapper_ptr_list::iterator  it;
  int       num=0;
  char        opfn[1024];

  for(it=cgh_list.begin();it!=cgh_list.end();++it)
  {
      string  name;
      int   n1,n2,n3,n;

      std::ostringstream    ss(opfn,1024);

      n = num;
      n1 = n%10;  n/=10;
      n2 = n%10;  n/=10;
      n3 = n;
      ss << basename << n3 << n2 << n1 << ".pgm" << std::ends;

      cgh *cgh = (*it)->cgh;
      cgh->scale(0,255);
      cgh->writeToFile( opfn, "PGM" );

      num++;
  }
    }*/

    /* void dumpAll( string basename )
    {
  //scrap this ?? Mon 10 Jun 2002 19:25:56 CEST
  //
   cgh_wrapper_ptr_list::iterator it;
  int       num=0;
  char        opfn[1024];

  for(it=cgh_list.begin();it!=cgh_list.end();++it)
  {
      string  name;
      int   n1,n2,n3,n;

      std::ostringstream      ss(opfn,1024);

      n = num;
      n1 = n%10;  n/=10;
      n2 = n%10;  n/=10;
      n3 = n;
      ss << basename << n3 << n2 << n1 << ".pgm" << std::ends;

      cgh *cgh = (*it)->cgh;
      cgh->scale(0,255);
      cgh->writeToFile( opfn, "PGM" );

      //now write out the wrapper details
      std::ostringstream      ss2(opfn,1024);
      ss2 << basename << n3 << n2 << n1 << ".info" << std::ends;

      ofstream      opf( opfn );

//      opf << "Name=" << (*it)->image_id << std::endl;
      opf << "Position=" << (*it)->position(0) << "," << (*it)->position(1) << std::endl;
      opf << "Contrast=" << (*it)->contrast << std::endl;

      opf.close();

      num++;
  }
    } */


    cgh_wrapper_ptr_list  crossCompare( cgh_scene& other )
    {
  cgh_wrapper_ptr_list::iterator  it;
  cgh_wrapper_ptr_list::iterator  oit;
  cgh_wrapper_ptr_list output;

  for(it=cgh_list.begin();it!=cgh_list.end(); ++it)
  {
      cgh_wrapper_ptr cw  = (*it);

      if (!cw)  continue;

      for(oit=other.cgh_list.begin(); oit!=other.cgh_list.end(); ++oit)
      {
    cgh_wrapper_ptr ocw = (*oit);

    if (!ocw) continue;

    double olap = dotProduct( *cw->cgh, *ocw->cgh );

    if (olap>comparison_thres)
    {
        if (olap> cw->match_score)
        {
      cw->match_score = olap;
      cw->best_match  = ocw;
        }
    }
      }

#ifdef DEBUG_CGH
if (cw->match_score>comparison_thres)
{
    mmout << "Feature at " << cw->position(0) << "x"
          << cw->position(1) << " matches at "
          << cw->best_match->position(0) << "x"
          << cw->best_match->position(1) << ", match=" << cw->match_score
          << std::endl;
}
#endif
      if (cw->match_score>comparison_thres)
      {
    output.push_back(cw);
      }
  }

        return output;
    }

    void  createFromImageFixedPoints( image<T>& im ) 
    {
  //extract edges and corners,
  //orient the edge strings and,
  //create a cgh from all corners

        canny_tool<int>   canny;
        edge_string_ptr_list edge_strings;

  //(1) first run canny to extract a set of string_el strings
        edge_strings=canny.findEdgeStrings( im );
 //       edge_string_op::filterWiggles( edge_strings, 0.2, 1, 35.0 );

//(1.5) contrast orient the strings?

  //(2) find the corners (not now)
  //(2.5) calculate the contrast threshold value.(not now)

        //(3) generate histograms
  int lx,ly,ux,uy,stepx,stepy,x,y;
  lx = im.getWidth()/4;
  ux = lx+im.getWidth()/2;
  ly = im.getHeight()/4;
  uy = ly+im.getHeight()/2;
  stepx = (ux-lx)/10;
  stepy = (uy-ly)/10;
  int number = 10*10,count=0;

        for(y=ly;y<uy;y+=stepy)
        {
      for(x=lx;x<ux;x+=stepx)
      {
          cgh_ptr c( new cgh );
          Vector pos(2);
          pos(0) = (double)x+0.5;
          pos(1) = (double)y+0.5;

        c->createFromStrings( edge_strings, pos);

        cgh_wrapper_ptr cw( new cgh_wrapper );
        cw->cgh = c;
        cw->position = pos;
        cw->contrast = 1.0;

        cgh_list.push_back(cw);

#ifndef NDEBUG
          std::cerr << "Created cgh number " << ++count << "("
                    << number << ")" << std::endl;
#endif
      }
        }

        //(4) delete the strings
        //edge_string_ptr_list::iterator  sit;
        //for(sit=edge_strings.begin();sit!=edge_strings.end();++sit)
        //delete (*sit);
    }
};

}

#endif

---