ContourDetectorSimple.cpp

#include "ContourDetectorSimple.hh"
// std includes
#include <limits>

using namespace std;
using namespace BIAS;

#define MY_INFTY 10000

/////////////////////////////////////////////////////////
inline unsigned short mymin(unsigned short a, unsigned short b)
{
  return (a<=b)?a:b;
}

inline unsigned short min(unsigned short s0,
                          unsigned short s1,
                          unsigned short s2,
                          unsigned short s3,
                          unsigned short s4)
{
  return mymin(s0, mymin(s1, mymin(s2, mymin(s3, s4))));
}

//////////////////////////////////////////////////////////////
template <class StorageType>
DistImgMatAcc<StorageType>::
DistImgMatAcc(BIAS::Image<StorageType> &img)
{
  data = img.GetImageDataArray();
}

template <class StorageType> StorageType
DistImgMatAcc<StorageType>::
Get(int row, int col)
{
  return data[row][col];
}

template <class StorageType> void
DistImgMatAcc<StorageType>::
Set(int row, int col, StorageType value)
{
  data[row][col] = value;
}

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

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


template <class StorageType>
ContourDetectorSimple<StorageType>::
ContourDetectorSimple(){
  SetBackground(StorageType(0));
  SetGap(5);
}

template <class StorageType>
ContourDetectorSimple<StorageType>::
~ContourDetectorSimple(){
}


template <class StorageType>
bool ContourDetectorSimple<StorageType>::
GetContourImage(BIAS::Image<unsigned char>& image, 
        const std::vector<BIASContour> & contour){
    
    if(contour.size() == 0 || contour[0].length ==0)
        return false;
    
    unsigned char** ida = image.GetImageDataArray();
    unsigned channels = image.GetChannelCount();
    unsigned w = image.GetWidth();
    unsigned h = image.GetHeight();
    //cout<<"Contour size:"<<contour.size()<<endl;
    
    for (unsigned int i=0;i<contour.size();i++){
        //cout<<"ith length:"<<contour[i].length<<endl;
        for (unsigned int k=0;k<contour[i].length;k++){
            for (unsigned int c=0;c<channels;c++){
                if((unsigned int)contour[i].contourPixel[k][0] > 0 && (unsigned int)contour[i].contourPixel[k][0] < w &&
                        (unsigned int)contour[i].contourPixel[k][1] > 0 && (unsigned int)contour[i].contourPixel[k][1] < h){
                    ida[(unsigned int)contour[i].contourPixel[k][1]]
                        [(unsigned int)contour[i].contourPixel[k][0]*channels+c] =  255;
                }
            }
        }
    }
    return true;
}

template <class StorageType>
bool ContourDetectorSimple<StorageType>::
FindFirst_(int &pos_x, int &pos_y) {
    //check for first pixzel and return true if found 
    bool found = false;
    for (int y = 0; y < img_h; y++)
        for (int x = 0; x < img_w; x++)
            if ( IsFg_(x,y) ) {
                pos_x = x;
                pos_y = y;        
                found = true;
                return found;
            }
    //else return false
    return found;
}

template <class StorageType>
void ContourDetectorSimple<StorageType>::
Init_(BIAS::Image<StorageType> &img)
{
  img_w = img.GetWidth();
  img_h = img.GetHeight();
  data_  = img.GetImageDataArray();

  // draw v lines
  const int offset = img_w-1;
  for (int i = 0; i < img_h; i++) {
    data_[i][0]      = background_;
    data_[i][offset] = background_;
  }
  // draw h lines
  for (int n = 0; n < img_h; n += (img_h-1)) {
    StorageType *line = data_[n];
    for (int i = 0; i < img_w; i++)
      line[i] = background_;
  }
}

//////////////////////////////////////////////////////////////
template <class StorageType>
int ContourDetectorSimple<StorageType>::
Detect(Image<StorageType>& image,
       std::vector<BIAS::BIASContour>& contour){

  if(contour.size() < 1){
    BIASContour cont;
    contour.push_back(cont);
  }

  Init_(image);

  CreateContourBase_(contour[0],image);
  return contour[0].length;
}

//////////////////////////////////////////////////////////////

template <class StorageType>
void ContourDetectorSimple<StorageType>::
CreateDistanceImage(BIAS::Image<StorageType>& dist_img,
                    const BIASContour& contour)
{
  InitDistanceImage_(dist_img, contour);
  MakeDistanceImage_(dist_img);
}

template <class StorageType>
int ContourDetectorSimple<StorageType>::
CreateDistanceImageByContour(BIAS::Image<StorageType>& dist_img,
                             BIAS::Image<StorageType>& img)
{
  BIASContour contour;
  Init_(img);
  bool ret = CreateContourBase_( contour, img );

  if (contour.length <= 0 || !ret)
    return -1;

  CreateDistanceImage( dist_img, contour );

  return contour.length;
}


//////////////////////////////////////////////////////////////
////////// Protected Funcitons //////////////////////////////

template <class StorageType> bool
ContourDetectorSimple<StorageType>::
CreateContourBase_(BIAS::BIASContour &contour,
                   BIAS::Image<StorageType> &img)
{

  // find first foreground pixel location
  bool ret = false;
  int first_x = -1;
  int first_y = -1;
  ret = FindFirst_( first_x, first_y );
  if ( first_x < 0 || first_y < 0 || !ret)
    return ret;

  // create contour run
  int x = first_x;
  int y = first_y;
  int d = 0;

  directionList_.clear();
  contour.contourPixel.clear();
  contour.length = 0;

  do {
    contour.contourPixel.push_back ( BIAS::Vector2<double>( x,y ) );
    contour.length++;

    d -= 3;
    //we try 5 iterations to find the next foreground pixel
    int stop = 8*gap_;
    while ( !IsFg_(x,y,d)  && d < stop) {
      d++;
    }
    d = (d+16)%8;
    directionList_.push_back (d);

    switch ( d ) {
    case 0: x += 1; y += 0; break;
    case 1: x += 1; y += 1; break;
    case 2: x += 0; y += 1; break;
    case 3: x -= 1; y += 1; break;
    case 4: x -= 1; y += 0; break;
    case 5: x -= 1; y -= 1; break;
    case 6: x += 0; y -= 1; break;
    case 7: x += 1; y -= 1; break;
    }
  } while ( x != first_x  ||  y != first_y );
  
  return true;
}

//////////////////////////////////////////////////////////////
template <class StorageType>
void ContourDetectorSimple<StorageType>::
InitDistanceImage_(BIAS::Image<StorageType>& img,
                  const BIASContour& contour)
{
  StorageType* data = img.GetImageData();
  int pixels = img.GetPixelCount();

  // initiate with distance infinity
  for (int i = 0; i < pixels; i++)
    data[i] = numeric_limits<StorageType>::max();

  // contour gets distance zero
  for (unsigned int i = 0; i < contour.contourPixel.size(); i++)
    img.SetPixel(0, (const unsigned)contour.contourPixel[i][0] /*col*/,
      (const unsigned)contour.contourPixel[i][1] /*row*/);
}


//////////////////////////////////////////////////////////////
template <class StorageType>
void ContourDetectorSimple<StorageType>::
MakeDistanceImage_(BIAS::Image<StorageType>& img)
{
  DistImgMatAcc<StorageType> d ( img );

  int rows = img.GetHeight();
  int cols = img.GetWidth();

  StorageType min;

  // forward pass
  for (int k = 1; k <= rows-1; k++) {
    for (int j = 1; j <= cols-1-1; j++) {
      min = numeric_limits<StorageType>::max();
      if (min > d.Get(k,j)) min = d.Get(k,j);
      if (min > d.Get(k,j-1)+3) min = d.Get(k,j-1)+3;
      if (min > d.Get(k-1,j)+3) min = d.Get(k-1,j)+3;
      if (min > d.Get(k-1,j-1)+4) min = d.Get(k-1,j-1)+4;
      if (min > d.Get(k-1,j+1)+4) min = d.Get(k-1,j+1)+4;
      d.Set(k,j, min);
    }
  }

  // backward pass
  for (int k = rows-1-1; k >= 0; k--) {
    for (int j = cols-1-1; j >= 1; j--) {
      min = numeric_limits<StorageType>::max();
      if (min > d.Get(k,j)) min = d.Get(k,j);
      if (min > d.Get(k,j+1)+3) min = d.Get(k,j+1)+3;
      if (min > d.Get(k+1,j)+3) min = d.Get(k+1,j)+3;
      if (min > d.Get(k+1,j+1)+4) min = d.Get(k+1,j+1)+4;
      if (min > d.Get(k+1,j-1)+4) min = d.Get(k+1,j-1)+4;
      d.Set(k, j, min);
    }
  }
}


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

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