BlobDetectorBFS.cpp

#include "BlobDetectorBFS.hh"
#include <Base/ImageUtils/ImageDraw.hh>
#include <Base/Image/ImageConvert.hh>
#include <Base/Image/ImageIO.hh>
using namespace BIAS;
using namespace std;

/*
   @brief standard constructor
*/
template <class StorageType>
BlobDetectorBFS<StorageType>::
BlobDetectorBFS(){
  UL_[0] = UL_[1] = LR_[0] = LR_[1] = 0;
  threshold_ = 128;
  gaussSigma_=0.0;
  minWeight_=0;
  maxWeight_=UINT_MAX;
  eraseBelowMinWeight_=false;
}

/*
  @brief standard Destructor
*/
template <class StorageType>
BlobDetectorBFS<StorageType>::
~BlobDetectorBFS(){
}


/*
   @brief Detect and return blobs in an image
   @param[in] image the image to detect blobs in
   @param[out] corners vector where detected blobs are stored in
   @return 0 on success, -1 on failure
*/
template <class StorageType>
int BlobDetectorBFS<StorageType>::
Detect(BIAS::Image<StorageType> &image,
       std::vector<BIAS::BIASBlob> &blobs){

  if(image.GetChannelCount()!=1){
    BIASERR("Blob detection only for 1 channel images, please convert!");
    return -1;
  }

  corners_.clear();
  unsigned int w = image.GetWidth();
  unsigned int h = image.GetHeight();

  //check roi
  if(UL_[0] == 0 && UL_[1] == 0 && LR_[0] == 0 && LR_[1] == 0){
    UL_[0] = UL_[1] = 0;
    LR_[0] = w;
    LR_[1] = h;
  }
  queue.reserve(w*h);
  cluster.reserve(w*h);
  markerBackup_.Init(w,h,1);
  marker_.Init(w,h,1);
  markerBackup_.FillImageWithConstValue((unsigned char)0);
  unsigned char **idaMark = markerBackup_.GetImageDataArray();
  for (unsigned int y=UL_[1];y<LR_[1];y++) {
    idaMark[y][UL_[0]  ]=255;
    idaMark[y][LR_[0]-1]=255;
  }
  for (unsigned int x=UL_[0];x<LR_[0];x++) {
    idaMark[UL_[1]  ][x]=255;
    idaMark[LR_[1]-1][x]=255;
  }


  marker_.CopyIn_NoInit(markerBackup_.GetImageData());

  StorageType **idaIn = image.GetImageDataArray();

  if (gaussSigma_!= 0.0) {
    smoothFilter_.SetSigma(gaussSigma_);
    smoothFilter_.Filter(image, imageSmooth_);
    idaIn = ( StorageType**)imageSmooth_.GetImageDataArray();
  }
  //BIAS::ImageIO::Save("marker",marker_);
  BIAS::BIASBlob cornersCurrent;
  unsigned int maxcornerweight = 0;
  cornersCurrent.weight = 0;
  maxCorners_ = cornersCurrent;
  int ret = -1; 
  
  StorageType **idaOrig;
  if (eraseBelowMinWeight_) {    
    if (gaussSigma_ != 0.0) {
      image.CopyIn_NoInit(imageSmooth_.GetImageData());
    }
    idaOrig = image.GetImageDataArray();
  } else {
    idaOrig = NULL;
  }
  for (unsigned int y=UL_[1];y<LR_[1];y++) {
    for (unsigned int x=UL_[0];x<LR_[0];x++) {

      StorageType val = idaIn[y][x];
      unsigned char mar = idaMark[y][x];
      if (val > threshold_) {
        if (mar == 0) {
          if ((ClusterDescent_(x,y,w,h, idaIn, idaMark, cornersCurrent, idaOrig) == 0) &&
            (cornersCurrent.weight > minWeight_) && (cornersCurrent.weight < maxWeight_)) {

            corners_.push_back(cornersCurrent);
            if (cornersCurrent.weight > maxcornerweight) {
              maxCorners_ = cornersCurrent;
              maxcornerweight = cornersCurrent.weight;
              ret = 0;
            }
          }
        }
      } else {
        if (idaOrig != NULL) {
          idaOrig[y][x] = 0;
        }
      }
    }
  }
  blobs.clear();
  for(unsigned k=0;k<corners_.size();k++){
    blobs.push_back(corners_[k]);
  }

  return ret;
}


/*
   @brief protected blobDetection function
   @param[in] x start x pixel coordinate
   @param[in] y start y pixel coordinate
   @param[in] w width of search space
   @param[in] h height of search space
   @param[in] idaIn input image imageDataArray
   @param[out] idaMark mark image imageDataArray (handled pixels are marked here)
   @param[out] corners detected corners
   @return int 0 on success -1 on failure
*/
template <class StorageType>
int BlobDetectorBFS<StorageType>::
ClusterDescent_(const unsigned int x, const unsigned int y,
                const unsigned int w, const unsigned int h,
                StorageType **idaIn, unsigned char **idaMark,
                BIAS::BIASBlob &corners, StorageType **idaOrig) {
  BIAS::Vector2<unsigned int> start(x,y);
  queue.clear();
  cluster.clear();

  queue.push_back(start);
  idaMark[y][x] = 255;
  while (!queue.empty()) {
    
    Vector2<unsigned int> cur = queue.back();
    if (cluster.size() > w*h)
      break;
    queue.pop_back();
    cluster.push_back(cur);
    
    n[0] = n[2] = n[4] = cur[0]-1;
    n[6] = n[8] = cur[0];
    n[10] = n[12] = n[14] = cur[0]+1;
    n[1] = n[7] = n[11] = cur[1]-1;
    n[3] = n[13] = cur[1];
    n[5] = n[9] = n[15] = cur[1]+1;
    
    unsigned int x,y;
    for (unsigned int i=0;i<16;i+=2) {
      x=n[i];y=n[i+1];
      if (idaMark[ y ][ x ] == 0) {
        idaMark[ y ][ x ] = 255;
        if (idaIn[ y ][ x ] > threshold_) {
          start[0]=x; start[1]=y;
          cluster.push_back(start);
          queue.push_back(start);
        }
      }
    }

/*    
    // can go x+1
    if (cur[0]<LR_[0]-1) {
      if (idaMark[cur[1]][cur[0]+1] == 0) {
        idaMark[cur[1]][cur[0]+1] = 255;
        if (idaIn[cur[1]][cur[0]+1] > threshold_) {
          start[0]=cur[0]+1; start[1]=cur[1];
          cluster.push_back(start);
          queue.push_back(start);
        }
      }
      // can go x+1 and y-1
      if (cur[1]>UL_[1]) {
        if (idaMark[cur[1]-1][cur[0]+1] == 0) {
          idaMark[cur[1]-1][cur[0]+1] = 255;
          if (idaIn[cur[1]-1][cur[0]+1] > threshold_) {
            start[0]=cur[0]+1; start[1]=cur[1]-1;
            cluster.push_back(start);
            queue.push_back(start);
          }
        }
      }
      // can go x+1 and y+1
      if (cur[1]<LR_[1]-1) {
        if (idaMark[cur[1]+1][cur[0]+1] == 0) {
          idaMark[cur[1]+1][cur[0]+1] = 255;
          if (idaIn[cur[1]+1][cur[0]+1] > threshold_) {
            start[0]=cur[0]+1; start[1]=cur[1]+1;
            cluster.push_back(start);
            queue.push_back(start);
          }
        }
      }
    }//end  if (cur[0]<LR_[0]-1)

    // can go x-1
    if (cur[0]>UL_[0]) {
      if (idaMark[cur[1]][cur[0]-1] == 0) {
        idaMark[cur[1]][cur[0]-1] = 255;
        if (idaIn[cur[1]][cur[0]-1] > threshold_) {
          start[0]=cur[0]-1; start[1]=cur[1];
          cluster.push_back(start);
          queue.push_back(start);
        }
      }
      // can go x-1 and y+1
      if (cur[1]<LR_[1]-1) {
        if (idaMark[cur[1]+1][cur[0]-1] == 0) {
          idaMark[cur[1]+1][cur[0]-1] = 255;
          if (idaIn[cur[1]+1][cur[0]-1] > threshold_) {
            start[0]=cur[0]-1; start[1]=cur[1]+1;
            cluster.push_back(start);
            queue.push_back(start);
          }
        }
      }
      // can go x-1 and y-1
      if (cur[1]>UL_[1]) {
        if (idaMark[cur[1]-1][cur[0]-1] == 0) {
          idaMark[cur[1]-1][cur[0]-1] = 255;
          if (idaIn[cur[1]-1][cur[0]-1] > threshold_) {
            start[0]=cur[0]-1;start[1]=cur[1]-1;
            cluster.push_back(start);
            queue.push_back(start);
          }
        }
      }
    }
    // can go y+1
    if (cur[1]<LR_[1]-1) {
      if (idaMark[cur[1]+1][cur[0]] == 0) {
        idaMark[cur[1]+1][cur[0]] = 255;
        if (idaIn[cur[1]+1][cur[0]] > threshold_) {
          start[0]=cur[0];start[1]=cur[1]+1;
          cluster.push_back(start);
          queue.push_back(start);
        }
      }
    }
    // can go y-1
    if (cur[1]>UL_[1]) {
      if (idaMark[cur[1]-1][cur[0]] == 0) {
        idaMark[cur[1]-1][cur[0]] = 255;
        if (idaIn[cur[1]-1][cur[0]] > threshold_) {
          start[0]=cur[0]; start[1]=cur[1]-1;
          cluster.push_back(start);
          queue.push_back(start);
        }
      }
    }
*/
  }

  //detect center of mass
  corners.weight = cluster.size();
  if (corners.weight > minWeight_ && corners.weight < maxWeight_) {
    corners.UL[0] = cluster[0][0];
    corners.UL[1] = cluster[0][1];
    corners.LR[0] = cluster[0][0];
    corners.LR[1] = cluster[0][1];
    corners.centerofmass[0] = cluster[0][0];
    corners.centerofmass[1] = cluster[0][1];
    for (unsigned int i=1;i<corners.weight;i++) {
      BIAS::Vector2<unsigned int> cur( cluster[i]);
      corners.centerofmass[0] += cur[0];
      corners.centerofmass[1] += cur[1];
      if (cur[0] > corners.LR[0])
        corners.LR[0] = cur[0];
      if (cur[0] < corners.UL[0])
        corners.UL[0] = cur[0];
      if (cur[1] > corners.LR[1])
        corners.LR[1] = cur[1];
      if (cur[1] < corners.UL[1])
        corners.UL[1] = cur[1];
    }
    corners.centerofmass[0] /= corners.weight;
    corners.centerofmass[1] /= corners.weight;
    return 0;
  } else {
    // if "erase below min size" this will clean up the small cluster
    if (idaOrig != NULL) {
      for (unsigned int i=0;i<cluster.size();i++) {
        idaOrig[ cluster[i][1] ][ cluster[i][0] ] = 0;
      }
    }
    return -1;
  }
  return 0;
}


/*
   @brief draws the detected blobs in image
   @param[in] image the blobs are drawn in here
   @return 0 on sucess, -1 on failure
*/
template <class StorageType>
int BlobDetectorBFS<StorageType>::
DrawInImage(BIAS::Image<StorageType> &image){
  StorageType green[3] = { 0,255,0 };
  StorageType red[3] = { 255,0,0 };
  //StorageType yellow[3] = { 255,255,0 };
  BIAS::BIASBlob c;

  if(image.GetChannelCount() != 3){
    BIAS::Image<StorageType> tmpImage(image);
    BIAS::ImageConvert::ToRGB(tmpImage,image);
  }

  for (unsigned int i=0; i<corners_.size();i++) {
    c = corners_[i];
    ImageDraw<StorageType>::RectangleCorners(image, (unsigned)c.UL[0],
                                             (unsigned)c.UL[1], (unsigned)c.LR[0],
                                             (unsigned)c.LR[1], green);
    ImageDraw<StorageType>::CircleCenterFilled (image, (unsigned)c.centerofmass[0],
                                             (unsigned)c.centerofmass[1], 5, red);
  }
  if (GetLargestBoundingBox(c) == 0) {
    ImageDraw<StorageType>::RectangleCorners(image,
                                             (unsigned)c.UL[0], (unsigned)c.UL[1],
                                             (unsigned)c.LR[0], (unsigned)c.LR[1], red);
    ImageDraw<StorageType>::RectangleCorners(image,
                                             (unsigned)c.UL[0]-1, (unsigned)c.UL[1]-1,
                                             (unsigned)c.LR[0]+1, (unsigned)c.LR[1]+1, red);
    ImageDraw<StorageType>::RectangleCorners(image,
                                             (unsigned)c.UL[0]+1, (unsigned)c.UL[1]+1,
                                             (unsigned)c.LR[0]-1, (unsigned)c.LR[1]-1, red);
  }
  return 0;
}

namespace BIAS{
template class BlobDetectorBFS<unsigned char>;
template class BlobDetectorBFS<float>;

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