CornerDetectorCSS.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLCV/src/ICLCV/CornerDetectorCSS.h                    **
** Module : ICLCV                                                  **
** Authors: Erik Weitnauer                                         **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.GPL  **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLUtils/Point32f.h>
#include <ICLCore/Types.h>
#include <vector>
#include <ICLUtils/Configurable.h>

namespace icl{
  namespace cv{
  

    class CornerDetectorCSS : public utils::Configurable{
      public:
      struct GaussianKernel {
        std::vector<icl32f> gau;
        float sigma;
        float cutoff;
        int width; // only one side of the gaussian, gau has width*2+1 elements!
        GaussianKernel(): sigma(0), cutoff(0), width(0) {}
      };
      
      struct DebugInformation {
        GaussianKernel gk;
        std::vector<utils::Point32f> boundary;
        std::vector<utils::Point32f> smoothed_boundary;
        std::vector<float> kurvature;
        std::vector<int> extrema;
        std::vector<int> maxima;
        std::vector<int> maxima_without_round_corners;
        std::vector<int> maxima_without_false_corners;
        std::vector<utils::Point32f> corners;
        std::vector<float> angles;
        int offset; // the number of additional points at begin and end of
        // smoothed_boundary and kurvature
        float angle_thresh;
        float rc_coeff;
        float straight_line_thresh;
      };
      
      CornerDetectorCSS(float angle_thresh=162.,
                        float rc_coeff=1.5, 
                        float sigma=3., 
                        float curvature_cutoff=100., 
                        float straight_line_thresh=0.1):
      angle_thresh(angle_thresh), rc_coeff(rc_coeff), sigma(sigma), 
      curvature_cutoff(curvature_cutoff), straight_line_thresh(straight_line_thresh),
      debug_mode(false) {};
  
      virtual void setPropertyValue(const std::string &propertyName, 
                                    const utils::Any &value) throw (utils::ICLException);
      
      virtual std::vector<std::string> getPropertyList() const;
      
      virtual std::string getPropertyType(const std::string &propertyName) const;
      
      virtual std::string getPropertyInfo(const std::string &propertyName) const;
      
      virtual utils::Any getPropertyValue(const std::string &propertyName) const;
        
      virtual inline int getPropertyVolatileness(const std::string &propertyName) const { return 0; }
      
      virtual std::string getPropertyToolTip(const std::string &propertyName) const;
      

      static int gaussian(GaussianKernel &gauss, float sigma, float cutoff);
      

      const std::vector<utils::Point32f> &detectCorners(const std::vector<utils::Point32f> &boundary);
      
      const std::vector<utils::Point32f> &detectCorners(const std::vector<utils::Point> &boundary);
      

      inline const std::vector<utils::Point32f> &getLastCorners() const {
        return corners;
      }
      
      const std::vector<float> &getCornerAngles() const { return corner_angles; }
  
      inline void setAngleThreshold(float value){ angle_thresh = value; }
      inline void setRCCoeff(float value){ rc_coeff = value; }
      inline void setSigma(float value){ sigma = value; }
      inline void setCurvatureCutoff(float value){ curvature_cutoff = value; }
      inline void setStraightLineThreshold(float value) { straight_line_thresh = value; }
  
      inline float getAngleThreshold() const { return angle_thresh;}
      inline float getRCCoeff() const { return rc_coeff; }
      inline float getSigma() const { return sigma; }
      inline float getCurvatureCutoff() const { return curvature_cutoff; }
      inline float getStraightLineThreshold() const { return straight_line_thresh;}
  
      inline void setDebugMode(bool value) { debug_mode = value; }
      const DebugInformation &getDebugInformation() const throw (utils::ICLException){ 
        if(!debug_mode) throw utils::ICLException("CornerDetectorCSS::getDebugInformation: not possible: debug mode is off");
        return debug_inf; 
      } 
  

      static void convolute_1D(float *vec, int dim, float *kernel, int kernelDim, float *dst);
        
      private:
      float angle_thresh, rc_coeff, sigma, curvature_cutoff, straight_line_thresh;
      bool debug_mode;
  
      GaussianKernel m_gauss;
                        

      static void findExtrema(std::vector<int> &extrema, icl32f* x, int length);
  

      static void removeRoundCorners( float rc_coeff, icl32f* k, std::vector<int> &extrema);
  

      static void removeFalseCorners(float angle_thresh, icl32f* xx, icl32f* yy, icl32f* k, 
                                     int length, std::vector<int> &maxima, std::vector<float> &corner_angles,
                                     float straight_line_thresh);
  

      static float tangentAngle(icl32f* x, icl32f* y, int length, int center, float straight_line_thresh);
  
      // result lists
      std::vector<utils::Point32f> corners;
      std::vector<float> corner_angles;
      std::vector<int> extrema;
      std::vector<utils::Point32f> inputBuffer;
      DebugInformation debug_inf;
    };
  } // namespace core
}