ContourDetectorSimple.hh

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003-2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef __CONTOURDETECTORSIMPLE_HH__
#define __CONTOURDETECTORSIMPLE_HH__

// std includes
#include <vector>

// BIAS includes
#include <Base/Image/Image.hh>
#include <Base/Math/Vector2.hh>
#include "ContourDetectorBase.hh"

namespace BIAS {

  /**
      @class ContourDetectorSimple
      @brief a class for calculating the contour of a segmented region
      @author Dennis Herzog, Jan. 2005 ischiller 08/08
      @ingroup g_feature
  */
  template <class StorageType>
  class BIASFeatureDetector_EXPORT ContourDetectorSimple :
    ContourDetectorBase<StorageType>
  {
  public:

    ContourDetectorSimple();
    ~ContourDetectorSimple();

    /**
     * @brief detect function of ContourDetectorSimple
     * @param image (input) an image with a constant background 
     * and an object of which the contour is to be calculated   
     * @param contour (output) the contours of the detected objects, 
     * currently only one contour is searched
     * @return <0=error, >0 length of contour in pixel
     * @author ischiller 
     * @date 12/09
     */
    int Detect(Image<StorageType>& image,
               std::vector<BIAS::BIASContour>& contour);

    /** @brief returns a Borgefor distance transformed image (returned in 'dist_img')
        of the pixel set given by the contour pixels in 'contour'
        @author herzog
        @param dist_im (output) the Borgefor distance image
        @param contour (input) the already detected contour by a call to Detect(...)
    */
    void CreateDistanceImage(BIAS::Image<StorageType>& dist_img,
                                const BIASContour& contour);

    /** @brief returns a Borgefor distance transformed image of the contour pixel
        set of the first blob found in the image 'img'.
        @author herzog
        @param img (input) source image, from which the contour comes
        @param dist_img (output) returns the distance transformed image of the contour
        @return <0=error, > 0 length of contour in pixel 
    */
    int CreateDistanceImageByContour(BIAS::Image<StorageType>& dist_img,
                                         BIAS::Image<StorageType>& img);

    /** @brief draws the contour in the given image as white line        
        @author ischiller
        @param image (input) image in which to draw the contour. Has to be initialized with the correct size     
        @return false=no contour available, true=drawing successful  
    */
    bool GetContourImage(BIAS::Image<unsigned char>& image, const std::vector<BIASContour>& contour);
    
    /** @brief instead of contour pixels
        a start point and a list of difference vector (created during
        surrounding the blob clock wise) is given
        @author herzog
        @return directionList difference vectors coded in FreeManCode
        (that means: (
        0 = step right --
        1 = step right & step down --
        2 = step down --
        3 = step left & step down --
        4 = step left --
        5 = step left & up
        6 = step up --
        7 = step right & step up))
    */
    inline std::vector<int>& GetFreemanCode() { return directionList_;}

    /**
       @brief Set the background color if it is different from 0
       @param backgroundColor (input) the new background color
    */
    inline void SetBackground(StorageType backgroundColor)
    { background_=backgroundColor;}
    
    /**
    * @brief Set the maximum gap which is bridged in search for contour
    * @param gap (input) the new max gap (default 5)
    */
    inline void SetGap(int gap=5){
        gap_ = gap;
    }

  protected:
   /** @brief creates the contour of the first blob found in the image;
    *          a pixel is assumed as foreground pixel, if the pixel value is != 0;
    *          this function works even if the blob is located at the image frame
    *    @author herzog
    *    @param contour 
    *    @return true=ok, false=no contour detected
    */
    bool CreateContourBase_(BIAS::BIASContour &contour, BIAS::Image<StorageType> &img);

    /** 
     * @brief Initializes the distance image
     */
    void InitDistanceImage_(BIAS::Image<StorageType>& img,const BIASContour& contour);
    
    /** converts the given image to an distance transformed image (the Borgefor
        distance is used, that means one step in diagonal direction has a
        distance of 4 other steps have distances of 3);
        the underlying pixel set has to be marked as zero valued pixels --
        all other pixels have to be set to a high value (MAX_USHORT)
        @author herzog
        @param img input and output image
    */
    void MakeDistanceImage_(BIAS::Image<StorageType>& img);


    /**
     * @brief determines of a pixel is foreground or not
     * @param x (input) x position of pixel
     * @param y (input) y position of pixel
     * @return true=is foreground, false=not foreground
     */
    inline bool IsFg_(int x, int y) {      
      StorageType pixel = data_[y][x];     
      return !( pixel == background_ );
    }
    
    /**
    * @brief returns IsFg_ of the next pixel in the direction of param direction
    * @param x (input) x position of pixel
    * @param y (input) y position of pixel
    * @param direction (input) direction of next pixel (freeman code)
    * @return true=is foreground, false=not foreground
    */
    inline bool IsFg_(int x, int y, int direction) {
        switch ( (direction+16)%8 ) {
      case 0: return IsFg_(x+1,y+0);
      case 2: return IsFg_(x+0,y+1);
      case 4: return IsFg_(x-1,y+0);
      case 6: return IsFg_(x+0,y-1);
      case 1: return IsFg_(x+1,y+1);
      case 3: return IsFg_(x-1,y+1);
      case 5: return IsFg_(x-1,y-1);
      case 7: return IsFg_(x+1,y-1);
      }
      //BIASERR("IsFg: error");
      return false;
    }

    
    /**
    * @brief Finds first foreground pixel 
    * @param pos_x (output) x position of pixel
    * @param pos_y (output) y position of pixel    
    * @return true=found, false=not found 
    */
    bool FindFirst_(int &pos_x, int &pos_y);
    void Init_(BIAS::Image<StorageType> &img);

    int img_w;
    int img_h;
    StorageType background_;
    std::vector<int> directionList_;
    StorageType **data_;
    int gap_;
  };//class


  template <class StorageType>
  class BIASFeatureDetector_EXPORT DistImgMatAcc{
  public:

    DistImgMatAcc(){};
    DistImgMatAcc(BIAS::Image<StorageType> &img);
    virtual ~DistImgMatAcc(){};

    StorageType Get(int row, int col);
    void Set(int row, int col, StorageType value);

  protected:
    StorageType **data;

  };

} // namespace

#endif //__CONTOURDETECTORSIMPLE_HH__