BlobDetectorLevelSet.cpp

#include "BlobDetectorLevelSet.hh"

// std include
#include <iostream>
#include <vector>

using namespace BIAS;
using namespace std;

template <class StorageType>
BlobDetectorLevelSet<StorageType>::
BlobDetectorLevelSet(){
  image_         = NULL;
  level_         = new BIAS::Image<StorageType>;
  level_s_       = new BIAS::Image<StorageType>;
  eval_ownsdata_ = true;
} 

template <class StorageType>
BlobDetectorLevelSet<StorageType>::
~BlobDetectorLevelSet(){
  if ( eval_ownsdata_ == false )
    eval_.RedirectImageDataPointer(NULL);

  delete level_;
  delete level_s_;
}


 
template <class StorageType> int 
BlobDetectorLevelSet<StorageType>::
Detect(Image<StorageType>& image,
       std::vector<BIAS::BIASBlob>& blobs){
  
  Init(image, image.GetROI()->MaskValid() );
  Evolute();
  GetSegmentation(image);
  BIASWARN("Implementation unfinished, see ExampleBlobDetectorLevelSet for usage instructions!");
  return 0;
}


template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
GetSegmentation(BIAS::Image<StorageType>& im) const
{
  const int w = GetImage().GetWidth();
  const int h = GetImage().GetHeight();

  Resize(im, w,h);

  const StorageType ** image = GetImage().GetImageDataArray();
  const StorageType ** level = GetLevel().GetImageDataArray();
  StorageType ** dst   = im.GetImageDataArray();
    
  for (int j = 0; j < h; j++)
    for (int k = 0; k < w; k++)
      dst[j][k] = level[j][k]==0 ? image[j][k] : 255-1;
}

template <class StorageType> std::vector<int>
BlobDetectorLevelSet<StorageType>::
GetHistogram(int hist) { 
  RecalcHistograms();
  
  vector<int> vec;
  for (int i = 0; i < 256; i++)
    vec.push_back(hist==0 ? _hist0[i]:_hist1[i]);
  return vec;
}


template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
Resize(BIAS::Image<StorageType> &image, const int w, const int h)
{
  if ( image.IsEmpty() ) 
    image.Init(w,h);
  else
    if ( int(image.GetWidth())!=w || int(image.GetHeight())!=h ||
     image.GetChannelCount()!=1 ) {
      image.Release();
      image.Init(w,h);
    }
}

template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
ClearHistogram(int hist[]) {
  for(int i = 0; i < 256; i++)
    hist[i] = 0;
}

template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
ClearHistograms() {
  ClearHistogram( _hist0 );
  ClearHistogram( _hist1 );
}

template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
RecalcHistograms()
{
  const int w = eval_.GetWidth();
  const int h = eval_.GetHeight();

  ClearHistograms();    

  const StorageType **  image = image_->GetImageDataArray();
  StorageType **      level = level_->GetImageDataArray();
  StorageType **       eval = eval_.GetImageDataArray();
    
  for(int j = 0; j < h; j++)
    for(int k = 0; k < w; k++) 
      if ( eval[j][k]!=0 ) {
        const StorageType pv = image[j][k]; 

        if ( level[j][k]==0 )
          _hist0[pv]++;
        else                 
          _hist1[pv]++; 
      }
}

template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
AddSquare(BIAS::Image<StorageType>& image, 
          const BIAS::Vector2<int>& p1, 
          const BIAS::Vector2<int>& p2)
{ 
  const int x1 = p1[0];
  const int y1 = p1[1];
  const int x2 = p2[0];
  const int y2 = p2[1];

#ifdef BIAS_DEBUG
  { // scope
    const int h = image.GetHeight();
    const int w = image.GetWidth();
    Vector2<int> vDim(w,h);
    BIASASSERT( p1>=Vector2<int>(0,0) && p1<=p2 && p2<=vDim );
  }
#endif //BIAS_DEBUG

  StorageType ** data = image.GetImageDataArray();
    
  for (int j = y1; j < y2; j++)
    for (int k = x1; k < x2; k++)
      data[j][k] = 255;
}

template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
Set(const BIAS::Image<StorageType> &image, bool useROI)
{
  image_ = &image;

  const int w = image.GetWidth();
  const int h = image.GetHeight();

  BIASASSERT( w==(int)eval_.GetWidth() && h==(int)eval_.GetHeight() );

  if ( image.GetROI()->MaskValid() && useROI ) { // use image's roi msk
    if ( eval_ownsdata_ == true ) 
      eval_.ReleaseImageDataPointer();
    //HACK!!!
    BIAS::ImageBase img;
    image_->GetROI()->GetMaskImage(img);
    eval_.RedirectImageDataPointer( (void*)img.GetImageData());
    eval_ownsdata_ = false;
  }
  else { // use own msk
    if ( eval_ownsdata_ == false ) {
      void * data = new char[w*h];
      eval_.RedirectImageDataPointer( data );
      eval_ownsdata_ = true;
    }
  }
}

template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
Init(const BIAS::Image<StorageType> &image, bool useROI)
{
  // dimension of all image data
  const int w = image.GetWidth();
  const int h = image.GetHeight();

  // setup images
  Resize( *level_,   w,h );
  Resize( *level_s_, w,h );
  Resize( eval_,     w,h );
  Set(image, useROI);

  // clear border of level_/level_s_
  StorageType ** level   = level_->GetImageDataArray();
  StorageType ** level_s = level_s_->GetImageDataArray();
  { for (int k = 0; k < w; k += w-1)
      for (int j = 0; j < h; j++)
        level[j][k] = level_s[j][k] = 0; }
  { for (int j = 0; j < h; j += h-1)
      for (int k = 0; k < w; k++)
        level[j][k] = level_s[j][k] = 0; }
}
  

template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
InitLevelSetSquare(const BIAS::Vector2<int>& p1,
                   const BIAS::Vector2<int>& p2)
{ 
  level_->Clear();
  AddSquare( *level_, p1,p2 ); 
}

template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
SetEvaluationSquare(const BIAS::Vector2<int>& p1,
                    const BIAS::Vector2<int>& p2)
{ 
  BIASASSERT( eval_ownsdata_ == true );

  eval_.Clear();
  AddSquare( eval_, p1,p2 ); 
}

template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
AddEvaluationSquare(const BIAS::Vector2<int>& p1,
                    const BIAS::Vector2<int>& p2)
{
  BIASASSERT( eval_ownsdata_ == true );

  AddSquare( eval_, p1,p2 ); 
}


template <class StorageType> void 
BlobDetectorLevelSet<StorageType>::
Evolute()
{
  RecalcHistograms();

  const int h = level_->GetHeight();
  const int w = level_->GetWidth();

  *level_s_ = *level_;

  const StorageType ** image   = image_->GetImageDataArray();
  StorageType **     level   = level_->GetImageDataArray();
  StorageType **     level_s = level_s_->GetImageDataArray();
  StorageType **     eval    = eval_.GetImageDataArray();
    
  // search for 3x3 neighbor
  for(int j = 1; j<h-1; j++)
    for (int k = 1; k<w-1; k++) 
      if ( eval[j][k]!=0 ) {
        const int val = 0;
        if ( level[j][k] == val )
          if ( level[j-1][k+1] != val  || 
               level[j-1][k+0] != val  ||
               level[j-1][k-1] != val  ||
               level[j+0][k+1] != val  ||
               level[j+0][k-1] != val  ||
               level[j+1][k-1] != val  ||
               level[j+1][k+0] != val  ||
               level[j+1][k+1] != val     ) 
            {
              const StorageType grey = image[j][k];
              if ( _hist0[grey] < _hist1[grey] )
                level_s[j][k] = 1;
            }
        if ( level[j][k] != val )
          if ( level[j-1][k+1] == val  || 
               level[j-1][k+0] == val  ||
               level[j-1][k-1] == val  ||
               level[j+0][k+1] == val  ||
               level[j+0][k-1] == val  ||
               level[j+1][k-1] == val  ||
               level[j+1][k+0] == val  ||
               level[j+1][k+1] == val     ) 
            {
              const StorageType grey = image[j][k];
              if ( _hist1[grey] < _hist0[grey] )
                level_s[j][k] = 0;
            }
      }
         
  // swap level set and init histograms
  BIAS::Image<StorageType>* buff = level_;
  level_   = level_s_;
  level_s_ = buff;
}

//////////////////////////////////////////////////////////////////////////
//                 instantiation
//////////////////////////////////////////////////////////////////////////
namespace BIAS{
template class BlobDetectorLevelSet<unsigned char>; 
//template class BlobDetectorLevelSet<float>; 

// fill in instances as required
#ifdef BUILD_IMAGE_INT
template class BlobDetectorLevelSet<int>; 
#endif
#ifdef BUILD_IMAGE_CHAR
//template class BlobDetectorLevelSet<char>; 
#endif
#ifdef BUILD_IMAGE_SHORT
#endif
#ifdef BUILD_IMAGE_USHORT
template class BlobDetectorLevelSet<unsigned short>; 
#endif
#ifdef BUILD_IMAGE_UINT
#endif
#ifdef BUILD_IMAGE_DOUBLE
#endif
}