BlobDetectorBFS.hh

#ifndef __BLOBDETECTOR_BFS_hh__
#define __BLOBDETECTOR_BFS_hh__

// includes
#include <bias_config.h>
#include <Base/Math/Vector2.hh>
#include <Base/Image/Image.hh>
#include <Filter/Gauss.hh>
#include "BlobDetectorBase.hh"

namespace BIAS {

  typedef std::vector<BIAS::Vector2<unsigned int> > PointQueue;

  /**
     @class BlobDetectorBFS
     Detects multiple blobs in an image, image has to be black
     except blocks to detect
     @author fkellner/ischiller 07/2008
     @ingroup g_feature
  */
  template <class StorageType>
  class BIASFeatureDetector_EXPORT BlobDetectorBFS :
    public BlobDetectorBase<StorageType>
  {
  public:
    /**
       @brief standard constructor
    */
    BlobDetectorBFS();

    /**
       @brief standard destructor
    */
    virtual ~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 sucess, -1 on failure
    */
    int Detect(BIAS::Image<StorageType> &image,
               std::vector<BIAS::BIASBlob> &blobs);


    /**
       @brief set a ROI (region of interest) in the image to detect
       @param UL Vector2 containing upper left corner
       @param LR Vector2 containing lower right corner
    */
    void SetROI(const BIAS::Vector2<unsigned> &UL,const BIAS::Vector2<unsigned> &LR){
      UL_ = UL;
      LR_ = LR;
    }

    /**
       @brief return largest blob (bounding box)
       @param corners largest detected blob
       @return 0 on sucess, -1 on failure
    */
    int GetLargestBoundingBox(BIAS::BIASBlob &corners) {
      if (maxCorners_.weight == 0)
        return -1;
      corners = maxCorners_;
      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
    */
    int DrawInImage(BIAS::Image<StorageType> &image);


    /**
          @brief set threshold for blobdetection
          @param threshold difference between background (black) and blob content
    */
    void SetThreshold(StorageType threshold){
      threshold_=threshold;
    }

    /**
          @brief set sigma for gaussian blurr before blobdetection
          @param sigma the gauss sigma
    */
    void SetGaussSigma(double sigma){
      gaussSigma_ = sigma;
    }

    /**
          @brief set minimum size of blobs
          @param minsize minimum size in pixel
    */
    void SetMinSize(unsigned minSize){
      minWeight_ = minSize;
    }

    void SetMaxSize(unsigned maxSize){
      maxWeight_ = maxSize;
    }
    /**
          @brief setting this true will clear pixels (0) in clusters of weight < minWeight
          @param erase true to clean up
    */
    void SetEraseBelowMinSize(bool erase){
      eraseBelowMinWeight_ = erase;
    }

  protected:
    /**
       @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
    */
    int 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);

  protected:
    BIAS::Image<unsigned char>           marker_, markerBackup_;
    BIAS::Vector2<unsigned>              UL_,LR_;
    BIAS::BIASBlob                       maxCorners_;
    std::vector<BIAS::BIASBlob>          corners_;
    StorageType                          threshold_;
    double                               gaussSigma_;
    BIAS::Gauss<StorageType,StorageType> smoothFilter_;
    BIAS::Image<StorageType>             imageSmooth_;
    unsigned                             minWeight_,maxWeight_;
    bool                                 eraseBelowMinWeight_;
    
  private:
    PointQueue queue;
    PointQueue cluster;
    unsigned int n[16];

  }; // class BlobDetectorBFS

} // namespace

#endif // __BLOBDETECTOR_BFS_hh__