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.LGPL **
** 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/CompatMacros.h>
#include <ICLUtils/Point32f.h>
#include <ICLUtils/Configurable.h>
#include <ICLCore/Types.h>
#include <vector>
#include <ICLUtils/Uncopyable.h>

namespace icl{
  namespace cv{


    class ICLCV_API CornerDetectorCSS : public utils::Configurable, public utils::Uncopyable{
      public:
      struct ICLCV_API 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) {}
      };

      CornerDetectorCSS(float angle_thresh=162.,
                        float rc_coeff=1.5,
                        float sigma=3.,
                        float curvature_cutoff=100.,
                        float straight_line_thresh=0.1,
                        bool accurate = false);

      ~CornerDetectorCSS();

      virtual void setPropertyValue(const std::string &propertyName,
                                    const utils::Any &value);

      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);


      template<class T> ICLCV_API
      const std::vector<std::vector<utils::Point32f> > &detectCorners(const std::vector<std::vector<T> > &boundaries, const std::vector<icl32f> &sigmas);
      template<class T> ICLCV_API
      const std::vector<utils::Point32f> &detectCorners(const std::vector<T> &boundary);


      inline const std::vector<utils::Point32f> &getLastCorners() const {
        return corners;
      }

      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 void setAccurate(bool value) { accurate = 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 bool getAccurate() const { return accurate; }


      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 accurate;

      int gauss_radius(float sigma, float cutoff);
      void fill_gauss(float *mask, float sigma, int width);
      void convolute(const float *data, int data_length, const float *mask , int mask_length, float *convoluted);
      void calculate_curvatures(const float *smoothed_x, const float *smoothed_y, int length, float curvature_cutoff, float *curvatures);
      void calculate_curvatures_bulk(int array_length, int num_boundaries, const int *lengths,
                                     const int *indices, const int *indices_padded, const float *smoothed_x, const float *smoothed_y, float curvature_cutoff, float *curvature);
      int findExtrema(int *extrema, int *num_extrema_out, float* k, int length);
      void removeRoundCorners(float rc_coeff, int maxima_offset, float* k, int length, int *extrema, int num_extrema, int *new_extrema, int *num_new_extrema_out);
      void removeRoundCornersAccurate(float rc_coeff, int maxima_offset, float* k, int length, int *extrema, int num_extrema, int *extrema_out, int *num_extrema_out);
      float cornerAngle(float *x, float *y, int prev, int current, int next, int length, float straight_line_thresh);
      float cornerAngleAccurate(float *x, float *y, int prev, int current, int next, int array_length, float straight_line_thresh);
      void removeFalseCorners(float angle_thresh, float* x, float* y, float* k, int length, int *maxima, int num_maxima, int *maxima_out, int *num_maxima_out);

      // result lists
      std::vector<utils::Point32f> corners;
      std::vector<std::vector<utils::Point32f> > corners_list;

      struct CLCurvature;
      CLCurvature *clcurvature;
      bool useOpenCL; // in case of no support, this is always false
    };
  } // namespace core
}