BlobDetectorDOM.hh

/*
 * BlobDetectorDOM.hh
 *
 *  Created on: Nov 10, 2009
 *      Author: jordt
 */

#ifndef BLOBDETECTORDOM_HH_
#define BLOBDETECTORDOM_HH_

// includes
#include <bias_config.h>
//#include <vector>
#include <Base/Math/Vector2.hh>
#include <Base/Image/Image.hh>
#include <Base/Geometry/HomgPoint2D.hh>
#include "BlobDetectorBase.hh"

namespace BIAS {

  /**
     @class BlobDetectorDOM
     Blob detector for 'Difference Of Means'-blobs (so this is not a binary blob detector). Blob 
     detection is done by distributing
     starting points in the DOM-Space (3dimensional, image dimensions + scale). An element of the 
     DOM space is given by the difference between the mean value of a square area at a certain position +
     size and the mean value of the surrounding square (double sized). Initial seeds in the DOM space
     are used to converge to local minima => DOM blobs. This implementation uses sum-images (integral images)
     to speed up the calculation.
      @author jordt 11/2009
     
  */
  template <class StorageType>
  class BIASFeatureDetector_EXPORT BlobDetectorDOM :
    public BlobDetectorBase<StorageType>
  {
  public:
    /**
       @brief standard constructor
    */
    BlobDetectorDOM();

    /**
       @brief standard destructor
    */
    virtual ~BlobDetectorDOM();

    /**
       @brief Detect and return blobs in an image
       @param[in] image the image to detect blobs in
       @param[out] vector to store the blobs in. If the vector is empty, seeds are generated
                   automatically according to the settings. If the vector allready contains blobs,
                   these blobs are optimized. 
       @return 0 on success, -1 on failure
    */
    int Detect(BIAS::Image<StorageType> &image, std::vector<BIAS::BIASBlob> &blobs);


    /**
       @brief draws the detected blobs in image
       @param image image the blobs are drawn in here
       @return 0 on success, -1 on failure
    */
    int DrawInImage(BIAS::Image<StorageType> &image, StorageType* color);


    /**
          @brief Set threshold for blob detection
          @param threshold Difference threshold between background and blob content
    */
    void SetThreshold(float threshold);
      
    
    /**
     *    Allow just a maximum number of DOM extrema in one cabin.
          @brief Set the cabin-optimization parameters
          @param cabinsPerAxis The number of cabins per axis, i.e. the square root of the overall number of cabins
          @param maxPopulation the maximum number of DOM extrema in one cabin
    */
    void SetCabin(int cabinsPerAxis, int maxPopulation);
      

    /**
          @brief Set minimum size of blobs
          @param minsize Minimum size in pixel
    */
    void SetMinSize(unsigned int minSize);
    
    /**
          @brief Set maximum size of blobs
          @param maxsize Maximum size in pixel
    */
    void SetMaxSize(unsigned int maxSize);
    
    
    /**  Returns the blobs generated by Detect() as HomgPoin2D vector and quality vector (Like feature points).
              @brief Get blobs as HomgPoin2D vector
              @param blobs Location vector, 3rd component is the size
              @param qual_vec Quality vector, contains the actual difference of means
        */
    void GetBlobsAsHomgPoint2D(std::vector<HomgPoint2D> &blobs, std::vector<float> &qual_vec);
    
    
    /**  If the automatic seed generation is used (by passing an empty
     *   vector to the Detect() function), the seeds are generated by this parameters.
     *  @brief Set seed parameters for auto seed generation
     *  @param minSeedSize Size of the smallest blob seeds
     *  @param maxSeedSize Size of the largest blob seeds
     *  @param seedStepSize Step size to get from minSeedSize to maxSeedSize
       */
    void SetSeedGenerationParams(unsigned int minSeedSize, 
                                     unsigned int maxSeedSize,
                                     unsigned int seedSizeStep);

    float GetAbsoluteDOM(int x, int y, int halfLevelSize);

  protected:
    
    void refineBlobPosAndSize(Image<StorageType> img);
    
    void GenerateAndOptimize(std::vector<HomgPoint2D> &pos_vec, std::vector<float> &qual_vec);
    HomgPoint2D GetLocalMaximum(int x, int y, int halfLevelSize);

    float GetDOM(int x, int y, int halfLevelSize);

    float diffThreshold_;
    unsigned int minBlobSize_;
    unsigned int maxBlobSize_;
    unsigned int minSeedSize_;
    unsigned int maxSeedSize_;
    unsigned int seedSizeStep_;
    unsigned int numberOfBins_;
    unsigned int maximumBinPopulation_;
    unsigned int similarityThreshold_;
    std::vector<HomgPoint2D> generatedBlobs_;
    std::vector<float> blobQualityVec_;

    
    
    // Integral image routines:
    
    void CreateIntegralImage(Image<StorageType> &in);
    
    double EvalIntegralImage(int xA, int yA, int xB, int yB);
    
    double* intImg_;
    unsigned int width_;
    unsigned int height_;    
    

  }; // class BlobDetectorDOM

} // namespace


#endif /* BLOBDETECTORDOM_HH_ */