LinearRegionDetector.cpp

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "LinearRegionDetector.hh"
#include <Base/Image/ImageConvert.hh>
#ifdef BIAS_DEBUG
#include <Base/Image/ImageIO.hh>
#endif

  //#define TIME_MEASURE
#define MIN_EIGENVALUE_RATIO 4.0
#include <Base/Debug/TimeMeasure.hh>

#include <limits.h>
#include <algorithm>

using namespace BIAS;
using namespace std;

//////////////////////////////////////////////////////////////////////////
//                 implementation
//////////////////////////////////////////////////////////////////////////


template <class StorageType, class CalculationType>
LinearRegionDetector<StorageType, CalculationType>::
LinearRegionDetector()
  : CornerDetectorGradient<StorageType, CalculationType>()
    
{
}

template <class StorageType, class CalculationType>
LinearRegionDetector<StorageType, CalculationType>::~LinearRegionDetector()
{
}

//////////////////////////////////////////////////////////////////////////////
//                      protected functions
//////////////////////////////////////////////////////////////////////////////


template <class StorageType, class CalculationType>
int LinearRegionDetector<StorageType, CalculationType>::
_ComputeCornerness(Image<CalculationType>& mineig)
{
#ifdef BIAS_DEBUG
  // _FeatureMap is only allocated when this->_Cornerness is allocated
  BIASASSERT(this->_Cornerness.SamePixelAndChannelCount(this->_sgxx));
  BIASASSERT(this->_Cornerness.SamePixelAndChannelCount(mineig));
#endif
  int tlx, tly, brx, bry;
  this->_sgxx.GetROI()->GetCorners(tlx, tly, brx, bry);
  mineig.GetROI()->SetCorners(tlx, tly, brx, bry);
  const int minx=tlx;
  const int miny=tly;
  const int maxx=brx;
  const int maxy=bry;

  register int x, y;
  register double gxx, gyy, gxy, ev1, ev2;
  register const double me=(double)this->_MinCornerness;
  Feat fp; this->_FeatList.clear(); 
  this->_FeatList.reserve((brx-tlx)*(bry-tly));
  register CalculationType **ime=mineig.GetImageDataArray();
  register CalculationType **isgxx=this->_sgxx.GetImageDataArray();
  register CalculationType **isgxy=this->_sgxy.GetImageDataArray();
  register CalculationType **isgyy=this->_sgyy.GetImageDataArray();


  for (y=miny; y<maxy; y++){
    for (x=minx; x<maxx; x++){
      gxx=(double)(isgxx[y][x]);
      gyy=(double)isgyy[y][x];
      gxy=(double)isgxy[y][x];
      double tmpsqrt = sqrt((gxx - gyy)*(gxx - gyy)+4.0*gxy*gxy);
      ev1=((gxx+gyy+tmpsqrt)/2.0);
      ev2=((gxx+gyy-tmpsqrt)/2.0);
      ime[y][x]=(CalculationType)fabs(ev1/ev2);
      if ((fabs(ev1/ev2)>MIN_EIGENVALUE_RATIO) && (ev1>me)){
        double gg=0;
        for (int i=-2; i<3; i++)
          for (int j=-2; j<3; j++)
            gg += (gxx-isgxx[y+i][x+j])*(gxx-isgxx[y+i][x+j])
              +(gyy-isgyy[y+i][x+j])*(gyy-isgyy[y+i][x+j])
              +(gxy-isgxy[y+i][x+j])*(gxy-isgxy[y+i][x+j]);
       
        if (gg<100000.0) {
          fp.x=x;
          fp.y=y;
          fp.val=(ev1>(double)INT_MAX)?(INT_MAX):((int)ev1);
          this->_FeatList.push_back(fp);
        }
      }
    }
  }
#ifdef BIAS_DEBUG
  if (this->DebugLevelIsSet(D_CD_WRITE_DEBUG_IM)){
    //ImageIO::Save("maxeig.mip", mineig);
    ImageIO::Save("maxeig.mip", mineig);
  }
#endif
  return 0;
}



//////////////////////////////////////////////////////////////////////////
//                 instantiation
//////////////////////////////////////////////////////////////////////////
namespace BIAS{
template class LinearRegionDetector<float, float>; 
template class LinearRegionDetector<unsigned char, float>;
// fill in instances as required
#ifdef BUILD_IMAGE_INT
template class LinearRegionDetector<unsigned char, int>; 
#endif
#ifdef BUILD_IMAGE_CHAR
#endif
#ifdef BUILD_IMAGE_SHORT
#endif
#ifdef BUILD_IMAGE_USHORT
#ifdef BUILD_IMAGE_INT
template class LinearRegionDetector<unsigned short, int>; 
#endif
#endif
#ifdef BUILD_IMAGE_UINT
#endif
#ifdef BUILD_IMAGE_DOUBLE
#endif
}