BlobDetectorCCA.cpp

#include <algorithm>
#include "BlobDetectorCCA.hh"
#include "Base/Image/ImageConvert.hh"


/**
   CCA : Connected Component Analysis
   @author Daniel grest, Sept. 2002
 */
#define D_EACHP 1<<0
#define D_REGION 1<<1


using namespace BIAS;
using namespace std;

namespace BIAS{
/**
 * \class Compare
 * \brief simple class so compare vector sizes
 * \internal
 */
class Compare {
public:
  bool operator()(const std::vector<Vector2<int> > &left,
                  const std::vector<Vector2<int> > &right) const {
    if (left.size()>right.size()) return true;
    else return false;
  }
  bool operator()(const std::vector<unsigned int> &left,
                  const std::vector<unsigned int> &right) const {
    if (left.size()>right.size()) return true;
    else return false;
  }
}; // endof class Compare
}//end namespace BIAS

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


template <class StorageType>
BlobDetectorCCA<StorageType>::
BlobDetectorCCA(){
  bIsInited_=false;
  fPercent_=50;
  bNeighborHood4_=true;
} 

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


template <class StorageType> int
BlobDetectorCCA<StorageType>::
Detect(Image<StorageType>& image,
       std::vector<BIAS::BIASBlob>& blobs){
  int ret =0;
  Init_(image);
  ret = Process_(image,fPercent_, bNeighborHood4_);
  std::vector<BIAS::Vector2<double> > centroids;
  GetCentroids(centroids);
  BIASBlob blob;
  blobs.clear();
  for(unsigned int i=0;i<centroids.size();i++){
    blob.UL[0] = (double)TopLefts_[i][0];
    blob.UL[1] = (double)TopLefts_[i][1];
    blob.LR[0] = (double)BotRights_[i][0];
    blob.LR[1] = (double)BotRights_[i][1];
    blob.weight = 0;
    blob.centerofmass = centroids[i];
    blobs.push_back(blob);
  }   
  return ret;
}


template <class StorageType> void
BlobDetectorCCA<StorageType>::
Init_(const Image<StorageType> &img){  
  Label::LabelInit_(img); 
  bIsInited_=true;
}


template <class StorageType> int
BlobDetectorCCA<StorageType>::
Process_(Image<StorageType> &img, float percent,
        bool neighborHood4) 
{

  unsigned int pixelAllowed= (unsigned int)((float)img.GetPixelCount() 
                                            * (percent / 100.0) + 0.5);
#ifdef BIAS_DEBUG
  if (img.GetChannelCount() !=1) {
    BIASERR("Filter::CCA()  only implemented for grey images");
    return -1;
  }
#endif
  ImageConvert::ConvertST(img, LabelSumImage_ , LABEL_STORAGE_TYPE);

  int count=Label4Neighbour_();
#ifdef BIAS_DEBUG
  if (count>=255) 
    BIASERR("WARNING: CCA: 255 blobs found, there are probably more."<<
            "If so, CCA did not work correctly, "<<
            "make sure there are less regions!");
#endif
  BIASCDOUT(D_LABEL, "found "<<count<<" blobs");
  BlobCount_.clear();
  TopLefts_.clear(); 
  BotRights_.clear();

  LABEL_CALC_TYPE **ida=LabelResultImage_.GetImageDataArray();
  int width, height;
  width=LabelResultImage_.GetWidth();
  height=LabelResultImage_.GetHeight();  
  if (count==0) { 
    BlobCount_.push_back(0);
  } else {
    //ImageIO::Save("sim.mip", LabelResultImage_);
    // initialize data structs
    BlobCount_.resize(count);
    TopLefts_.resize(count);
    BotRights_.resize(count);
    SortVec_.resize(count);
    allBlobs_.resize(count);
    Num_.clear();
  
    for (int ii=0; ii<count; ii++){
      SortVec_[ii].bc=0;
      SortVec_[ii].tl.Set(width, height);
      SortVec_[ii].br.Set(0, 0);
    }
    // now get values
  

    LABEL_CALC_TYPE c=0, i=0;

    for (int y=0; y<height; y++) {
      for (int x=0; x<width; x++) {
        c=ida[y][x];
        i=0;
        while ((unsigned int)i<Num_.size() && Num_[i]!=c) i++;
        if ((unsigned int)i==Num_.size()) Num_.push_back(c);
        SortVec_[i].bc++; // BlobCount_[i]++;
        if (SortVec_[i].tl[0]>x) SortVec_[i].tl[0]=x;
        if (SortVec_[i].tl[1]>y) SortVec_[i].tl[1]=y;
        if (SortVec_[i].br[0]<x) SortVec_[i].br[0]=x;
        if (SortVec_[i].br[1]<y) SortVec_[i].br[1]=y;
        allBlobs_[i].push_back(BIAS::Vector2<int>(x,y));
      }
    }
    sort(SortVec_.begin(), SortVec_.end());
    for (int ii=0; ii<count; ii++) {
      BlobCount_[ii]=SortVec_[ii].bc;
      TopLefts_[ii]=SortVec_[ii].tl;
      BotRights_[ii]=SortVec_[ii].br;
    }
  }

  //// now delete small regions 
  sort(allBlobs_.begin(), allBlobs_.end(), Compare()); 
  StorageType **data=img.GetImageDataArray();
  if (percent<0) { // delete all except first region
    for (unsigned int r=2;r<allBlobs_.size();r++) 
      for (unsigned int p=0;p<allBlobs_[r].size();p++) 
        data[allBlobs_[r][p][1]][allBlobs_[r][p][0]]=0;
  } else { // delete too small regions
    for (unsigned int r=0;r<allBlobs_.size();r++) 
      if ((unsigned int)(BlobCount_[r])<pixelAllowed) 
        for (unsigned int p=0;p<allBlobs_[r].size();p++) 
          data[allBlobs_[r][p][1]][allBlobs_[r][p][0]]=0;
  }

  return 0;
}

template <class StorageType> int
BlobDetectorCCA<StorageType>::
Process8_(Image<StorageType> &/*img*/, float /*percent*/)
{
#ifdef BIAS_DEBUG
  BIASERR("8 neighborhood not yet implemented");  
#endif
 
  return -1;
}

template <class StorageType> int
BlobDetectorCCA<StorageType>::
GetCentroids(std::vector<BIAS::Vector2<double> > &centroids) {
  centroids.clear();
  if (allBlobs_.size()<1) {
    return 0;
  }  
  BIAS::Vector2<double> center;
  for (unsigned int r=0;r<allBlobs_.size();r++) {
    center[0]=0; center[1]=0;
    for (unsigned int i=0;i<allBlobs_[r].size();i++) {
      center[0]+= allBlobs_[r][i][0];
      center[1]+= allBlobs_[r][i][1];
    }
    center[0]/=(double)(allBlobs_[r].size());
    center[1]/=(double)(allBlobs_[r].size());
    centroids.push_back(center);
  }
  return 0;
}

template <class StorageType> int
BlobDetectorCCA<StorageType>::
GetMedians(std::vector<BIAS::Vector2<unsigned int> > &medians)
{
  medians.clear();
  if (allBlobs_.size()<1) {
    return 0;
  }
  std::vector<unsigned int> xValues, yValues;
  xValues.reserve(allBlobs_[0].size());
  yValues.reserve(allBlobs_[0].size());

  BIAS::Vector2<unsigned int> center;
  for (unsigned int r=0;r<allBlobs_.size();r++) {
    xValues.clear(); yValues.clear();
    for (unsigned int i=0;i<allBlobs_[r].size();i++) {
      xValues.push_back( allBlobs_[r][i][0]);
      yValues.push_back( allBlobs_[r][i][1]);
    }
    sort(xValues.begin(), xValues.end());
    center[0]=xValues[xValues.size() / 2];
    center[1]=yValues[yValues.size() / 2];
    medians.push_back(center);
  }
  return 0;
}


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

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