#ifndef REGIONBASEDBLOBSEARCHER_H
#define REGIONBASEDBLOBSEARCHER_H
#include <Array.h>
#include <Size.h>
#include <Point.h>
#include <Rect.h>
#include <ICLTypes.h>
#include <map>


namespace icl{

  struct lessSize {
     bool operator()(const icl::Size& lhs, const icl::Size& rhs) const {
        return lhs.width < rhs.width && lhs.height < rhs.height;
     }
  };
  
  class Converter; // converts all images
 
  class ImgRegionDetector;  // seaches connected regions 
  class RegionDetectorBlob; // a found blob and all params
  
  /// discrimimator for a found regions
  /** The RegionFilter (RF) class filters a set of given Regions in two
      steps:
      -# Filter the regions by a size- and value- interval
      -# Filter the regions by position, value, and optionally higher level features
         like the bounding box and the major axis and corresponding arcs.
      
      The devision of the filter process is reasoned in the internal implementation of
      the region extraction algorithm. The used ImgRegionDetector provides a
      direct repulsion of too small, too large, too dark and too bright regions.
      @see RegionBasedBlobSearcher for more details 
  */
  struct RegionFilter{

    // Destructor
    virtual ~RegionFilter(){}

    /// defines the minimum size of a blob
    virtual unsigned int getMinSize()=0;

    /// defines the maximum size of a blob
    virtual unsigned int getMaxSize()=0;
    virtual icl8u getMinVal()=0;
    virtual icl8u getMaxVal()=0;
    virtual bool needSpecialFeatures(){ return false; }
    virtual bool ok(icl8u value, int x, int y){
      (void)value; (void)x; (void)y; 
      return false;
    }
    virtual bool ok(icl8u value, int x, int y, int *bb, icl32f *pca){
      (void)value; (void)x; (void)y; (void)bb; (void)pca;
      return false;
    }
    static RegionFilter *getDefaultRegionFilter(unsigned int minSize, unsigned int maxSize,
                                                icl8u minVal, icl8u maxVal, 
                                                bool specialFeaturesEnabled);
                                                
  };

  /// interface for Feature Map creators
  /** see RegionBasedBlobSearcher for more details */
  struct FMCreator{
    virtual ~FMCreator(){};
    virtual Size getSize()=0;
    virtual format getFormat()=0;
    virtual Img8u* getFM(Img8u *image)=0;
    virtual RegionFilter *getFilter()=0;


    static FMCreator *getDefaultFMCreator(const Size &size, 
                                          format fmt,
                                          std::vector<icl8u> refcolor,
                                          std::vector<icl8u> thresholds,
                                          RegionFilter *rf);
  };


  /// Class to detect a set of blobs in an image using a region based approach
  /** The basic idea of the ReagionBasedBlobSearcher (RBBS) is simple:
      - create an Image where the homogenous segments comply supposed blobs
      - extract all image regions (with pixel-precision) into a list of regions
      - remove all regions/blobs, which params (size, value, ...) do not match
        to the searched blobs
      - use the bounding boxes, or the centers of the remaining regions as blob info
  
     The RBBS complies a more convenient wrapper of the ImgRegionDetector class.
  
     <h2>Details</h2>
     The above description poses three quetions:
     -# How can we create a feature map ?
     -# How can we reject bad regions ?
     -# How can we handle all that together ?
     
     <h3>How can we create a feature map and How can we reject bad regions </h3>
     The RegionBasedBlobSearcher (RBBS) provides an interface for adding and removing
     so called FMCreators (see FMCreator). Each of this objects can tell the 
     parent RBBS which certain image format and size it needs to create a new feature 
     map. In addition the FMCreator offers an own so called RegionFilter, which is
     another user-definable class interface. Each region, extracted from the 
     freature map of the FMCreator by the RBBS, is given to the corresponding RegionFilter
     to decide if the regions has to be accepted or rejected. Some RegionFilters are able
     to decide this only by some the simple features: x-position, y-position and value of
     the region; Other will additionally factor in so advanced features: The Regions
     bounding box and the regions major axis' and arcs. 
     
     <h3>How can we handle all that together</h3>
     The RegionBasedBlobSearcher (RBBS) provides an easy to use interface to tackle all
     the above mentioned meanisms. To allow inexperienced users a quick entrance, the 
     member function addDefaultFMCreator(..) can be used to add a simple color map
     based FMCreator-object. 
  
  */
  class RegionBasedBlobSearcher{
    public:
    
    /// Create a new RegionBasedBlobSearcher without any FMCreator
    RegionBasedBlobSearcher();

    /// Destructor (delets all contained FMCreators)
    ~RegionBasedBlobSearcher();
    
    /// 1st working method: extract centers by using all FMCreators
    const Array<int> &getCenters(ImgBase *image);

    /// 2nd working method: extract bounding boxes by using all FMCreators
    /** This function produces valid resuls only for RegionFilters 
        that use the "special-features" */
    const Array<int> &getBoundingBoxes(ImgBase *image);

    
    /// 3rd working method: extract pca info
    /** Data order is [axis1-length, axis2-length, axis1-angle, axis2-angle, ...] */
    const Array<float> &getPCAInfo(ImgBase *image);

    /// Combined working method, extracting all information at once
    void detectAll(ImgBase *image, Array<int> &centers, Array<int> &boundingBoxes, Array<float> &pcaInfos); 
    
    /// add new FMCreator
    /** ownership is passed to the RegionBasedBlobSearcher*/
    void add(FMCreator* fmc);

    /// remove FMCreator
    /** ownership is passed back to the caller*/
    void remove(FMCreator *fmc);

    /// removes all FMCreators
    /** the objects are deleted, as the owner is the RegionBasedBlobSearcher*/
    void removeAll();

    /// adds an anonymous DefaultFMCreator with given params
    /** Because of the its anomymity, the FMCreator is owned by the
        RegionBasedBlobSearcher
        The new FMCreator will create the feature map using the following algorithm:
        <pre>
        I = input-image converted to size "imageSize" and format "imageFormat"
        {the example is written for a 3-channel rgb image it is generalizable for abitrary formats}
        [r,g,b] = "refcolor"       
        [tr,tg,tb] = thresholds  
        for all pixel p=(x,y) I do
           dr = abs( I(x,y,0) - r )
           dg = abs( I(x,y,1) - g )
           db = abs( I(x,y,2) - b )
           RESULT(x,y) = (dr<tr && dg<tg && db<tb) * 255;
        done
        </pre>
    */
    void addDefaultFMCreator(const Size &imageSize,
                             format imageFormat,
                             std::vector<icl8u> refcolor,
                             std::vector<icl8u> thresholds,
                             unsigned int minBlobSize,
                             unsigned int maxBlobSize,
                             bool enableSpecialFeatures = true);
                             


    private:
    // ::functions::
    
    /// returns the current input image in the given format and size
    Img8u *getImage(const Size &size, format fmt);       

    /// 1st: use all fms to create a list of regions
    void extractRegions();
    
    /// 3rd: unify dublicated regions
    void unifyRegions();
    
    // ::member data::

    // layer 1 converter
    Converter *m_poConverter;                            //!< used converter instance
    
    typedef std::map<icl::format,Img8u*> fmtmap;
    typedef std::map<icl::Size,fmtmap,lessSize> sizemap;
    sizemap m_mmImages;  //!< map of map of converted images
        
    // FM-Creators
    Array<FMCreator*> m_oFMCreators;    //!< array of all fm-creators
    
    // RegionDetector
    ImgRegionDetector *m_poRD;          //!< detects connected regions
    Array<Array<Point> > m_oPoints;     //!< buffer of all center lists
    Array<Array<Rect> > m_oRects;       //!< buffer of all b.b. lists
    Array<Array<float> > m_oPCA;        //!< buffer for pca info 
    
    
    /// inupt and ouput data
    ImgBase *m_poInputImage;            //!< input image
    Array<int> m_oOutputBuffer;         //!< output-buffer (used for centers and b.b.)
    Array<float> m_oOutputBufferF;      //!< float output-buffer (used for the pca infos )

  };
}

#endif