LineSuppression

Intel® Integrated Performance Primitives (Intel® IPP) Developer Guide and Reference

Download PDF

ID 790148

Date 6/24/2024

Version

Public

A newer version of this document is available. Customers should click here to go to the newest version.

Visible to Intel only — GUID: GUID-B4BA2DB5-7DCD-4FC9-AD8B-364B76029C39

View Details

LineSuppression

Implements the line suppression algorithm.

Syntax

IppStatus ippiLineSuppression_8u_C1R(const Ipp8u* pSrc, int srcStep, const Ipp8u* pFeature, int featureStep, Ipp8u* pDst, int dstStep, IppiSize roiSize, IppiDifferentialKernel filterType, IppiMaskSize filterMask, Ipp32u avgWndSize, float threshold, IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer);

Include Files

ippcv.h

Domain Dependencies

Headers: ippcore.h, ippvm.h, ipps.h, ippi.h

Libraries: ippcore.lib, ippvm.lib, ipps.lib, ippi.lib

Parameters

pSrc

Pointer to the source image.

srcStep

Distance, in bytes, between the starting points of consecutive lines in the source image.

pFeature

Pointer to the feature points image.

featureStep

Distance, in bytes, between the starting points of consecutive lines in the feature points image.

pDst

Pointer to the destination image.

dstStep

Distance, in bytes, between the starting points of consecutive lines in the destination image.

roiSize

Size of the source and destination image ROI, in pixels.

filterType

Type of the derivative operator. Possible values are:

ippKernelSobel	Sobel filter
ippKernelScharr	Scharr filter
ippKernelCentralDiff	Central differences operator

filterMask

Size of the derivative filter aperture. The list of possible values depends on the filterType value:

Filter Type	Filter Mask
ippKernelSobel	ippMskSize3x3, ippMskSize5x5
ippKernelScharr	ippMskSize3x3
ippKernelCentralDiff	ippMskSize3x3

avgWndSize

Linear size of a neighborhood block for averaging.

threshold

Line suppression threshold.

borderType

Type of border. Possible values are:

ippBorderConst	Values of all border pixels are set to a constant.
ippBorderRepl	Border is replicated from the edge pixels.
ippBorderInMem	Border is obtained from the source image pixels in memory.

Mixed borders are also supported. They can be obtained by the bitwise operation OR between ippBorderRepl or ippBorderConst and the following flags:

ippBorderInMemTop
ippBorderInMemBottom
ippBorderInMemLeft
ippBorderInMemRight

Each of these flags means that for the corresponding border the outside pixels of the source image are in memory.

borderValue

Constant value(s) to assign to pixels of the constant border. This parameter is applicable only to the ippBorderConst border type.

pBuffer

Pointer to the work buffer. To calculate the size of the temporary buffer, use the LineSuppressionGetBufferSize function.

Description

The ippiLineSuppression function implements the line suppression algorithm. This function uses two input images: the original image and feature points image containing the lines (edges) and corners. This function performs the following steps:

Computes I^{(x, y)}_x and I^{(x, y)}_y gradients for each (x, y) pixel of the image. The function computes gradients using the derivative operator specified by the filterType and filterMask parameters.
Computes products of the gradients at each (x, y) pixel of the image:
Performs averaging of the products of gradients over a rectangular neighborhood block at each pixel of the image. The block size is specified by the avgWndSize value.
Defines 2x2 gradient covariance matrix H^{(x , y)} over a rectangular neighborhood block for each (x, y) pixel of the image.
For each (x, y) pixel of the image checks the condition below. If the condition is true, the considered point is not a feature point.

where
- threshold is the line suppression threshold value passed to the function
- λ₁*λ₂ are eigenvalues of the matrix H^{(x , ^y)}. If both eigenvalues have large positive values, the point belongs to a corner. If λ₁ is much bigger than λ₂, the function clears out the candidate point.

The first and third stages of the function algorithm are filtering operations; they use border processing approach that is specified by the borderType parameter.

Before using this function, compute the size of the external work buffer using the LineSuppressionGetBufferSize function.

Return Values

ippStsNoErr	Indicates no error.
ippStsNullPtrErr	Indicates an error when pSrc, pFeature, pDst, or pBufferSize is `NULL`.
ippStsSizeErr	Indicates an error in the following cases: when roiSize is less than, or equal to zero when avgWndSize is equal to zero
ippStsNotEvenStepErr	Indicates an error when one of the step values is not divisible by 4 for floating point images.
ippStsFilterTypeErr	Indicates an error when filterType has an illegal value.
ippStsMaskSizeErr	Indicates an error when filterMask has an illegal value.
ippStsBorderErr	Indicates an error when borderType has an illegal value.
ippStsStepErr	Indicates an error when srcStep or dstStep has a negative value.
ippStsInplaceModeNotSupportedErr	Indicates an error when pFeature and pDst point to the same image.

Example

/*******************************************************************************
* Copyright 2015 Intel Corporation.
*
*
* This software and the related documents are Intel copyrighted materials, and your use of them is governed by
* the express license under which they were provided to you ('License'). Unless the License provides otherwise,
* you may not use, modify, copy, publish, distribute, disclose or transmit this software or the related
* documents without Intel's prior written permission.
* This software and the related documents are provided as is, with no express or implied warranties, other than
* those that are expressly stated in the License.
*******************************************************************************/

// A simple example of Line Suppression 
// using Intel(R) Integrated Performance Primitives (Intel(R) IPP) functions:
//     ippiLineSuppressionGetBufferSize
//     ippiLineSuppression_8u_C1R


#include <stdio.h>
#include "ipp.h"

#define WIDTH  128  /* image width  */
#define HEIGHT  64  /* image height */

/* Next two defines are created to simplify code reading and understanding */
#define EXIT_MAIN exitLine:                                  /* Label for Exit */
#define check_sts(st) if((st) != ippStsNoErr) goto exitLine; /* Go to Exit if Intel(R) IPP function returned status different from ippStsNoErr */

/* Results of ippMalloc() are not validated because Intel(R) IPP functions perform bad arguments check and will return an appropriate status  */

int main(void)
{
    IppStatus status = ippStsNoErr;
    Ipp8u* pSrc = NULL, *pDst = NULL, *pFeature = NULL;  /* Pointers to source/destination/feature images */
    int srcStep = 0, dstStep = 0, featureStep = 0;       /* Steps, in bytes, through the source/destination/feature images */
    IppiSize roiSize = { WIDTH, HEIGHT };    /* Size of source/destination ROI in pixels */
    IppiMaskSize filterMask = ippMskSize3x3; /* Linear size of derivative filter aperture */
    Ipp32u avgWndSize = 1;                   /* Neighbourhood block size for smoothing */
    Ipp32u numChannels = 1;
    Ipp32f threshold = 5.0f;
    const Ipp8u borderValue = 0;
    Ipp8u* pBuffer = NULL;                   /* Pointer to the work buffer */
    int bufSize = 0;
    IppiDifferentialKernel filterType = ippFilterSobel; /* Type of derivative operator */

    pSrc = ippiMalloc_8u_C1(roiSize.width, roiSize.height, &srcStep);
    pDst = ippiMalloc_8u_C1(roiSize.width, roiSize.height, &dstStep);
    pFeature = ippiMalloc_8u_C1(roiSize.width, roiSize.height, &featureStep);

    /* Computes the temporary work buffer size */
    check_sts( status = ippiLineSuppressionGetBufferSize(roiSize, filterMask, avgWndSize, ipp8u, numChannels, &bufSize) )
    pBuffer = ippsMalloc_8u(bufSize);

    /* Line Suppression processing */
    check_sts( status = ippiLineSuppression_8u_C1R(pSrc, srcStep, pFeature, featureStep, pDst, dstStep, roiSize, filterType, filterMask, avgWndSize, threshold, ippBorderRepl, borderValue, pBuffer) )

EXIT_MAIN
    ippiFree(pSrc);
    ippiFree(pDst);
    ippiFree(pFeature);
    printf("Exit status %d (%s)\n", (int)status, ippGetStatusString(status));
    return (int)status;
}

Parent topic: Feature Detection Functions

Select Your Language

Using Intel.com Search

Quick Links

Recent Searches

Advanced Search

Only search in

Intel® Integrated Performance Primitives (Intel® IPP) Developer Guide and Reference

LineSuppression

Syntax

Include Files

Domain Dependencies

Parameters

Description

Return Values

Example

See Also