detection of 2D lines in gradient images using extension of Hough algorithm based on gradient orientation More...

IPSDKIPLFEATUREDETECTION_API ipsdk::imaproc::fd::HoughLinesResult	ipsdk::imaproc::fd::houghLinesGradient2d (const image::ImageConstPtr &pInGxImg, const image::ImageConstPtr &pInGyImg)
	wrapper function for detection of 2D lines in gradient images using extension of Hough algorithm based on gradient orientation More...

IPSDKIPLFEATUREDETECTION_API ipsdk::imaproc::fd::HoughLinesResult	ipsdk::imaproc::fd::houghLinesGradient2d (const image::ImageConstPtr &pInGxImg, const image::ImageConstPtr &pInGyImg, const ipsdk::imaproc::attr::HoughLinesGradientImgParamsConstPtr &pHoughLinesImgParams, const ipsdk::imaproc::attr::HoughLinesExtractionParamsConstPtr &pHoughLinesExtractionParams, const ipsdk::ipReal32 orientationTolerance)
	wrapper function for detection of 2D lines in gradient images using extension of Hough algorithm based on gradient orientation More...

IPSDKIPLFEATUREDETECTION_API ipsdk::imaproc::fd::PlanIndexedHoughLinesResult	ipsdk::imaproc::fd::multiSlice_houghLinesGradient2d (const image::ImageConstPtr &pInGxImg, const image::ImageConstPtr &pInGyImg)
	wrapper function for detection of 2D lines in gradient images using extension of Hough algorithm based on gradient orientation More...

IPSDKIPLFEATUREDETECTION_API ipsdk::imaproc::fd::PlanIndexedHoughLinesResult	ipsdk::imaproc::fd::multiSlice_houghLinesGradient2d (const image::ImageConstPtr &pInGxImg, const image::ImageConstPtr &pInGyImg, const ipsdk::imaproc::attr::HoughLinesGradientImgParamsConstPtr &pHoughLinesImgParams, const ipsdk::imaproc::attr::HoughLinesExtractionParamsConstPtr &pHoughLinesExtractionParams, const ipsdk::ipReal32 orientationTolerance)
	wrapper function for detection of 2D lines in gradient images using extension of Hough algorithm based on gradient orientation More...

Detailed Description

detection of 2D lines in gradient images using extension of Hough algorithm based on gradient orientation

This algorithm detects 2D lines in an input image using an extension of Hough algorithm based on gradient orientation. Differences with the implementation of regular Hough detector HoughLines2d are:

the algorithm takes as inputs 2 images, corresponding to the images of gradients, respectively along x-axis and y-axis. From these 2 images, the image of gradient magnitude is computed. It will be used to compute the accumulation matrix, but instead of accumulating intensity of each pixel on the whole range of possible line orientations of the $( \rho, \theta)$ parameter space , the range is restricted to $[ \theta_0 - \Delta \theta, \theta_0 + \Delta \theta ]$ , with:
- $\Delta \theta$ a tolerance specified by the user (equals to $\pi/18$ radians (10°) by default)
- $\theta_0$ the gradient orientation at current pixel, in radians, computed from the 2 input images of gradient.
Indeed, if the pixel is on a line, gradient orientation should be close to the orientation of the normal to the line. Thus, the accumulator matrix is not polluted with accumulation of intensities that are not relevant
using the gradient orientation, the total range of orientations can be extended to (instead of for HoughLines2d algorithm). Considering a straight-lined edge separating the space in 2 distinct half-spaces and , this extension enables to clearly distinguish the case where is bright and is dark from the case where is dark and is bright, what regular Hough transform cannot. We can deduce potential advantages of this property on 2 different examples:
1. let's assume that we want to find only transitions from left black to right white in the image of stripes displayed below. It would not be easy with regular Hough lines detector, because all borders would have the same orientation (they would correspond to points aligned on the same row in the accumulator matrix). With the current algorithm, on the contrary, black/white transitions and white/black transitions respectively correspond to points aligned on 2 different rows of the accumulator matrix. To filter lines we are not interested in, we just have to restrict the range of orientations to [0, 10°], for instance
2. let's consider the image displayed below (original image on the left, zoomed image on the right):
  
  In this image, we would like to detect lines corresponding to the 2 borders of the thin straight-lined object. With the regular Hough algorithm applied on image of gradient magnitude, the problem is that, depending on the resolution chosen for $\rho$ and $\theta$ , the 2 expected peaks may be merged into a single one, as shown in the following accumulator matrix obtained with RhoStep=1 pixel and ThetaStep=1° (which are the default parameters) :
  
  It results in one single line detected instead of the two expected. With the extended Hough algorithm, the two peaks are very distant one from each other, and there is no risk to observe this issue. The 2 borders of the thin stripes are correctly detected:
  
  See also
  https://www.fer.unizg.hr/_download/repository/0012-0007.pdf

Attributes description

Attribute description for algorithm :

Name	ToolTip	Default Initializer
ipsdk::imaproc::attr::InGxGreyImg2d	[Input] 2d grey levels image of gradient computed along x-axis	X
ipsdk::imaproc::attr::InGyGreyImg2d	[Input] 2d grey levels image of gradient computed along y-axis	X
ipsdk::imaproc::attr::InOptHoughLinesGradientImgParams	[Input Optional] Parameters for Hough lines detection algorithm using 2 input gradient images	X
ipsdk::imaproc::attr::InOptHoughLinesExtractionParams	[Input Optional] Parameters used for step of extraction of lines in Hough lines algorithm	X
ipsdk::imaproc::attr::InOptHoughLinesOrientationTolerance	[Input Optional] Tolerance for orientation around estimated gradient direction	X
ipsdk::imaproc::attr::OutOptRealImg	[Output Optional] image for processing operation (data contained in image buffer are reals)	X
ipsdk::imaproc::attr::OutPIHoughLines2dPpties	[Output] plan indexed collection of positions and intensities of 2d pixels	ipsdk::imaproc::fromImage (_pOutPIHoughLines2dPpties, _pInGxGreyImg2d)

Global Rule description

Global rule description for algorithm :
ipsdk::processor::If (
ipsdk::processor::isSet (_pOutOptRealImg),
ipsdk::imaproc::customImageProperty (_pOutOptRealImg,
  ipsdk::imaproc::fd::houghLines2dCheckOutImgSzXEquals (_pInGxGreyImg2d,_pInOptHoughLinesGradientImgParams)) &&
ipsdk::imaproc::customImageProperty (_pOutOptRealImg,
  ipsdk::imaproc::fd::houghLines2dCheckOutImgSzYEquals (_pInGxGreyImg2d,_pInOptHoughLinesGradientImgParams,_pInOptHoughLinesExtractionParams)) &&
ipsdk::imaproc::customImageProperty (_pOutOptRealImg,
  ipsdk::imaproc::fd::houghLines2dCheckOutImgBufferType (_pInGxGreyImg2d)) &&
ipsdk::imaproc::matchSize (eMatchImageSizeType::eMIST_T,_pInGxGreyImg2d,_pOutOptRealImg) &&
ipsdk::imaproc::matchVolumeGeometryType (_pInGxGreyImg2d,_pOutOptRealImg) &&
ipsdk::imaproc::matchColorGeometryType (_pInGxGreyImg2d,_pOutOptRealImg) &&
ipsdk::imaproc::noInSitu (_pInGxGreyImg2d,_pOutOptRealImg),
ipsdk::processor::none ())

Example of Python code :

Example imports

import PyIPSDK
import PyIPSDK.IPSDKIPLFeatureDetection as fd
import PyIPSDK.IPSDKIPLFiltering as filter

Code Example

    # opening of input image
    inImg = PyIPSDK.loadTiffImageFile(inputImgPath)
    
    # compute images of gradient along each axis, applying a gaussian gradient with
    # sigma=1
    gxImg, gyImg = filter.gaussianGradient2dImg(inImg, 1.0)
    # Initialize parameters for Hough lines accumulation matrix construction:
    # - step for rho = 1
    rhoStep = 2.0
    
    # - range of 15 evenly spaced orientations between pi/2 and 3.pi/4 radians
    thetaRange = PyIPSDK.createEvenlySpacedRange(math.pi/2, 3*math.pi/4, 15)
        
    # only accumulate pixels of input image with intensity greater than  210
    intensityThreshold = 70.0
    # orientation tolerance = 10 degrees (pi / 18 radians)
    orientationTolerance = math.pi / 18
    
    imgParams = PyIPSDK.createHoughLinesGradientImgParams(
        rhoStep, thetaRange, intensityThreshold)
        
    # Initialize parameters for extraction of lines from accumulation matrix
    # to default
    extractionParams = PyIPSDK.createDefaultHoughLinesExtractionParams()
    
    # hough circle detection computation
    outLines, outImg = fd.houghLinesGradient2d(
        gxImg, gyImg, imgParams, extractionParams, orientationTolerance)

Example of C++ code :

Example informations

Associated library

IPSDKIPLFeatureDetection

Header file

#include <IPSDKIPL/IPSDKIPLFeatureDetection/Processor/HoughLinesGradient2d/HoughLinesGradient2d.h>

Code Example

    ImageConstPtr pInImg = loadTiffImageFile(inImgPath);
    GradientXYImg xyImg = sobelGradient2dImg(pInImg);
    // Initialize parameters for Hough lines accumulation matrix construction:
    // - step for rho = 1
    const ipReal64 rhoStep = 1.0;
    // - range of 15 evenly spaced orientations between pi/2 and 3.pi/4 radians
    const EvenlySpacedRange& thetaRange = *createEvenlySpacedRange(
        M_PI / 2, 3 * M_PI / 4, 15);
    // only accumulate pixels of input image with intensity greater than  10
    const ipReal32 intensityThreshold = 10.0f;
    const HoughLinesGradientImgParamsConstPtr pInImgPrms =
        createHoughLinesGradientImgParams(rhoStep, thetaRange, intensityThreshold);
    // Initialize parameters for extraction of lines from accumulation matrix:
    // - only keep local maxima with a value greater than 50 % of global maximum
    // of the accumulation matrix
    const eHoughAccumThresholdType accumThresholdType =
        eHoughAccumThresholdType::eHATT_MaxRatio;
    const ipReal64 accumThresholdValue = 0.5f;
    // - only one local maximum allowed in a neighborhood of radius equalling to 10
    // pixels
    const ipUInt32 localMaxSearchWindowRadius = 10;
    const HoughLinesExtractionParamsConstPtr pInExtractPrms =
        createHoughLinesExtractionParams(
            accumThresholdType, accumThresholdValue, localMaxSearchWindowRadius);
    // Initialize orientation tolerance parameter to 10 degrees (pi/18 radians)
    const ipReal32 orientationTolerance = static_cast<ipReal32>(M_PI / 18);
    // launch Hough lines detection algorithm
    HoughLinesResult res = houghLinesGradient2d(
        xyImg._pXGradImg,
        xyImg._pYGradImg,
        pInImgPrms,
        pInExtractPrms,
        orientationTolerance);
    // store results in variables
    const HoughLines2dPptiesConstPtr& pPlinesPpties = res._pLinesPpties;
    const ImagePtr pAccumulationMatrix = res._pOutImg;

See also: HoughLinesGradient2dLvl1; HoughLinesGradient2dLvl2

Function Documentation

◆ houghLinesGradient2d() [1/2]

IPSDKIPLFEATUREDETECTION_API ipsdk::imaproc::fd::HoughLinesResult ipsdk::imaproc::fd::houghLinesGradient2d	(	const image::ImageConstPtr &	pInGxImg,
		const image::ImageConstPtr &	pInGyImg
	)

wrapper function for detection of 2D lines in gradient images using extension of Hough algorithm based on gradient orientation

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure

◆ houghLinesGradient2d() [2/2]

IPSDKIPLFEATUREDETECTION_API ipsdk::imaproc::fd::HoughLinesResult ipsdk::imaproc::fd::houghLinesGradient2d	(	const image::ImageConstPtr &	pInGxImg,
		const image::ImageConstPtr &	pInGyImg,
		const ipsdk::imaproc::attr::HoughLinesGradientImgParamsConstPtr &	pHoughLinesImgParams,
		const ipsdk::imaproc::attr::HoughLinesExtractionParamsConstPtr &	pHoughLinesExtractionParams,
		const ipsdk::ipReal32	orientationTolerance
	)

wrapper function for detection of 2D lines in gradient images using extension of Hough algorithm based on gradient orientation

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure

◆ multiSlice_houghLinesGradient2d() [1/2]

IPSDKIPLFEATUREDETECTION_API ipsdk::imaproc::fd::PlanIndexedHoughLinesResult ipsdk::imaproc::fd::multiSlice_houghLinesGradient2d	(	const image::ImageConstPtr &	pInGxImg,
		const image::ImageConstPtr &	pInGyImg
	)

wrapper function for detection of 2D lines in gradient images using extension of Hough algorithm based on gradient orientation

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure

◆ multiSlice_houghLinesGradient2d() [2/2]

IPSDKIPLFEATUREDETECTION_API ipsdk::imaproc::fd::PlanIndexedHoughLinesResult ipsdk::imaproc::fd::multiSlice_houghLinesGradient2d	(	const image::ImageConstPtr &	pInGxImg,
		const image::ImageConstPtr &	pInGyImg,
		const ipsdk::imaproc::attr::HoughLinesGradientImgParamsConstPtr &	pHoughLinesImgParams,
		const ipsdk::imaproc::attr::HoughLinesExtractionParamsConstPtr &	pHoughLinesExtractionParams,
		const ipsdk::ipReal32	orientationTolerance
	)

wrapper function for detection of 2D lines in gradient images using extension of Hough algorithm based on gradient orientation

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure