/*M/////////////////////////////////////////////////////////////////////////////////////// // // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // // By downloading, copying, installing or using the software you agree to this license. // If you do not agree to this license, do not download, install, // copy or use the software. // // // License Agreement // For Open Source Computer Vision Library // // Copyright (C) 2015, Smart Engines Ltd, all rights reserved. // Copyright (C) 2015, Institute for Information Transmission Problems of the Russian Academy of Sciences (Kharkevich Institute), all rights reserved. // Copyright (C) 2015, Dmitry Nikolaev, Simon Karpenko, Michail Aliev, Elena Kuznetsova, all rights reserved. // Third party copyrights are property of their respective owners. // // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: // // * Redistribution's of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // // * Redistribution's in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation // and/or other materials provided with the distribution. // // * The name of the copyright holders may not be used to endorse or promote products // derived from this software without specific prior written permission. // // This software is provided by the copyright holders and contributors "as is" and // any express or implied warranties, including, but not limited to, the implied // warranties of merchantability and fitness for a particular purpose are disclaimed. // In no event shall the Intel Corporation or contributors be liable for any direct, // indirect, incidental, special, exemplary, or consequential damages // (including, but not limited to, procurement of substitute goods or services; // loss of use, data, or profits; or business interruption) however caused // and on any theory of liability, whether in contract, strict liability, // or tort (including negligence or otherwise) arising in any way out of // the use of this software, even if advised of the possibility of such damage. // //M*/ #ifndef __OPENCV_FAST_HOUGH_TRANSFORM_HPP__ #define __OPENCV_FAST_HOUGH_TRANSFORM_HPP__ #ifdef __cplusplus #include "opencv2/core.hpp" namespace cv { namespace ximgproc { /** * @brief Specifies the part of Hough space to calculate * @details The enum specifies the part of Hough space to calculate. Each * member specifies primarily direction of lines (horizontal or vertical) * and the direction of angle changes. * Direction of angle changes is from multiples of 90 to odd multiples of 45. * The image considered to be written top-down and left-to-right. * Angles are started from vertical line and go clockwise. * Separate quarters and halves are written in orientation they should be in * full Hough space. */ enum AngleRangeOption { ARO_0_45 = 0, //< Vertical primarily direction and clockwise angle changes ARO_45_90 = 1, //< Horizontal primarily direction and counterclockwise angle changes ARO_90_135 = 2, //< Horizontal primarily direction and clockwise angle changes ARO_315_0 = 3, //< Vertical primarily direction and counterclockwise angle changes ARO_315_45 = 4, //< Vertical primarily direction ARO_45_135 = 5, //< Horizontal primarily direction ARO_315_135 = 6, //< Full set of directions ARO_CTR_HOR = 7, //< 90 +/- atan(0.5), interval approximately from 64.5 to 116.5 degrees. //< It is used for calculating Fast Hough Transform for images skewed by atan(0.5). ARO_CTR_VER = 8 //< +/- atan(0.5), interval approximately from 333.5(-26.5) to 26.5 degrees //< It is used for calculating Fast Hough Transform for images skewed by atan(0.5). }; /** * @brief Specifies binary operations. * @details The enum specifies binary operations, that is such ones which involve * two operands. Formally, a binary operation @f$ f @f$ on a set @f$ S @f$ * is a binary relation that maps elements of the Cartesian product * @f$ S \times S @f$ to @f$ S @f$: * @f[ f: S \times S \to S @f] * @ingroup MinUtils_MathOper */ enum HoughOp { FHT_MIN = 0, //< Binary minimum operation. The constant specifies the binary minimum operation //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = \min(x, y) @f] FHT_MAX = 1, //< Binary maximum operation. The constant specifies the binary maximum operation //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = \max(x, y) @f] FHT_ADD = 2, //< Binary addition operation. The constant specifies the binary addition operation //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = x + y @f] FHT_AVE = 3 //< Binary average operation. The constant specifies the binary average operation //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = \frac{x + y}{2} @f] }; /** * @brief Specifies to do or not to do skewing of Hough transform image * @details The enum specifies to do or not to do skewing of Hough transform image * so it would be no cycling in Hough transform image through borders of image. */ enum HoughDeskewOption { HDO_RAW = 0, //< Use raw cyclic image HDO_DESKEW = 1 //< Prepare deskewed image }; /** * @brief Specifies the degree of rules validation. * @details The enum specifies the degree of rules validation. This can be used, * for example, to choose a proper way of input arguments validation. */ typedef enum { RO_STRICT = 0x00, ///< Validate each rule in a proper way. RO_IGNORE_BORDERS = 0x01, ///< Skip validations of image borders. } RulesOption; /** * @brief Calculates 2D Fast Hough transform of an image. * @param dst The destination image, result of transformation. * @param src The source (input) image. * @param dstMatDepth The depth of destination image * @param op The operation to be applied, see cv::HoughOp * @param angleRange The part of Hough space to calculate, see cv::AngleRangeOption * @param makeSkew Specifies to do or not to do image skewing, see cv::HoughDeskewOption * * The function calculates the fast Hough transform for full, half or quarter * range of angles. */ CV_EXPORTS_W void FastHoughTransform( InputArray src, OutputArray dst, int dstMatDepth, int angleRange = ARO_315_135, int op = FHT_ADD, int makeSkew = HDO_DESKEW ); /** * @brief Calculates coordinates of line segment corresponded by point in Hough space. * @param houghPoint Point in Hough space. * @param srcImgInfo The source (input) image of Hough transform. * @param angleRange The part of Hough space where point is situated, see cv::AngleRangeOption * @param makeSkew Specifies to do or not to do image skewing, see cv::HoughDeskewOption * @param rules Specifies strictness of line segment calculating, see cv::RulesOption * @retval [Vec4i] Coordinates of line segment corresponded by point in Hough space. * @remarks If rules parameter set to RO_STRICT then returned line cut along the border of source image. * @remarks If rules parameter set to RO_WEAK then in case of point, which belongs the incorrect part of Hough image, returned line will not intersect source image. * * The function calculates coordinates of line segment corresponded by point in Hough space. */ CV_EXPORTS_W Vec4i HoughPoint2Line(const Point &houghPoint, InputArray srcImgInfo, int angleRange = ARO_315_135, int makeSkew = HDO_DESKEW, int rules = RO_IGNORE_BORDERS ); } }// namespace cv::ximgproc #endif //__cplusplus #endif //__OPENCV_FAST_HOUGH_TRANSFORM_HPP__