Computes the Harris corner detection response. More...

IPSDKIPLFEATUREDETECTION_API image::ImagePtr	ipsdk::imaproc::fd::harrisCorner2dImg (const ipsdk::image::ImageConstPtr &pInImg)
	wrapper function for Computes the Harris corner detection response More...

IPSDKIPLFEATUREDETECTION_API image::ImagePtr	ipsdk::imaproc::fd::harrisCorner2dImg (const ipsdk::image::ImageConstPtr &pInImg, const ipsdk::ipReal32 inGradStdDev)
	wrapper function for Computes the Harris corner detection response More...

IPSDKIPLFEATUREDETECTION_API void	ipsdk::imaproc::fd::harrisCorner2dImg (const ipsdk::image::ImageConstPtr &pInImg, const ipsdk::ipReal32 inGradStdDev, const attr::GaussianCoverageConstPtr &pInOptGradientGaussianCoverage, const ipsdk::imaproc::attr::CornerDetectionParamsConstPtr &pInCornerDetectionParams, const ipsdk::image::ImagePtr &pOutImg)
	wrapper function for Computes the Harris corner detection response More...

Detailed Description

Computes the Harris corner detection response.

This algorithm computes the cornerness for each pixel of the input image, according to the Harris corner detector algorithm [1] or to the Shi-Tomasi [2] [3] corner detector algorithm (with respect to method contained by parameter $InCornerDetectionParams$ ).

The basic idea of the Harris corner detector is that a corner can be characterized by high intensity variation in all directions. It means that a pixel at position $(u, v)$ is a corner if the energy $E(u, v)$ , described by the following equation, reaches a maximum value compared to its neighbourhood $\aleph$ :

$E(u, v) = \sum_{x, y \in \aleph}{\omega(x, y) \left( InImg(x+u, y+v) - InImg(x, y) \right)^2}$

Where $\aleph$ is the pixel's neighbourhood, $InImg$ is the input image and $\omega(x, y)$ is the Gaussian coefficient at the position $(x, y)$ . The gaussian coefficients are computed using the parameters $InStdDev$ and $InOptGradientGaussianCoverage$ .

The energy can be approximated by a first order Taylor expansion :

$E(u, v) \approx \left[ u, v \right] M \left[ \begin{array}{c} u \\ v \end{array} \right]$

Where

$M = \sum_{x, y, \in \aleph}{\omega(x, y) \begin{bmatrix} I_x^2 & IxIy\\ IxIy & Iy^2 \end{bmatrix}}$

Where $Ix$ and $Iy$ are the spatial derivatives of the input image at the position $(u, v)$ along the directions x and y respectively. In this implementation, the spatial derivatives are computed using the Gaussian Gradient 2d algorithm.

If selected method is set to ipsdk::imaproc::attr::eCornerDetectionMethod::eCDM_Harris (which is the default value) the cornerness can be computed at the position by :
$C(u, v) = det(M) - k \left( trace(M) \right)^2$
Where is the sensitivity contained by parameter , $det(M) = I_x^2 I_y^2 - \left(I_x I_y\right)^2$ is the determinant of and is the trace of . In order to fit into the output image range, the algorithm returns the square root of :
$OutImg(u, v) = \sqrt{C(u, v)}$
If selected method is set to ipsdk::imaproc::attr::eCornerDetectionMethod::eCDM_ShiTomasi the cornerness can be computed at the position by :
$C(u, v) = OutImg(u, v) = \min(\lambda_1, \lambda_2)$
where $\lambda_1$ and $\lambda_2$ correspond to eigen values of matrix (in this case sensitivity contained by parameter is ignored).

Here is an example of a 2d Harris cornerness calculation applied to an 8-bits grey level input image (with $InStdDev=0.75$ and $k = 0.04$ ):

[1] C. Harris and M. Stephens (1988). "A combined corner and edge detector". Proceedings of the 4th Alvey Vision Conference. pp. 147 - 151.
[2] J. Shi and C. Tomasi (June 1994). "Good Features to Track". 9th IEEE Conference on Computer Vision and Pattern Recognition. Springer
[3] C. Tomasi and T. Kanade (2004). "Detection and Tracking of Point Features". Pattern Recognition. 37: 165 - 168

Attributes description

Attribute description for algorithm :

Name	ToolTip	Default Initializer
ipsdk::imaproc::attr::InImg	[Input] image for processing operation	X
ipsdk::imaproc::attr::InOptGradStdDev	[Input Optional] standard deviation used for gradient computation	X
ipsdk::imaproc::attr::InOptGradientGaussianCoverage	[Input Optional] Parameter allowing to specify a gaussian distribution coverage for processing	X
ipsdk::imaproc::attr::InOptCornerDetectionParams2d	[Input Optional] parameters used during corner detection process	X
ipsdk::imaproc::attr::OutWk1Img	[Output] Temporary working image for algorithm	promoteUnary (_pOutWk1Img, _pInImg, ipsdk::imaproc::ePromoteUnaryType::ePUT_UpperSigned)
ipsdk::imaproc::attr::OutWk2Img	[Output] Temporary working image for algorithm	promoteUnary (_pOutWk2Img, _pInImg, ipsdk::imaproc::ePromoteUnaryType::ePUT_UpperSigned)
ipsdk::imaproc::attr::OutWk3Img	[Output] Temporary working image for algorithm	promoteUnary (_pOutWk3Img, _pInImg, ipsdk::imaproc::ePromoteUnaryType::ePUT_UpperSigned)
ipsdk::imaproc::attr::OutImg	[Output] image for processing operation	promoteUnary (_pOutImg, _pInImg, ipsdk::imaproc::ePromoteUnaryType::ePUT_UpperSigned)

Global Rule description

Global rule description for algorithm :
matchSize (_pInImg,_pOutImg) &&
matchSizeAndType (_pOutImg,_pOutWk1Img) &&
matchSizeAndType (_pOutWk1Img,_pOutWk2Img,_pOutWk3Img)

Example of Python code :

Example imports

import PyIPSDK

import PyIPSDK.IPSDKIPLFeatureDetection as fd

Code Example

    # opening input images
    inGeometry = PyIPSDK.geometry2d(PyIPSDK.eImageBufferType.eIBT_UInt8, 510, 509)
    inImg = PyIPSDK.loadRawImageFile(inputImgPath, inGeometry)
    
    # images addition
    outImg = fd.harrisCorner2dImg(inImg)

Example of C++ code :

Example informations

Associated library

IPSDKIPLFeatureDetection

Header file

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

Code Example

    // Sample with a generated output image
    // ------------------------------------
    ImagePtr pAutoOutImg = harrisCorner2dImg(pInImg);
    // Sample with a provided output image
    // ------------------------------------
    // create output image
    const ipUInt64 sizeX = pInImg->getSizeX();
    const ipUInt64 sizeY = pInImg->getSizeY();
    ImageGeometryPtr pOutputImageGeometry = geometry2d(outType, sizeX, sizeY);
    boost::shared_ptr<MemoryImage> pOutImg(boost::make_shared<MemoryImage>());
    pOutImg->init(*pOutputImageGeometry);
    // compute harris image
    harrisCorner2dImg(pInImg, stdDev, createGaussianCoverage(gaussRatio, 2), createHarrisParams(sensitivity), pOutImg);

See also: HarrisCorner2dImgLvl1; HarrisCorner2dImgLvl2; HarrisCorner2dImgLvl3

Function Documentation

◆ harrisCorner2dImg() [1/3]

IPSDKIPLFEATUREDETECTION_API image::ImagePtr ipsdk::imaproc::fd::harrisCorner2dImg ( const ipsdk::image::ImageConstPtr & pInImg )

wrapper function for Computes the Harris corner detection response

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure

◆ harrisCorner2dImg() [2/3]

IPSDKIPLFEATUREDETECTION_API image::ImagePtr ipsdk::imaproc::fd::harrisCorner2dImg	(	const ipsdk::image::ImageConstPtr &	pInImg,
		const ipsdk::ipReal32	inGradStdDev
	)

wrapper function for Computes the Harris corner detection response

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure

◆ harrisCorner2dImg() [3/3]

IPSDKIPLFEATUREDETECTION_API void ipsdk::imaproc::fd::harrisCorner2dImg	(	const ipsdk::image::ImageConstPtr &	pInImg,
		const ipsdk::ipReal32	inGradStdDev,
		const attr::GaussianCoverageConstPtr &	pInOptGradientGaussianCoverage,
		const ipsdk::imaproc::attr::CornerDetectionParamsConstPtr &	pInCornerDetectionParams,
		const ipsdk::image::ImagePtr &	pOutImg
	)

wrapper function for Computes the Harris corner detection response

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure