HessianSimple.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 "HessianSimple.hh"
#include "FilterMask.hh"

using namespace BIAS;
using namespace std;

namespace BIAS {

#define POLAR_TABLE_OFFSET 128
#define POLAR_TABLE_SIZE 257
//////////////////////////////////////////////////////////////////////////
//                 implementation
//////////////////////////////////////////////////////////////////////////
template <class InputStorageType, class OutputStorageType> void
HessianSimple<InputStorageType, OutputStorageType>::
InitKernel_() 
{
  // this is a filtermask in the sense of convolution
  // it is reflected at its symmetry center before being "dropped"
  // onto the image !
  Vector<FM_INT> h(3), v(1);
  h[0] = 1;
  h[1] = -2;
  h[2] = 1;
  v[0] = 1;
  FilterMask f(h, v, 0, 0);
  f.CreateFloatFilter();
  _Conv.SetKernel(f);
}

template <class InputStorageType, class OutputStorageType>
HessianSimple<InputStorageType, OutputStorageType>::
HessianSimple(bool BuildPCM)
  : FilterNTo3N<InputStorageType, OutputStorageType>()
{
  InitKernel_(); 
}

template <class InputStorageType, class OutputStorageType>
HessianSimple<InputStorageType, OutputStorageType>::
HessianSimple(const HessianSimple<InputStorageType, OutputStorageType>& other)
  : _Conv(other._Conv)
 
{
  InitKernel_();
}

template <class InputStorageType, class OutputStorageType>
HessianSimple<InputStorageType, OutputStorageType>::
~HessianSimple()
{

}

template <class InputStorageType, class OutputStorageType>
int HessianSimple<InputStorageType,OutputStorageType>::
Filter(const Image<InputStorageType>& src, Image<OutputStorageType>& hxx, 
       Image<OutputStorageType>& hyy)
{
  BIASCDOUT(D_FILTERBASE_CALLSTACK, "HessianSimple::Filter(src, gx, gy)\n");
  int res=0;
  if (!hxx.SamePixelAndChannelCount(src)){
    hxx.Release();
    hxx.Init(src.GetWidth(), src.GetHeight(), src.GetChannelCount());
  }
  if (!hyy.SamePixelAndChannelCount(src)){
    hyy.Release();
    hyy.Init(src.GetWidth(), src.GetHeight(), src.GetChannelCount());
  }
 
  if (src.GetChannelCount()==1) {
    if (_Conv.CalculationInFloat()){    
        res = SimpleGreyValidFloat_(src, hxx, hyy);
    } else {     
        res = SimpleGreyValidInt_(src, hxx, hyy);
    }
  } else {
    // grest
    BIASERR("not for multiple channel images");
    return -5;
  }
  return res;
}

template <class InputStorageType, class OutputStorageType>
int HessianSimple<InputStorageType,OutputStorageType>::
Filter(const Image<InputStorageType>& src, Image<OutputStorageType>& hxx, 
       Image<OutputStorageType>& hyy, Image<OutputStorageType>& hxy) 
{
  BIASCDOUT(D_FILTERBASE_CALLSTACK, 
            "HessianSimple::Filter(src, hxx, hyyy, hxy)\n");
  if (!src.SamePixelAndChannelCount(hxy)){
    if (!hxy.IsEmpty()) hxy.Release();
    hxy.Init(src.GetWidth(), src.GetHeight(), src.GetChannelCount());
  }
  
  int res=0;
  res = Filter(src, hxx, hyy);
  OutputStorageType **idaHxx = hxx.GetImageDataArray();
  OutputStorageType **idaHyy = hyy.GetImageDataArray();
  OutputStorageType **idaHxy = hxy.GetImageDataArray();
  
  for(unsigned int x=0;x<hxx.GetWidth();x++){
    for(unsigned int y=0;y<hxx.GetHeight();y++){
      idaHxy[y][x] = idaHxx[y][x] + idaHyy[y][x];
    }
  }  
 
  return (res==0)?0:-1;
}




template <class InputStorageType, class OutputStorageType>
int HessianSimple<InputStorageType, OutputStorageType>::
SimpleGreyValidFloat_(const Image<InputStorageType>& src,
                      Image<OutputStorageType>& gWE,
                      Image<OutputStorageType>& gNS)
{
  BIASCDOUT(D_FILTERBASE_CALLSTACK, "HessianSimple::SimpleGreyValidFloat_\n");
 
  OutputStorageType *gx=gWE.GetImageData();
  OutputStorageType *gy=gNS.GetImageData();
  const int width=(int)src.GetWidth();
  const int nwidth = - width;
  
#ifdef BIAS_DEBUG
  BIASASSERT(src.GetChannelCount()==1);
  BIASASSERT(src.SamePixelAndChannelCount(gWE));
  BIASASSERT(src.SamePixelAndChannelCount(gNS));
  BIASASSERT(gx!=gy);
  BIASASSERT(_Conv.CalculationInFloat());
#endif

  int minx, miny, maxx, maxy;
  src.GetROI()->GetCorners(minx, miny, maxx, maxy);
  gWE.GetROI()->SetCorners(minx+1, miny+1, maxx-1, maxy-1);
  gNS.GetROI()->SetCorners(minx+1, miny+1, maxx-1, maxy-1);

 
  int offset;
  OutputStorageType *pgx, *pgy, *end2, *lend2;
 
 
  int step=width-maxx+minx;

  offset=minx+1+(miny+1)*width;
  const InputStorageType *ph  = src.GetImageData() + offset;
  pgx=gx+offset;
  pgy=gy+offset;
  step+=2;
  end2=gx+maxx+width*(maxy-2)-1;
  lend2=gx+maxx+width*(miny+1)-1;
  while (pgx<end2){
    while (pgx<lend2){
      *pgx++ = (OutputStorageType)(ph[1] - ph[-1])/
        (OutputStorageType)2;
      *pgy++ = (OutputStorageType)(ph[width] - ph[nwidth])/ 
        (OutputStorageType)2;
      ph++;
    }
    ph+=step;
    pgx+=step;
    pgy+=step;
    lend2+=width;
  }
  return 0;
}


template <class InputStorageType, class OutputStorageType>
int HessianSimple<InputStorageType, OutputStorageType>::
SimpleGreyValidInt_(const Image<InputStorageType>& src,
                      Image<OutputStorageType>& gWE,
                      Image<OutputStorageType>& gNS)
{
  BIASCDOUT(D_FILTERBASE_CALLSTACK, "HessianSimple::SimpleGreyValidInt_\n");
 
  OutputStorageType *gx=gWE.GetImageData();
  OutputStorageType *gy=gNS.GetImageData();
  const int width=(int)src.GetWidth();
  const int nwidth = - width;
  
#ifdef BIAS_DEBUG
  BIASASSERT(src.GetChannelCount()==1);
  BIASASSERT(src.SamePixelAndChannelCount(gWE));
  BIASASSERT(src.SamePixelAndChannelCount(gNS));
  BIASASSERT(gx!=gy);
  BIASASSERT(!_Conv.CalculationInFloat());
#endif



  int minx, miny, maxx, maxy;
  src.GetROI()->GetCorners(minx, miny, maxx, maxy);
  gWE.GetROI()->SetCorners(minx+1, miny+1, maxx-1, maxy-1);
  gNS.GetROI()->SetCorners(minx+1, miny+1, maxx-1, maxy-1);

 
  int offset;
  OutputStorageType *pgx, *pgy, *end2, *lend2;
  
 
  int step=width-maxx+minx;

   offset=minx+1+(miny+1)*width;
  const InputStorageType * ph = src.GetImageData()+offset;
 
  pgx=gx+offset;
  pgy=gy+offset;
  step+=2;
  end2=gx+maxx+width*(maxy-2)-1;
  lend2=gx+maxx+width*(miny+1)-1;
  while (pgx<end2){
    while (pgx<lend2){
      *pgx++ = (OutputStorageType)(ph[1] - ph[-1])/ 
        (OutputStorageType)2;
      *pgy++ = (OutputStorageType)(ph[width] - ph[nwidth])/ 
        (OutputStorageType)2;
      ph++;
    }
    ph+=step;
    pgx+=step;
    pgy+=step;
    lend2+=width;
  }

  return 0;
}


template <class InputStorageType, class OutputStorageType>
void HessianSimple<InputStorageType, OutputStorageType>::
GetBordersValid_(int &border_x, int &border_y) const
{
  _Conv.GetBorders(border_x, border_y);
}

//////////////////////////////////////////////////////////////////////////
//                 instantiation
//////////////////////////////////////////////////////////////////////////
#define FILTER_INSTANTIATION_CLASS HessianSimple
#define FILTER_INSTANTIATION_NO_UNSIGNED_OUTPUT
#include "Filterinst.hh"

} // namespace BIAS