5107 lines
269 KiB
C
5107 lines
269 KiB
C
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// INTEL CORPORATION PROPRIETARY INFORMATION
|
|
// This software is supplied under the terms of a license agreement or
|
|
// nondisclosure agreement with Intel Corporation and may not be copied
|
|
// or disclosed except in accordance with the terms of that agreement.
|
|
// Copyright (c) 1999-2009 Intel Corporation. All Rights Reserved.
|
|
//
|
|
// Intel(R) Integrated Performance Primitives
|
|
// Computer Vision (ippCV)
|
|
//
|
|
*/
|
|
|
|
#if !defined( __IPPCV_H__ ) || defined( _OWN_BLDPCS )
|
|
#define __IPPCV_H__
|
|
|
|
#if defined (_WIN32_WCE) && defined (_M_IX86) && defined (__stdcall)
|
|
#define _IPP_STDCALL_CDECL
|
|
#undef __stdcall
|
|
#endif
|
|
|
|
#ifndef __IPPDEFS_H__
|
|
#include "ippdefs.h"
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#if !defined( _OWN_BLDPCS )
|
|
|
|
typedef enum _IppiKernelType {
|
|
ippKernelSobel = 0,
|
|
ippKernelScharr = 1
|
|
} IppiKernelType;
|
|
|
|
typedef enum _IppiNorm {
|
|
ippiNormInf = 0,
|
|
ippiNormL1 = 1,
|
|
ippiNormL2 = 2,
|
|
ippiNormFM = 3
|
|
} IppiNorm;
|
|
|
|
struct ipcvMorphState;
|
|
typedef struct ipcvMorphState IppiMorphState;
|
|
|
|
struct ipcvMorphAdvState;
|
|
typedef struct ipcvMorphAdvState IppiMorphAdvState;
|
|
|
|
struct ipcvMorphGrayState_8u;
|
|
typedef struct ipcvMorphGrayState_8u IppiMorphGrayState_8u;
|
|
|
|
struct ipcvMorphGrayState_32f;
|
|
typedef struct ipcvMorphGrayState_32f IppiMorphGrayState_32f;
|
|
|
|
struct ipcvConvState;
|
|
typedef struct ipcvConvState IppiConvState;
|
|
|
|
typedef struct _IppiConnectedComp {
|
|
Ipp64f area; /* area of the segmented component */
|
|
Ipp64f value[3];/* gray scale value of the segmented component */
|
|
IppiRect rect; /* bounding rectangle of the segmented component */
|
|
} IppiConnectedComp;
|
|
|
|
struct PyramidState;
|
|
typedef struct PyramidState IppiPyramidState;
|
|
|
|
typedef IppiPyramidState IppiPyramidDownState_8u_C1R;
|
|
typedef IppiPyramidState IppiPyramidDownState_16u_C1R;
|
|
typedef IppiPyramidState IppiPyramidDownState_32f_C1R;
|
|
typedef IppiPyramidState IppiPyramidDownState_8u_C3R;
|
|
typedef IppiPyramidState IppiPyramidDownState_16u_C3R;
|
|
typedef IppiPyramidState IppiPyramidDownState_32f_C3R;
|
|
typedef IppiPyramidState IppiPyramidUpState_8u_C1R;
|
|
typedef IppiPyramidState IppiPyramidUpState_16u_C1R;
|
|
typedef IppiPyramidState IppiPyramidUpState_32f_C1R;
|
|
typedef IppiPyramidState IppiPyramidUpState_8u_C3R;
|
|
typedef IppiPyramidState IppiPyramidUpState_16u_C3R;
|
|
typedef IppiPyramidState IppiPyramidUpState_32f_C3R;
|
|
|
|
|
|
typedef struct _IppiPyramid {
|
|
Ipp8u **pImage;
|
|
IppiSize *pRoi;
|
|
Ipp64f *pRate;
|
|
int *pStep;
|
|
Ipp8u *pState;
|
|
int level;
|
|
} IppiPyramid;
|
|
|
|
struct OptFlowPyrLK;
|
|
typedef struct OptFlowPyrLK IppiOptFlowPyrLK;
|
|
|
|
typedef IppiOptFlowPyrLK IppiOptFlowPyrLK_8u_C1R;
|
|
typedef IppiOptFlowPyrLK IppiOptFlowPyrLK_16u_C1R;
|
|
typedef IppiOptFlowPyrLK IppiOptFlowPyrLK_32f_C1R;
|
|
|
|
struct ipcvHaarClassifier_32f;
|
|
typedef struct ipcvHaarClassifier_32f IppiHaarClassifier_32f;
|
|
|
|
struct ipcvHaarClassifier_32s;
|
|
typedef struct ipcvHaarClassifier_32s IppiHaarClassifier_32s;
|
|
|
|
struct ipcvFGHistogramState_8u_C1R;
|
|
typedef struct ipcvFGHistogramState_8u_C1R IppFGHistogramState_8u_C1R;
|
|
|
|
struct ipcvFGHistogramState_8u_C3R;
|
|
typedef struct ipcvFGHistogramState_8u_C3R IppFGHistogramState_8u_C3R;
|
|
|
|
struct ipcvFGGaussianState_8u_C1R;
|
|
typedef struct ipcvFGGaussianState_8u_C1R IppFGGaussianState_8u_C1R;
|
|
|
|
struct ipcvFGGaussianState_8u_C3R;
|
|
typedef struct ipcvFGGaussianState_8u_C3R IppFGGaussianState_8u_C3R;
|
|
|
|
typedef struct _IppFGHistogramModel { /* for C3 image */
|
|
int valueQuant; /* 64 */
|
|
int changeQuant; /* 32 */
|
|
int valueUse; /* 30 */
|
|
int valueAll; /* 50 */
|
|
int changeUse; /* 50 */
|
|
int changeAll; /* 80 */
|
|
Ipp32f updBGChange; /* 0.0046 */
|
|
Ipp32f updBGRef; /* 0.0010 */
|
|
int numFrame;
|
|
float detectionRate;
|
|
float brightnessDistortion;
|
|
int shadowBG;
|
|
} IppFGHistogramModel;
|
|
|
|
typedef struct _IppFGGaussianModel {
|
|
int numGauss;
|
|
Ipp32f priorBack;
|
|
Ipp32f updBGProb;
|
|
int winSize;
|
|
int numFrame;
|
|
float detectionRate;
|
|
float brightnessDistortion;
|
|
int shadowBG;
|
|
} IppFGGaussianModel;
|
|
|
|
typedef enum _IppiInpaintFlag {
|
|
IPP_INPAINT_TELEA = 0,
|
|
IPP_INPAINT_NS = 1
|
|
} IppiInpaintFlag;
|
|
|
|
struct ipcvInpaintState_8u;
|
|
typedef struct ipcvInpaintState_8u IppiInpaintState_8u_C1R;
|
|
typedef struct ipcvInpaintState_8u IppiInpaintState_8u_C3R;
|
|
|
|
#endif /* _OWN_BLDPCS */
|
|
|
|
#define IPP_SEGMENT_QUEUE 0x01
|
|
#define IPP_SEGMENT_DISTANCE 0x02
|
|
#define IPP_SEGMENT_BORDER_4 0x40
|
|
#define IPP_SEGMENT_BORDER_8 0x80
|
|
|
|
#define IPP_TRUNC(a,b) ((a)&~((b)-1))
|
|
#define IPP_APPEND(a,b) (((a)+(b)-1)&~((b)-1))
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// Functions declarations
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////// */
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippcvGetLibVersion
|
|
//
|
|
// Purpose: getting of the library version
|
|
//
|
|
// Returns: the structure of information about version of ippcv library
|
|
//
|
|
// Parameters:
|
|
//
|
|
// Notes: not necessary to release the returned structure
|
|
*/
|
|
IPPAPI( const IppLibraryVersion*, ippcvGetLibVersion, (void) )
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Copy with Subpixel Precision *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiCopySubpix_8u_C1R, ippiCopySubpix_16u_C1R,
|
|
// ippiCopySubpix_8u16u_C1R_Sfs, ippiCopySubpix_16u32f_C1R,
|
|
// ippiCopySubpix_8u32f_C1R, ippiCopySubpix_32f_C1R
|
|
//
|
|
// Purpose: copies source image to destination image with interpolation
|
|
//
|
|
// Returns:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc Pointer to source image
|
|
// srcStep Step in source image
|
|
// pDst Pointer to destination image
|
|
// dstStep Step in destination image
|
|
// roiSize Source and destination image ROI size.
|
|
// dx x coeff of linear interpolation
|
|
// dy y coeff of linear interpolation
|
|
// scaleFactor Output scale factor, >= 0
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpix_8u_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp32f dx, Ipp32f dy))
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpix_8u16u_C1R_Sfs, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp16u* pDst, int dstStep, IppiSize roiSize, Ipp32f dx, Ipp32f dy, int scaleFactor))
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpix_8u32f_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f dx, Ipp32f dy))
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpix_16u_C1R, (const Ipp16u* pSrc, int srcStep,
|
|
Ipp16u* pDst, int dstStep, IppiSize roiSize, Ipp32f dx, Ipp32f dy))
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpix_16u32f_C1R, (const Ipp16u* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f dx, Ipp32f dy))
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpix_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f dx, Ipp32f dy))
|
|
|
|
|
|
/*F////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiCopySubpixIntersect_8u_C1R, ippiCopySubpixIntersect_16u_C1R,
|
|
// ippiCopySubpixIntersect_8u16u_C1R_Sfs, ippiCopySubpixIntersect_16u32f_C1R,
|
|
// ippiCopySubpixIntersect_8u32f_C1R, ippiCopySubpixIntersect_32f_C1R
|
|
//
|
|
// Purpose: finds intersection of centered window in the source image and copies
|
|
// in to destination image with the border
|
|
// border pixel are taken from the source image or replicated if they are outside it
|
|
//
|
|
// Returns:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc Pointer to source image
|
|
// srcStep Step in source image
|
|
// srcRoiSize Source image ROI size.
|
|
// pDst Pointer to destination image
|
|
// dstStep Step in destination image
|
|
// dstRoiSize Destination image ROI size.
|
|
// point Center of dst window in src image (subpixel)
|
|
// pMin Top left corner of dst filled part
|
|
// pMax Bottom right corner of dst filled part
|
|
// scaleFactor Output scale factor, >= 0
|
|
//
|
|
// Notes: For integer point.x or point.y pixels from the last row
|
|
// or column are not copied. Branches are possible.
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpixIntersect_8u_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
IppiSize srcRoiSize, Ipp8u* pDst, int dstStep, IppiSize dstRoiSize,
|
|
IppiPoint_32f point, IppiPoint *pMin, IppiPoint *pMax))
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpixIntersect_8u16u_C1R_Sfs, (const Ipp8u* pSrc, int srcStep,
|
|
IppiSize srcRoiSize, Ipp16u* pDst, int dstStep, IppiSize dstRoiSize,
|
|
IppiPoint_32f point, IppiPoint *pMin, IppiPoint *pMax, int scaleFactor))
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpixIntersect_8u32f_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
IppiSize srcRoiSize, Ipp32f* pDst, int dstStep, IppiSize dstRoiSize,
|
|
IppiPoint_32f point, IppiPoint *pMin, IppiPoint *pMax))
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpixIntersect_16u_C1R, (const Ipp16u* pSrc, int srcStep,
|
|
IppiSize srcRoiSize, Ipp16u* pDst, int dstStep, IppiSize dstRoiSize,
|
|
IppiPoint_32f point, IppiPoint *pMin, IppiPoint *pMax))
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpixIntersect_16u32f_C1R, (const Ipp16u* pSrc, int srcStep,
|
|
IppiSize srcRoiSize, Ipp32f* pDst, int dstStep, IppiSize dstRoiSize,
|
|
IppiPoint_32f point, IppiPoint *pMin, IppiPoint *pMax))
|
|
|
|
IPPAPI(IppStatus, ippiCopySubpixIntersect_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
IppiSize srcRoiSize, Ipp32f* pDst, int dstStep, IppiSize dstRoiSize,
|
|
IppiPoint_32f point, IppiPoint *pMin, IppiPoint *pMax))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Line sampling *
|
|
\****************************************************************************************/
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiSampleLine_8u_C1R, ippiSampleLine_8u_C3R,
|
|
// ippiSampleLine_16u_C1R, ippiSampleLine_16u_C3R,
|
|
// ippiSampleLine_32f_C1R, ippiSampleLine_32f_C3R,
|
|
//
|
|
// Purpose: Reads values of pixels on the raster
|
|
// line between two given points and write them to buffer.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsOutOfRangeErr At least one of the points is outside the image ROI.
|
|
//
|
|
// Parameters:
|
|
// pSrc Source image
|
|
// srcStep Its step
|
|
// roiSize ROI size
|
|
// pBuffer Pointer to buffer where the pixels are stored.
|
|
// It must have size >= max(abs(pt2.y - pt1.y)+1,
|
|
// abs(pt2.x - pt1.x)+1)*
|
|
// <size_of_pixel>.
|
|
// pt1 Starting point of the line segment.
|
|
// The pixel value will be stored to buffer first.
|
|
// pt2 Ending point of the line segment.
|
|
// The pixel value will be stored to buffer last.
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiSampleLine_8u_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
IppiSize roiSize, Ipp8u* pDst,
|
|
IppiPoint pt1, IppiPoint pt2 ))
|
|
|
|
IPPAPI(IppStatus, ippiSampleLine_8u_C3R, ( const Ipp8u* pSrc, int srcStep,
|
|
IppiSize roiSize, Ipp8u* pDst,
|
|
IppiPoint pt1, IppiPoint pt2 ))
|
|
|
|
IPPAPI(IppStatus, ippiSampleLine_16u_C1R, ( const Ipp16u* pSrc, int srcStep,
|
|
IppiSize roiSize, Ipp16u* pDst,
|
|
IppiPoint pt1, IppiPoint pt2 ))
|
|
|
|
IPPAPI(IppStatus, ippiSampleLine_16u_C3R, ( const Ipp16u* pSrc, int srcStep,
|
|
IppiSize roiSize, Ipp16u* pDst,
|
|
IppiPoint pt1, IppiPoint pt2 ))
|
|
|
|
IPPAPI(IppStatus, ippiSampleLine_32f_C1R, ( const Ipp32f* pSrc, int srcStep,
|
|
IppiSize roiSize, Ipp32f* pDst,
|
|
IppiPoint pt1, IppiPoint pt2 ))
|
|
|
|
IPPAPI(IppStatus, ippiSampleLine_32f_C3R, ( const Ipp32f* pSrc, int srcStep,
|
|
IppiSize roiSize, Ipp32f* pDst,
|
|
IppiPoint pt1, IppiPoint pt2 ))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Accumulation *
|
|
\****************************************************************************************/
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiAdd_8u32f_C1IR, ippiAdd_8s32f_C1IR,
|
|
// ippiAdd_16u32f_C1IR,
|
|
// ippiAdd_8u32f_C1IMR, ippiAdd_8s32f_C1IMR,
|
|
// ippiAdd_16u32f_C1IMR, ippiAdd_32f_C1IMR
|
|
//
|
|
// Purpose: Add image to accumulator.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr Step is too small to fit image.
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Arguments:
|
|
// pSrc Pointer to source image
|
|
// srcStep Step in the source image
|
|
// pMask Pointer to mask
|
|
// maskStep Step in the mask image
|
|
// pSrcDst Pointer to accumulator image
|
|
// srcDstStep Step in the accumulator image
|
|
// roiSize Image size
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiAdd_8u32f_C1IR, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAdd_8s32f_C1IR, (const Ipp8s* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAdd_16u32f_C1IR, (const Ipp16u* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiAdd_8u32f_C1IMR,(const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAdd_8s32f_C1IMR,(const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAdd_16u32f_C1IMR,(const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAdd_32f_C1IMR, (const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiAddSquare_8u32f_C1IR, ippiAddSquare_8s32f_C1IR,
|
|
// ippiAddSquare_16u32f_C1IR, ippiAddSquare_32f_C1IR,
|
|
// ippiAddSquare_8u32f_C1IMR, ippiAddSquare_8s32f_C1IMR,
|
|
// ippiAddSquare_16u32f_C1IMR, ippiAddSquare_32f_C1IMR
|
|
//
|
|
// Purpose: Add squared image (i.e. multiplied by itself) to accumulator.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr Step is too small to fit image.
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Arguments:
|
|
// pSrc Pointer to source image
|
|
// srcStep Step in the source image
|
|
// pMask Pointer to mask
|
|
// maskStep Step in the mask image
|
|
// pSrcDst Pointer to accumulator image
|
|
// srcDstStep Step in the accumulator image
|
|
// roiSize Image size
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiAddSquare_8u32f_C1IR, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddSquare_8s32f_C1IR, (const Ipp8s* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddSquare_16u32f_C1IR, (const Ipp16u* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddSquare_32f_C1IR, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddSquare_8u32f_C1IMR,(const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddSquare_8s32f_C1IMR,(const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddSquare_16u32f_C1IMR,(const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddSquare_32f_C1IMR, (const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiAddProduct_8u32f_C1IR, ippiAddProduct_8s32f_C1IR,
|
|
// ippiAddProduct_16u32f_C1IR, ippiAddProduct_32f_C1IR,
|
|
// ippiAddProduct_8u32f_C1IMR, ippiAddProduct_8s32f_C1IMR,
|
|
// ippiAddProduct_16u32f_C1IMR, ippiAddProduct_32f_C1IMR
|
|
//
|
|
// Purpose: Add product of two images to accumulator.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr Step is too small to fit image.
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Arguments:
|
|
// pSrc1 Pointer to first source image
|
|
// src1Step Step in the first source image
|
|
// pSrc2 Pointer to second source image
|
|
// src2Step Step in the second source image
|
|
// pMask Pointer to mask
|
|
// maskStep Step in the mask image
|
|
// pSrcDst Pointer to accumulator image
|
|
// srcDstStep Step in the accumulator image
|
|
// roiSize Image size
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiAddProduct_8u32f_C1IR, (const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddProduct_8s32f_C1IR, (const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddProduct_16u32f_C1IR, (const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddProduct_32f_C1IR, (const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddProduct_8u32f_C1IMR,(const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddProduct_8s32f_C1IMR,(const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddProduct_16u32f_C1IMR,(const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAddProduct_32f_C1IMR, (const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize ))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiAddWeighted_8u32f_C1IR, ippiAddWeighted_8s32f_C1IR,
|
|
// ippiAddWeighted_16u32f_C1IR, ippiAddWeighted_32f_C1IR,
|
|
// ippiAddWeighted_8u32f_C1IMR, ippiAddWeighted_8s32f_C1IMR,
|
|
// ippiAddWeighted_16u32f_C1IMR,ippiAddWeighted_32f_C1IMR
|
|
// ippiAddWeighted_32f_C1R
|
|
//
|
|
// Purpose: Add image, multiplied by alpha, to accumulator, multiplied by (1 - alpha).
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr Step is too small to fit image.
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Arguments:
|
|
// pSrc1 Pointer to first source image
|
|
// src1Step Step in the first source image
|
|
// pSrc2 Pointer to second source image
|
|
// src2Step Step in the second source image
|
|
// pMask Pointer to mask
|
|
// maskStep Step in the mask image
|
|
// pSrcDst Pointer to accumulator image
|
|
// srcDstStep Step in the accumulator image
|
|
// pDst Pointer to destination image
|
|
// dstStep Step in the destination image
|
|
// roiSize Image size
|
|
// alpha Weight of source image
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiAddWeighted_8u32f_C1IR, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize, Ipp32f alpha ))
|
|
|
|
IPPAPI(IppStatus, ippiAddWeighted_8s32f_C1IR, (const Ipp8s* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize, Ipp32f alpha ))
|
|
|
|
IPPAPI(IppStatus, ippiAddWeighted_16u32f_C1IR, (const Ipp16u* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize, Ipp32f alpha ))
|
|
|
|
IPPAPI(IppStatus, ippiAddWeighted_32f_C1IR, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize, Ipp32f alpha ))
|
|
|
|
IPPAPI(IppStatus, ippiAddWeighted_8u32f_C1IMR,(const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize, Ipp32f alpha ))
|
|
|
|
IPPAPI(IppStatus, ippiAddWeighted_8s32f_C1IMR,(const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize, Ipp32f alpha ))
|
|
|
|
IPPAPI(IppStatus, ippiAddWeighted_16u32f_C1IMR,(const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize, Ipp32f alpha ))
|
|
|
|
IPPAPI(IppStatus, ippiAddWeighted_32f_C1IMR, (const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
Ipp32f* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize, Ipp32f alpha ))
|
|
|
|
IPPAPI(IppStatus, ippiAddWeighted_32f_C1R, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp32f alpha ))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Absolute difference *
|
|
\****************************************************************************************/
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiAbsDiff_8u_C1R, ippiAbsDiff_8u_C3R, ippiAbsDiff_16u_C1R, ippiAbsDiff_32f_C1R,
|
|
//
|
|
// Purpose: Calculate absolute difference between corresponding pixels of the two images
|
|
// or between image pixels and scalar.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc1 Source image
|
|
// src1Step Its step
|
|
// pSrc2 Second source image
|
|
// src2Step Its step
|
|
// pDst Destination image
|
|
// dstStep Its step
|
|
// roiSize ROI size
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiAbsDiff_8u_C1R, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize ))
|
|
IPPAPI(IppStatus, ippiAbsDiff_8u_C3R, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAbsDiff_16u_C1R, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
Ipp16u* pDst, int dstStep, IppiSize roiSize ))
|
|
|
|
IPPAPI(IppStatus, ippiAbsDiff_32f_C1R, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize ))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiAbsDiffC_8u_C1R, ippiAbsDiffC_16u_C1R, ippiAbsDiffC_32f_C1R,
|
|
//
|
|
// Purpose: Calculate absolute difference between image pixels and scalar.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc Source image
|
|
// srcStep Its step
|
|
// pDst Destination image: dst(x,y) = abs(src(x,y) - value)
|
|
// dstStep Its step
|
|
// roiSize ROI size
|
|
// value Scalar value to compare with. For 8u function
|
|
// If scalar is not within [0,255], it is clipped
|
|
// ( value = value < 0 ? 0 : value > 255 ? 255 : value )
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiAbsDiffC_8u_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, int value ))
|
|
|
|
IPPAPI(IppStatus, ippiAbsDiffC_16u_C1R, ( const Ipp16u* pSrc, int srcStep,
|
|
Ipp16u* pDst, int dstStep,
|
|
IppiSize roiSize, int value ))
|
|
|
|
IPPAPI(IppStatus, ippiAbsDiffC_32f_C1R, ( const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp32f value ))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Morphological Operations *
|
|
\****************************************************************************************/
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphologyGetSize_8u_C1R, ippiMorphologyGetSize_32f_C1R,
|
|
// ippiMorphologyGetSize_8u_C3R, ippiMorphologyGetSize_32f_C3R,
|
|
// ippiMorphologyGetSize_8u_C4R, ippiMorphologyGetSize_32f_C4R
|
|
//
|
|
// Purpose: Gets size of internal state of morphological operation.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of image or width or height of structuring
|
|
// element is less or equal zero.
|
|
//
|
|
// Arguments:
|
|
// roiWidth Width of image ROI in pixels
|
|
// pMask Pointer to structuring element (mask)
|
|
// maskSize Size of structuring element
|
|
// pSize Pointer to state length (GetSize)
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphologyGetSize_8u_C1R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize, int* pSize))
|
|
IPPAPI(IppStatus, ippiMorphologyGetSize_8u_C3R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize, int* pSize))
|
|
IPPAPI(IppStatus, ippiMorphologyGetSize_8u_C4R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize, int* pSize))
|
|
IPPAPI(IppStatus, ippiMorphologyGetSize_32f_C1R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize, int* pSize))
|
|
IPPAPI(IppStatus, ippiMorphologyGetSize_32f_C3R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize, int* pSize))
|
|
IPPAPI(IppStatus, ippiMorphologyGetSize_32f_C4R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize, int* pSize))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphologyInit_8u_C1R, ippiMorphologyInit_32f_C1R,
|
|
// ippiMorphologyInit_8u_C3R, ippiMorphologyInit_32f_C3R,
|
|
// ippiMorphologyInit_8u_C4R, ippiMorphologyInit_32f_C4R,
|
|
//
|
|
// Purpose: Initialize internal state of morphological operation.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of image or width or height of structuring
|
|
// element is less or equal zero.
|
|
// ippStsAnchorErr Anchor point is outside the structuring element
|
|
//
|
|
// Arguments:
|
|
// roiWidth Width of image ROI in pixels
|
|
// pMask Pointer to structuring element (mask)
|
|
// maskSize Size of structuring element
|
|
// anchor Anchor of the structuring element
|
|
// pState Pointer to morphological state (Init)
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphologyInit_8u_C1R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiMorphologyInit_8u_C3R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiMorphologyInit_8u_C4R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiMorphologyInit_32f_C1R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiMorphologyInit_32f_C3R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiMorphologyInit_32f_C4R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphologyInitAlloc_8u_C1R, ippiMorphologyInitAlloc_32f_C1R,
|
|
// ippiMorphologyInitAlloc_8u_C3R, ippiMorphologyInitAlloc_32f_C3R,
|
|
// ippiMorphologyInitAlloc_8u_C4R, ippiMorphologyInitAlloc_32f_C4R
|
|
//
|
|
// Purpose: Allocate buffers and initialize internal state of morphological operation.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of image or width or height of structuring
|
|
// element is less or equal zero.
|
|
// ippStsAnchorErr Anchor point is outside the structuring element
|
|
// ippStsMemAllocErr Memory allocation error
|
|
//
|
|
// Arguments:
|
|
// roiWidth Width of image ROI in pixels
|
|
// pMask Pointer to structuring element (mask)
|
|
// maskSize Size of structuring element
|
|
// anchor Anchor of the structuring element
|
|
// ppState Double pointer to morphological state (InitAlloc)
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphologyInitAlloc_8u_C1R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState** ppState))
|
|
IPPAPI(IppStatus, ippiMorphologyInitAlloc_8u_C3R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState** ppState))
|
|
IPPAPI(IppStatus, ippiMorphologyInitAlloc_8u_C4R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState** ppState))
|
|
IPPAPI(IppStatus, ippiMorphologyInitAlloc_32f_C1R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState** ppState))
|
|
IPPAPI(IppStatus, ippiMorphologyInitAlloc_32f_C3R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState** ppState))
|
|
IPPAPI(IppStatus, ippiMorphologyInitAlloc_32f_C4R,(int roiWidth, const Ipp8u* pMask, IppiSize maskSize,
|
|
IppiPoint anchor, IppiMorphState** ppState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphologyFree
|
|
//
|
|
// Purpose: Releases buffers, allocated by ippiMorphologyInitAlloc
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
//
|
|
// Arguments:
|
|
// morphState Pointer to morphological state.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphologyFree,(IppiMorphState* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiDilateBorderReplicate_8u_C1R, ippiDilateBorderReplicate_8u_C3R,
|
|
// ippiDilateBorderReplicate_8u_C4R, ippiDilateBorderReplicate_32f_C1R,
|
|
// ippiDilateBorderReplicate_32f_C3R, ippiDilateBorderReplicate_32f_C4R
|
|
//
|
|
// ippiErodeBorderReplicate_8u_C1R, ippiErodeBorderReplicate_8u_C3R,
|
|
// ippiErodeBorderReplicate_8u_C4R, ippiErodeBorderReplicate_32f_C1R,
|
|
// ippiErodeBorderReplicate_32f_C3R, ippiErodeBorderReplicate_32f_C4R,
|
|
//
|
|
// Purpose: Perform erosion/dilation of image arbitrary shape structuring element.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The ROI width or height is less than 1
|
|
// or ROI width is bigger than ROI width in state
|
|
// ippStsStepErr Step is too small to fit image.
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsBadArgErr Bad border type
|
|
//
|
|
// Arguments:
|
|
// pSrc The pointer to source image
|
|
// srcStep The step in source image
|
|
// pDst The pointer to destination image
|
|
// dstStep The step in destination image
|
|
// roiSize ROI size
|
|
// borderType Type of border (ippBorderRepl now)
|
|
// pState Pointer to morphological operation state
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiDilateBorderReplicate_8u_C1R,(const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiDilateBorderReplicate_8u_C3R,(const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiDilateBorderReplicate_8u_C4R,(const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiDilateBorderReplicate_32f_C1R,(const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiDilateBorderReplicate_32f_C3R,(const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiDilateBorderReplicate_32f_C4R,(const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
|
|
IPPAPI(IppStatus, ippiErodeBorderReplicate_8u_C1R,(const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiErodeBorderReplicate_8u_C3R,(const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiErodeBorderReplicate_8u_C4R,(const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiErodeBorderReplicate_32f_C1R,(const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiErodeBorderReplicate_32f_C3R,(const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
IPPAPI(IppStatus, ippiErodeBorderReplicate_32f_C4R,(const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, IppiMorphState* pState))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Advanced Morphological Operations *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphAdvGetSize_8u_C1R, ippiMorphAdvGetSize_32f_C1R,
|
|
// ippiMorphAdvGetSize_8u_C3R, ippiMorphAdvGetSize_32f_C3R,
|
|
// ippiMorphAdvGetSize_8u_C4R, ippiMorphAdvGetSize_32f_C4R
|
|
//
|
|
// Purpose: Gets size of internal state of advanced morphological operation.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of image or width or height of structuring
|
|
// element is less or equal zero.
|
|
//
|
|
// Arguments:
|
|
// roiSize Maximal image ROI in pixels
|
|
// pMask Pointer to structuring element (mask)
|
|
// maskSize Size of structuring element
|
|
// pSize Pointer to state length (GetSize)
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphAdvGetSize_8u_C1R,(IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, int* stateSize))
|
|
IPPAPI(IppStatus, ippiMorphAdvGetSize_8u_C3R,(IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, int* stateSize))
|
|
IPPAPI(IppStatus, ippiMorphAdvGetSize_8u_C4R,(IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, int* stateSize))
|
|
IPPAPI(IppStatus, ippiMorphAdvGetSize_32f_C1R,(IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, int* stateSize))
|
|
IPPAPI(IppStatus, ippiMorphAdvGetSize_32f_C3R,(IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, int* stateSize))
|
|
IPPAPI(IppStatus, ippiMorphAdvGetSize_32f_C4R,(IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, int* stateSize))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphAdvInit_8u_C1R, ippiMorphAdvInit_32f_C1R,
|
|
// ippiMorphAdvInit_8u_C3R, ippiMorphAdvInit_32f_C3R,
|
|
// ippiMorphAdvInit_8u_C4R, ippiMorphAdvInit_32f_C4R,
|
|
//
|
|
// Purpose: Initialize internal state of advanced morphological operation.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of image or width or height of structuring
|
|
// element is less or equal zero.
|
|
// ippStsAnchorErr Anchor point is outside the structuring element
|
|
//
|
|
// Arguments:
|
|
// pState Pointer to morphological state (Init)
|
|
// roiSize Maximal image ROI in pixels
|
|
// pMask Pointer to structuring element (mask)
|
|
// maskSize Size of structuring element
|
|
// anchor Anchor of the structuring element
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphAdvInit_8u_C1R,(IppiMorphAdvState* morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
IPPAPI(IppStatus, ippiMorphAdvInit_8u_C3R,(IppiMorphAdvState* morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
IPPAPI(IppStatus, ippiMorphAdvInit_8u_C4R,(IppiMorphAdvState* morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
IPPAPI(IppStatus, ippiMorphAdvInit_32f_C1R,(IppiMorphAdvState* morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
IPPAPI(IppStatus, ippiMorphAdvInit_32f_C3R,(IppiMorphAdvState* morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
IPPAPI(IppStatus, ippiMorphAdvInit_32f_C4R,(IppiMorphAdvState* morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphAdvInitAlloc_8u_C1R, ippiMorphAdvInitAlloc_32f_C1R,
|
|
// ippiMorphAdvInitAlloc_8u_C3R, ippiMorphAdvInitAlloc_32f_C3R,
|
|
// ippiMorphAdvInitAlloc_8u_C4R, ippiMorphAdvInitAlloc_32f_C4R
|
|
//
|
|
// Purpose: Allocate buffers and initialize internal state of advanced morphological operation.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of image or width or height of structuring
|
|
// element is less or equal zero.
|
|
// ippStsAnchorErr Anchor point is outside the structuring element
|
|
// ippStsMemAllocErr Memory allocation error
|
|
//
|
|
// Arguments:
|
|
// ppState Double pointer to morphological state (InitAlloc)
|
|
// roiSize Maximal image ROI in pixels
|
|
// pMask Pointer to structuring element (mask)
|
|
// maskSize Size of structuring element
|
|
// anchor Anchor of the structuring element
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphAdvInitAlloc_8u_C1R,(IppiMorphAdvState** morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
IPPAPI(IppStatus, ippiMorphAdvInitAlloc_8u_C3R,(IppiMorphAdvState** morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
IPPAPI(IppStatus, ippiMorphAdvInitAlloc_8u_C4R,(IppiMorphAdvState** morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
IPPAPI(IppStatus, ippiMorphAdvInitAlloc_32f_C1R,(IppiMorphAdvState** morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
IPPAPI(IppStatus, ippiMorphAdvInitAlloc_32f_C3R,(IppiMorphAdvState** morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
IPPAPI(IppStatus, ippiMorphAdvInitAlloc_32f_C4R,(IppiMorphAdvState** morphState, IppiSize roiSize, const Ipp8u* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphAdvFree
|
|
//
|
|
// Purpose: Releases buffers, allocated by rippiMorphAdvInitAlloc
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr Null pointer to pointer to morphological state.
|
|
//
|
|
// Arguments:
|
|
// pState double pointer to morphological state.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphAdvFree,(IppiMorphAdvState* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphCloseBorder_8u_C1R, ippiMorphCloseBorder_8u_C3R,
|
|
// ippiMorphCloseBorder_8u_C4R, ippiMorphCloseBorder_32f_C1R,
|
|
// ippiMorphCloseBorder_32f_C3R, ippiMorphCloseBorder_32f_C4R
|
|
//
|
|
// ippiMorphOpenBorder_8u_C1R, ippiMorphOpenBorder_8u_C3R,
|
|
// ippiMorphOpenBorder_8u_C4R, ippiMorphOpenBorder_32f_C1R,
|
|
// ippiMorphOpenBorder_32f_C3R, ippiMorphOpenBorder_32f_C4R,
|
|
//
|
|
// ippiMorphTophatBorder_8u_C1R, ippiMorphTophatBorder_8u_C3R,
|
|
// ippiMorphTophatBorder_8u_C4R, ippiMorphTophatBorder_32f_C1R,
|
|
// ippiMorphTophatBorder_32f_C3R, ippiMorphTophatBorder_32f_C4R,
|
|
//
|
|
// ippiMorphBlackhatBorder_8u_C1R, ippiMorphBlackhatBorder_8u_C3R,
|
|
// ippiMorphBlackhatBorder_8u_C4R, ippiMorphBlackhatBorder_32f_C1R,
|
|
// ippiMorphBlackhatBorder_32f_C3R, ippiMorphBlackhatBorder_32f_C4R,
|
|
//
|
|
// ippiMorphGradientBorder_8u_C1R, ippiMorphGradientBorder_8u_C3R,
|
|
// ippiMorphGradientBorder_8u_C4R, ippiMorphGradientBorder_32f_C1R,
|
|
// ippiMorphGradientBorder_32f_C3R, ippiMorphGradientBorder_32f_C4R,
|
|
//
|
|
// Purpose: Perform advanced morphology of image arbitrary shape structuring element.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The ROI width or height is less than 1
|
|
// or ROI width is bigger than ROI width in state
|
|
// ippStsStepErr Step is too small to fit image.
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsBadArgErr Bad border type
|
|
//
|
|
// Arguments:
|
|
// pSrc The pointer to source image
|
|
// srcStep The step in source image
|
|
// pDst The pointer to destination image
|
|
// dstStep The step in destination image
|
|
// roiSize ROI size
|
|
// borderType Type of border (ippBorderRepl now)
|
|
// pState Pointer to morphological operation state
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphOpenBorder_8u_C1R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphOpenBorder_8u_C3R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphOpenBorder_8u_C4R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphOpenBorder_32f_C1R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphOpenBorder_32f_C3R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphOpenBorder_32f_C4R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
|
|
IPPAPI(IppStatus, ippiMorphCloseBorder_8u_C1R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphCloseBorder_8u_C3R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphCloseBorder_8u_C4R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphCloseBorder_32f_C1R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphCloseBorder_32f_C3R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphCloseBorder_32f_C4R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
|
|
IPPAPI(IppStatus, ippiMorphTophatBorder_8u_C1R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphTophatBorder_8u_C3R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphTophatBorder_8u_C4R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphTophatBorder_32f_C1R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphTophatBorder_32f_C3R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphTophatBorder_32f_C4R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
|
|
IPPAPI(IppStatus, ippiMorphBlackhatBorder_8u_C1R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphBlackhatBorder_8u_C3R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphBlackhatBorder_8u_C4R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphBlackhatBorder_32f_C1R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphBlackhatBorder_32f_C3R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphBlackhatBorder_32f_C4R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
|
|
IPPAPI(IppStatus, ippiMorphGradientBorder_8u_C1R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphGradientBorder_8u_C3R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphGradientBorder_8u_C4R,(
|
|
const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphGradientBorder_32f_C1R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphGradientBorder_32f_C3R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
IPPAPI(IppStatus, ippiMorphGradientBorder_32f_C4R,(
|
|
const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiBorderType borderType, IppiMorphAdvState* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphGrayGetSize_8u_C1R, ippiMorphGrayGetSize_32f_C1R
|
|
//
|
|
// Purpose: Gets size of internal state of gray-kernel morphological operation.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of image or width or height of structuring
|
|
// element is less or equal zero.
|
|
//
|
|
// Arguments:
|
|
// roiSize Maximal image ROI in pixels
|
|
// pMask Pointer to structuring element
|
|
// maskSize Size of structuring element
|
|
// pSize Pointer to state length
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphGrayGetSize_8u_C1R,(IppiSize roiSize, const Ipp32s* pMask, IppiSize maskSize, int* pSize))
|
|
|
|
IPPAPI(IppStatus, ippiMorphGrayGetSize_32f_C1R,(IppiSize roiSize, const Ipp32f* pMask, IppiSize maskSize, int* pSize))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphGrayInit_8u_C1R, ippiMorphGrayInit_32f_C1R
|
|
//
|
|
// Purpose: Initialize internal state of gray-scale morphological operation.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of image or width or height of structuring
|
|
// element is less or equal zero.
|
|
// ippStsAnchorErr Anchor point is outside the structuring element
|
|
//
|
|
// Arguments:
|
|
// roiSize Maximal image roiSize in pixels
|
|
// pMask Pointer to structuring element (mask)
|
|
// maskSize Size of structuring element
|
|
// anchor Anchor of the structuring element
|
|
// pState Pointer to morphological state (Init)
|
|
*/
|
|
IPPAPI(IppStatus, ippiMorphGrayInit_8u_C1R,(IppiMorphGrayState_8u* pState, IppiSize roiSize, const Ipp32s* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
|
|
IPPAPI(IppStatus, ippiMorphGrayInit_32f_C1R,(IppiMorphGrayState_32f* pState, IppiSize roiSize, const Ipp32f* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphGrayInitAlloc_8u_C1R, ippiMorphGrayInitAlloc_32f_C1R
|
|
//
|
|
// Purpose: Allocate buffers and initialize internal state of gray-scale morphological operation.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of image or width or height of structuring
|
|
// element is less or equal zero.
|
|
// ippStsAnchorErr Anchor point is outside the structuring element
|
|
// ippStsMemAllocErr Memory allocation error
|
|
//
|
|
// Arguments:
|
|
// roiSize Maximal image roiSize in pixels
|
|
// pMask Pointer to structuring element (mask)
|
|
// maskSize Size of structuring element
|
|
// anchor Anchor of the structuring element
|
|
// ppState Double pointer to morphological state (InitAlloc)
|
|
*/
|
|
IPPAPI(IppStatus, ippiMorphGrayInitAlloc_8u_C1R,(IppiMorphGrayState_8u** ppState, IppiSize roiSize, const Ipp32s* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
|
|
IPPAPI(IppStatus, ippiMorphGrayInitAlloc_32f_C1R,(IppiMorphGrayState_32f** ppState, IppiSize roiSize, const Ipp32f* pMask,
|
|
IppiSize maskSize, IppiPoint anchor))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphGrayFree_8u_C1R, ippiMorphGrayFree_32f_C1R
|
|
//
|
|
// Purpose: Releases buffers, allocated by rippiMorphGrayInitAlloc
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr Null pointer to pointer to morphological state.
|
|
//
|
|
// Arguments:
|
|
// pState Double pointer to morphological state.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphGrayFree_8u_C1R,(IppiMorphGrayState_8u* pState))
|
|
|
|
IPPAPI(IppStatus, ippiMorphGrayFree_32f_C1R,(IppiMorphGrayState_32f* pState))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiGrayDilateBorder_8u_C1R, ippiGrayDilateBorder_32f_C1R,
|
|
// ippiGrayErodeBorder_8u_C1R, ippiGrayErodeBorder_32f_C1R
|
|
//
|
|
// Purpose: Perform erosion/dilation of image with gray-scale structuring element.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The ROI width or height is less than 1
|
|
// or ROI width is bigger than ROI width in state
|
|
// ippStsStepErr Step is too small to fit image.
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsBadArgErr Bad border type
|
|
//
|
|
// Arguments:
|
|
// pSrc The pointer to source image
|
|
// srcStep The step in source image
|
|
// pDst The pointer to destination image
|
|
// dstStep The step in destination image
|
|
// roiSize ROI size
|
|
// border Type of border (ippBorderRepl now)
|
|
// pState Pointer to morphological operation state
|
|
*/
|
|
IPPAPI(IppStatus, ippiGrayErodeBorder_8u_C1R,(const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType border, IppiMorphGrayState_8u* pState))
|
|
|
|
IPPAPI(IppStatus, ippiGrayErodeBorder_32f_C1R,(const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType border, IppiMorphGrayState_32f* pState))
|
|
|
|
IPPAPI(IppStatus, ippiGrayDilateBorder_8u_C1R,(const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType border, IppiMorphGrayState_8u* pState))
|
|
|
|
IPPAPI(IppStatus, ippiGrayDilateBorder_32f_C1R,(const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType border, IppiMorphGrayState_32f* pState))
|
|
|
|
|
|
/*F/////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphReconstructGetBufferSize_8u_C1, ippiMorphReconstructGetBufferSize_8u_C1
|
|
//
|
|
// Purpose: returns buffer size for morphological reconstruction
|
|
//
|
|
// Returns:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// roiSize The maximal ROI size.
|
|
// pBufSize The pointer to the buffer size.
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphReconstructGetBufferSize_8u_C1,(IppiSize roiSize, int *pSize))
|
|
|
|
IPPAPI(IppStatus, ippiMorphReconstructGetBufferSize_32f_C1,(IppiSize roiSize, int *pSize))
|
|
|
|
|
|
/*F/////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMorphReconstructDilate_8u_C1IR, ippiMorphReconstructErode_8u_C1IR,
|
|
// ippiMorphReconstructDilate_32f_C1IR, ippiMorphReconstructErode_32f_C1IR
|
|
//
|
|
// Purpose: performs morphological reconstruction of pSrcDst under/above pSrc
|
|
//
|
|
// Returns:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc The pointer to source above/under image
|
|
// srcStep The step in source image
|
|
// pSrcDst The pointer to image to reconstruct
|
|
// srcDstStep The step in destination image
|
|
// roiSize The source and destination image ROI size.
|
|
// norm The norm type for dilation
|
|
// ippiNormInf = Linf norm (8-connectivity)
|
|
// ippiNormL1 = L1 norm (4-connectivity)
|
|
// pBuffer The pointer to working buffer
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiMorphReconstructDilate_8u_C1IR, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize, Ipp8u *pBuf, IppiNorm norm))
|
|
|
|
IPPAPI(IppStatus, ippiMorphReconstructErode_8u_C1IR, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize, Ipp8u *pBuf, IppiNorm norm))
|
|
|
|
IPPAPI(IppStatus, ippiMorphReconstructDilate_32f_C1IR, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize, Ipp32f *pBuf, IppiNorm norm))
|
|
|
|
IPPAPI(IppStatus, ippiMorphReconstructErode_32f_C1IR, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize, Ipp32f *pBuf, IppiNorm norm))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Min/Max Filters *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFilterMinGetBufferSize_8u_C1R, ippiFilterMaxGetBufferSize_8u_C1R,
|
|
// ippiFilterMinGetBufferSize_32f_C1R, ippiFilterMaxGetBufferSize_32f_C1R,
|
|
// ippiFilterMinGetBufferSize_8u_C3R, ippiFilterMaxGetBufferSize_8u_C3R,
|
|
// ippiFilterMinGetBufferSize_32f_C3R, ippiFilterMaxGetBufferSize_32f_C3R,
|
|
// ippiFilterMinGetBufferSize_8u_C4R, ippiFilterMaxGetBufferSize_8u_C4R,
|
|
// ippiFilterMinGetBufferSize_32f_C4R, ippiFilterMaxGetBufferSize_32f_C4R
|
|
//
|
|
// Purpose: Calculate buffer size for morphology operations with rectangular kernel
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image is less or equal zero
|
|
// ippStsMaskSizeErr Wrong mask size
|
|
//
|
|
// Parameters:
|
|
// roiWidth The image ROI width
|
|
// maskSize The mask size
|
|
// pBufferSize The pointer to the buffer size
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinGetBufferSize_8u_C1R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxGetBufferSize_8u_C1R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinGetBufferSize_32f_C1R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxGetBufferSize_32f_C1R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinGetBufferSize_8u_C3R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxGetBufferSize_8u_C3R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinGetBufferSize_32f_C3R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxGetBufferSize_32f_C3R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinGetBufferSize_8u_C4R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxGetBufferSize_8u_C4R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinGetBufferSize_32f_C4R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxGetBufferSize_32f_C4R, (int roiWidth, IppiSize maskSize, int *pBufferSize))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFilterMaxBorderReplicate_8u_C1R, ippiFilterMinBorderReplicate_8u_C1R,
|
|
// ippiFilterMaxBorderReplicate_32f_C1R, ippiFilterMinBorderReplicate_32f_C1R
|
|
// ippiFilterMaxBorderReplicate_8u_C3R, ippiFilterMinBorderReplicate_8u_C3R,
|
|
// ippiFilterMaxBorderReplicate_32f_C3R, ippiFilterMinBorderReplicate_32f_C3R
|
|
// ippiFilterMaxBorderReplicate_8u_C4R, ippiFilterMinBorderReplicate_8u_C4R,
|
|
// ippiFilterMaxBorderReplicate_32f_C4R, ippiFilterMinBorderReplicate_32f_C4R
|
|
//
|
|
// Purpose: Perform morphology operations with rectangular kernel
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsMaskSizeErr Wrong mask size
|
|
// ippStsAnchorErr Anchor is outside the mask size.
|
|
//
|
|
// Parameters:
|
|
// pSrc The pointer to the source image
|
|
// srcStep The step in the source image
|
|
// pDst The pointer to the destination image
|
|
// dstStep The step in the destination image
|
|
// roiSize The image ROI size
|
|
// maskSize The mask size
|
|
// anchor The anchor position
|
|
// pBuffer The pointer to the working buffer
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinBorderReplicate_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxBorderReplicate_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinBorderReplicate_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxBorderReplicate_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinBorderReplicate_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxBorderReplicate_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinBorderReplicate_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxBorderReplicate_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinBorderReplicate_8u_C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxBorderReplicate_8u_C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMinBorderReplicate_32f_C4R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterMaxBorderReplicate_32f_C4R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiSize maskSize, IppiPoint anchor, Ipp8u *pBuffer))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Separable Filters *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFilterRowBorderPipelineGetBufferSize_8u16s_C1R, ippiFilterRowBorderPipelineGetBufferSize_8u16s_C3R
|
|
// ippiFilterRowBorderPipelineGetBufferSize_16s_C1R, ippiFilterRowBorderPipelineGetBufferSize_16s_C3R
|
|
// ippiFilterRowBorderPipelineGetBufferSize_Low_16s_C1R, ippiFilterRowBorderPipelineGetBufferSize_Low_16s_C3R
|
|
// ippiFilterRowBorderPipelineGetBufferSize_32f_C1R, ippiFilterRowBorderPipelineGetBufferSize_32f_C3R
|
|
//
|
|
// Purpose: Get size of external buffer.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image or kernel size are less or equal zero
|
|
//
|
|
// Parameters:
|
|
// roiSize The image ROI size
|
|
// kernelSize The size of the kernel
|
|
// pBufferSize The pointer to the buffer size
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipelineGetBufferSize_8u16s_C1R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipelineGetBufferSize_8u16s_C3R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipelineGetBufferSize_16s_C1R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipelineGetBufferSize_16s_C3R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipelineGetBufferSize_Low_16s_C1R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipelineGetBufferSize_Low_16s_C3R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipelineGetBufferSize_32f_C1R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipelineGetBufferSize_32f_C3R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFilterRowBorderPipeline_8u16s_C1R, ippiFilterRowBorderPipeline_8u16s_C3R
|
|
// ippiFilterRowBorderPipeline_16s_C1R, ippiFilterRowBorderPipeline_16s_C3R
|
|
// ippiFilterRowBorderPipeline_Low_16s_C1R, ippiFilterRowBorderPipeline_Low_16s_C3R
|
|
// ippiFilterRowBorderPipeline_32f_C1R, ippiFilterRowBorderPipeline_32f_C3R
|
|
//
|
|
// Purpose: Convolves source image rows with the row kernel
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsAnchorErr The anchor outside the kernel
|
|
// ippStsBadArgErr Wrong border type or zero divisor
|
|
//
|
|
// Parameters:
|
|
// pSrc The pointer to the source image
|
|
// srcStep The step in the source image
|
|
// ppDst The double pointer to the destination image
|
|
// roiSize The image ROI size
|
|
// pKernel The pointer to the kernel
|
|
// kernelSize The size of the kernel
|
|
// xAnchor The anchor value , (0<=xAnchor<kernelSize)
|
|
// borderType The type of the border
|
|
// borderValue The value for the constant border
|
|
// divisor The value to divide output pixels by , (for integer functions)
|
|
// pBuffer The pointer to the working buffer
|
|
// Notes: The output is the doulble pointer to support the circle buffer
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipeline_8u16s_C1R, (const Ipp8u* pSrc, int srcStep, Ipp16s** ppDst,
|
|
IppiSize roiSize, const Ipp16s* pKernel, int kernelSize, int xAnchor,
|
|
IppiBorderType borderType, Ipp8u borderValue, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipeline_8u16s_C3R, (const Ipp8u* pSrc, int srcStep, Ipp16s** ppDst,
|
|
IppiSize roiSize, const Ipp16s* pKernel, int kernelSize, int xAnchor,
|
|
IppiBorderType borderType, Ipp8u borderValue[3], int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipeline_16s_C1R, (const Ipp16s* pSrc, int srcStep, Ipp16s** ppDst,
|
|
IppiSize roiSize, const Ipp16s* pKernel, int kernelSize, int xAnchor,
|
|
IppiBorderType borderType, Ipp16s borderValue, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipeline_16s_C3R, (const Ipp16s* pSrc, int srcStep, Ipp16s** ppDst,
|
|
IppiSize roiSize, const Ipp16s* pKernel, int kernelSize, int xAnchor,
|
|
IppiBorderType borderType, Ipp16s borderValue[3], int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipeline_Low_16s_C1R, (const Ipp16s* pSrc, int srcStep, Ipp16s** ppDst,
|
|
IppiSize roiSize, const Ipp16s* pKernel, int kernelSize, int xAnchor,
|
|
IppiBorderType borderType, Ipp16s borderValue, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipeline_Low_16s_C3R, (const Ipp16s* pSrc, int srcStep, Ipp16s** ppDst,
|
|
IppiSize roiSize, const Ipp16s* pKernel, int kernelSize, int xAnchor,
|
|
IppiBorderType borderType, Ipp16s borderValue[3], int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipeline_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f** ppDst,
|
|
IppiSize roiSize, const Ipp32f* pKernel, int kernelSize, int xAnchor,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterRowBorderPipeline_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f** ppDst,
|
|
IppiSize roiSize, const Ipp32f* pKernel, int kernelSize, int xAnchor,
|
|
IppiBorderType borderType, Ipp32f borderValue[3], Ipp8u* pBuffer))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFilterColumnPipelineGetBufferSize_16s_C1R, ippiFilterColumnPipelineGetBufferSize_16s_C3R
|
|
// ippiFilterColumnPipelineGetBufferSize_Low_16s_C1R, ippiFilterColumnPipelineGetBufferSize_Low_16s_C3R
|
|
// ippiFilterColumnPipelineGetBufferSize_16s8u_C1R, ippiFilterColumnPipelineGetBufferSize_16s8u_C3R
|
|
// ippiFilterColumnPipelineGetBufferSize_16s8s_C1R, ippiFilterColumnPipelineGetBufferSize_16s8s_C3R
|
|
// ippiFilterColumnPipelineGetBufferSize_32f_C1R, ippiFilterColumnPipelineGetBufferSize_32f_C3R
|
|
//
|
|
// Purpose: Get size of external buffer.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image or kernel size are less or equal zero
|
|
//
|
|
// Parameters:
|
|
// roiSize The image ROI size
|
|
// kernelSize The size of the kernel
|
|
// pBufferSize The pointer to the buffer size
|
|
*/
|
|
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipelineGetBufferSize_16s_C1R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipelineGetBufferSize_16s_C3R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipelineGetBufferSize_Low_16s_C1R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipelineGetBufferSize_Low_16s_C3R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipelineGetBufferSize_16s8u_C1R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipelineGetBufferSize_16s8u_C3R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipelineGetBufferSize_16s8s_C1R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipelineGetBufferSize_16s8s_C3R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipelineGetBufferSize_32f_C1R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipelineGetBufferSize_32f_C3R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFilterColumnPipeline_16s_C1R, ippiFilterColumnPipeline_16s_C3R
|
|
// ippiFilterColumnPipeline_Low_16s_C1R, ippiFilterColumnPipeline_Low_16s_C3R
|
|
// ippiFilterColumnPipeline_16s8u_C1R, ippiFilterColumnPipeline_16s8u_C3R
|
|
// ippiFilterColumnPipeline_16s8s_C1R, ippiFilterColumnPipeline_16s8s_C3R
|
|
// ippiFilterColumnPipeline_32f_C1R, ippiFilterColumnPipeline_32f_C3R
|
|
// Purpose: Convolves source image rows with the row kernel
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsBadArgErr Zero divisor
|
|
//
|
|
// Parameters:
|
|
// ppSrc The double pointer to the source image
|
|
// pDst The pointer to the destination image
|
|
// dstStep The step in the destination image
|
|
// roiSize The image ROI size
|
|
// pKernel The pointer to the kernel
|
|
// kernelSize The size of the kernel
|
|
// divisor The value to divide output pixels by , (for integer functions)
|
|
// pBuffer The pointer to the working buffer
|
|
// Notes: The input is the doulble pointer to support the circle buffer
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipeline_16s_C1R, (const Ipp16s** ppSrc, Ipp16s* pDst, int dstStep, IppiSize roiSize,
|
|
const Ipp16s* pKernel, int kernelSize, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipeline_16s_C3R, (const Ipp16s** ppSrc, Ipp16s* pDst, int dstStep, IppiSize roiSize,
|
|
const Ipp16s* pKernel, int kernelSize, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipeline_Low_16s_C1R, (const Ipp16s** ppSrc, Ipp16s* pDst, int dstStep, IppiSize roiSize,
|
|
const Ipp16s* pKernel, int kernelSize, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipeline_Low_16s_C3R, (const Ipp16s** ppSrc, Ipp16s* pDst, int dstStep, IppiSize roiSize,
|
|
const Ipp16s* pKernel, int kernelSize, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipeline_16s8u_C1R, (const Ipp16s** ppSrc, Ipp8u* pDst, int dstStep, IppiSize roiSize,
|
|
const Ipp16s* pKernel, int kernelSize, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipeline_16s8u_C3R, (const Ipp16s** ppSrc, Ipp8u* pDst, int dstStep, IppiSize roiSize,
|
|
const Ipp16s* pKernel, int kernelSize, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipeline_16s8s_C1R, (const Ipp16s** ppSrc, Ipp8s* pDst, int dstStep, IppiSize roiSize,
|
|
const Ipp16s* pKernel, int kernelSize, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipeline_16s8s_C3R, (const Ipp16s** ppSrc, Ipp8s* pDst, int dstStep, IppiSize roiSize,
|
|
const Ipp16s* pKernel, int kernelSize, int divisor, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipeline_32f_C1R, (const Ipp32f** ppSrc, Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
const Ipp32f* pKernel, int kernelSize, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterColumnPipeline_32f_C3R, (const Ipp32f** ppSrc, Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
const Ipp32f* pKernel, int kernelSize, Ipp8u* pBuffer))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Fixed Filters *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFilterScharrHorizGetBufferSize_8u16s_C1R, ippiFilterScharrHorizGetBufferSize_32f_C1R,
|
|
// ippiFilterScharrVertGetBufferSize_8u16s_C1R, ippiFilterScharrVertGetBufferSize_32f_C1R,
|
|
// ippiFilterSobelHorizGetBufferSize_8u16s_C1R, ippiFilterSobelHorizGetBufferSize_32f_C1R,
|
|
// ippiFilterSobelVertGetBufferSize_8u16s_C1R, ippiFilterSobelVertGetBufferSize_32f_C1R,
|
|
// ippiFilterSobelNegVertGetBufferSize_8u16s_C1R, ippiFilterSobelNegVertGetBufferSize_32f_C1R,
|
|
// ippiFilterSobelHorizSecondGetBufferSize_8u16s_C1R, ippiFilterSobelHorizSecondGetBufferSize_32f_C1R,
|
|
// ippiFilterSobelVertSecondGetBufferSize_8u16s_C1R, ippiFilterSobelVertSecondGetBufferSize_32f_C1R,
|
|
// ippiFilterSobelCrossGetBufferSize_8u16s_C1R, ippiFilterSobelCrossGetBufferSize_32f_C1R,
|
|
// ippiFilterLaplacianGetBufferSize_8u16s_C1R, ippiFilterLaplacianGetBufferSize_32f_C1R,
|
|
// ippiFilterLowpassGetBufferSize_8u_C1R, ippiFilterLowpassGetBufferSize_32f_C1R,
|
|
// ippiFilterScharrHorizGetBufferSize_8u8s_C1R,
|
|
// ippiFilterScharrVertGetBufferSize_8u8s_C1R,
|
|
// ippiFilterSobelHorizGetBufferSize_8u8s_C1R,
|
|
// ippiFilterSobelVertGetBufferSize_8u8s_C1R,
|
|
// ippiFilterSobelNegVertGetBufferSize_8u8s_C1R,
|
|
// ippiFilterSobelHorizSecondGetBufferSize_8u8s_C1R,
|
|
// ippiFilterSobelVertSecondGetBufferSize_8u8s_C1R,
|
|
// ippiFilterSobelCrossGetBufferSize_8u8s_C1R,
|
|
// ippiFilterLaplacianGetBufferSize_8u8s_C1R,
|
|
//
|
|
//
|
|
// Purpose: Perform convolution operation with fixed kernels 3x3 and 5x5
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image is less or equal zero
|
|
// ippStsMaskSizeErr Wrong mask size
|
|
//
|
|
// Parameters:
|
|
// roiSize The image ROI size
|
|
// mask The mask size
|
|
// pBufferSize The pointer to the buffer size
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrHorizGetBufferSize_8u16s_C1R, (IppiSize roiSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrVertGetBufferSize_8u16s_C1R, (IppiSize roiSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizGetBufferSize_8u16s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertGetBufferSize_8u16s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelNegVertGetBufferSize_8u16s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizSecondGetBufferSize_8u16s_C1R,(IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertSecondGetBufferSize_8u16s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelCrossGetBufferSize_8u16s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterLaplacianGetBufferSize_8u16s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrHorizGetBufferSize_8u8s_C1R, (IppiSize roiSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrVertGetBufferSize_8u8s_C1R, (IppiSize roiSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizGetBufferSize_8u8s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertGetBufferSize_8u8s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelNegVertGetBufferSize_8u8s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizSecondGetBufferSize_8u8s_C1R,(IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertSecondGetBufferSize_8u8s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelCrossGetBufferSize_8u8s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterLaplacianGetBufferSize_8u8s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiFilterLowpassGetBufferSize_8u_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrHorizGetBufferSize_32f_C1R, (IppiSize roiSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrVertGetBufferSize_32f_C1R, (IppiSize roiSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizGetBufferSize_32f_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertGetBufferSize_32f_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelNegVertGetBufferSize_32f_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizSecondGetBufferSize_32f_C1R,(IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertSecondGetBufferSize_32f_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelCrossGetBufferSize_32f_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterLaplacianGetBufferSize_32f_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFilterLowpassGetBufferSize_32f_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFilterScharrHorizBorder_8u16s_C1R, ippiFilterScharrHorizBorder_32f_C1R
|
|
// ippiFilterScharrVertBorder_8u16s_C1R, ippiFilterScharrVertBorder_32f_C1R
|
|
// ippiFilterSobelHorizBorder_8u16s_C1R, ippiFilterSobelHorizBorder_32f_C1R
|
|
// ippiFilterSobelVertBorder_8u16s_C1R, ippiFilterSobelVertBorder_32f_C1R
|
|
// ippiFilterSobelNegVertBorder_8u16s_C1R, ippiFilterSobelNegVertBorder_32f_C1R
|
|
// ippiFilterSobelHorizSecondBorder_8u16s_C1R, ippiFilterSobelHorizSecondBorder_32f_C1R
|
|
// ippiFilterSobelVertSecondBorder_8u16s_C1R, ippiFilterSobelVertSecondBorder_32f_C1R
|
|
// ippiFilterSobelCrossBorder_8u16s_C1R, ippiFilterSobelCrossBorder_32f_C1R
|
|
// ippiFilterLaplacianBorder_8u16s_C1R, ippiFilterLaplacianBorder_32f_C1R
|
|
// ippiFilterLowpassBorder_8u_C1R, ippiFilterLowpassBorder_32f_C1R,
|
|
// ippiFilterScharrHorizBorder_8u8s_C1R,
|
|
// ippiFilterScharrVertBorder_8u8s_C1R,
|
|
// ippiFilterSobelHorizBorder_8u8s_C1R,
|
|
// ippiFilterSobelVertBorder_8u8s_C1R,
|
|
// ippiFilterSobelNegVertBorder_8u8s_C1R,
|
|
// ippiFilterSobelHorizSecondBorder_8u8s_C1R,
|
|
// ippiFilterSobelVertSecondBorder_8u8s_C1R,
|
|
// ippiFilterSobelCrossBorder_8u8s_C1R,
|
|
// ippiFilterLaplacianBorder_8u8s_C1R
|
|
//
|
|
// Purpose: Perform convolution operation with fixed kernels 3x3 and 5x5
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsMaskSizeErr Wrong mask size
|
|
// ippStsBadArgErr Wrong border type or zero divisor
|
|
//
|
|
// Parameters:
|
|
// pSrc The pointer to the source image
|
|
// srcStep The step in the source image
|
|
// pDst The pointer to the destination image
|
|
// dstStep The step in the destination image
|
|
// roiSize The image ROI size
|
|
// mask The mask size
|
|
// borderType The type of the border
|
|
// borderValue The value for the constant border
|
|
// pBuffer The pointer to the working buffer
|
|
// divisor The value to divide output pixels by , (for integer functions)
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrHorizBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp16s* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrVertBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp16s* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp16s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp16s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelNegVertBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp16s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizSecondBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp16s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertSecondBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp16s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelCrossBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp16s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterLaplacianBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp16s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterLowpassBorder_8u_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrHorizBorder_8u8s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, Ipp8u borderValue, int divisor,
|
|
Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrVertBorder_8u8s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, Ipp8u borderValue, int divisor,
|
|
Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizBorder_8u8s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, int divisor,
|
|
Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertBorder_8u8s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, int divisor,
|
|
Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelNegVertBorder_8u8s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, int divisor,
|
|
Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizSecondBorder_8u8s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, int divisor,
|
|
Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertSecondBorder_8u8s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, int divisor,
|
|
Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelCrossBorder_8u8s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, int divisor,
|
|
Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterLaplacianBorder_8u8s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp8u borderValue, int divisor,
|
|
Ipp8u* pBuffer))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrHorizBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterScharrVertBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelNegVertBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelHorizSecondBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelVertSecondBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterSobelCrossBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterLowpassBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiFilterLaplacianBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
|
|
IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiGenSobelKernel_16s, ippiGenSobelKernel_32f
|
|
//
|
|
// Purpose: Generate kernel for Sobel differential operator
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The size of kernel is less or equal zero
|
|
// ippStsBadArgErr derivative order is less than 0
|
|
//
|
|
// Parameters:
|
|
// pDst The pointer to the destination kernel
|
|
// kernelSize The kernel size, odd
|
|
// dx The order of derivative (0<=dx<kernelSize)
|
|
// sign Reverse signs in sign < 0
|
|
*/
|
|
|
|
IPPAPI (IppStatus, ippiGenSobelKernel_16s, (Ipp16s* pDst, int kernelSize, int dx, int sign))
|
|
|
|
IPPAPI (IppStatus, ippiGenSobelKernel_32f, (Ipp32f *pDst, int kernelSize, int dx, int sign))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Image Integrals *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/*F/////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiIntegral_8u32s_C1R, ippiIntegral_8u32f_C1R,
|
|
// ippiSqrIntegral_8u32s64f_C1R, ippiSqrIntegral_8u32f64f_C1R,
|
|
// ippiTiltedIntegral_8u32s_C1R, ippiTiltedIntegral_8u32f_C1R
|
|
// ippiTiltedSqrIntegral_8u32s64f_C1R, ippiTiltedSqrIntegral_8u32f64f_C1R,
|
|
// ippiSqrIntegral_8u32s_C1R, ippiTiltedSqrIntegral_8u32s_C1R
|
|
//
|
|
// Purpose: calculates pixel sum on subimage
|
|
//
|
|
// Returns:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc The pointer to source image
|
|
// srcStep The step in source image
|
|
// pDst The pointer to destination integral image
|
|
// dstStep The step in destination image
|
|
// pSq The pointer to destination square integral image
|
|
// sqStep The step in destination image
|
|
// roiSize The source and destination image ROI size.
|
|
// val The value to add to pDst image pixels.
|
|
// valSqr The value to add to pSq image pixels.
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiIntegral_8u32s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32s* pDst, int dstStep, IppiSize roiSize, Ipp32s val))
|
|
|
|
IPPAPI(IppStatus, ippiTiltedIntegral_8u32s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32s* pDst, int dstStep, IppiSize roiSize, Ipp32s val))
|
|
|
|
IPPAPI(IppStatus, ippiSqrIntegral_8u32s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32s* pDst, int dstStep, Ipp32s* pSqr, int sqrStep, IppiSize roi,
|
|
Ipp32s val, Ipp32s valSqr))
|
|
|
|
IPPAPI(IppStatus, ippiTiltedSqrIntegral_8u32s_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32s* pDst, int dstStep, Ipp32s* pSqr, int sqrStep, IppiSize roi,
|
|
Ipp32s val, Ipp32s valSqr))
|
|
|
|
IPPAPI(IppStatus, ippiSqrIntegral_8u32s64f_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32s* pDst, int dstStep, Ipp64f* pSqr, int sqrStep, IppiSize roiSize,
|
|
Ipp32s val, Ipp64f valSqr))
|
|
|
|
IPPAPI(IppStatus, ippiTiltedSqrIntegral_8u32s64f_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32s* pDst, int dstStep, Ipp64f* pSqr, int sqrStep, IppiSize roiSize,
|
|
Ipp32s val, Ipp64f valSqr))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiIntegral_8u32f_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f val))
|
|
|
|
IPPAPI(IppStatus, ippiTiltedIntegral_8u32f_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f val))
|
|
|
|
IPPAPI(IppStatus, ippiSqrIntegral_8u32f64f_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, Ipp64f* pSqr, int sqrStep, IppiSize roiSize,
|
|
Ipp32f val, Ipp64f valSqr))
|
|
|
|
IPPAPI(IppStatus, ippiTiltedSqrIntegral_8u32f64f_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, Ipp64f* pSqr, int sqrStep, IppiSize roiSize,
|
|
Ipp32f val, Ipp64f valSqr))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Image Mean and Variance *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMean_8u_C1MR, ippiMean_8s_C1MR, ippiMean_16u_C1MR, ippiMean_32f_C1MR,
|
|
// ippiMean_8u_C3CMR, ippiMean_8s_C3CMR, ippiMean_16u_C3CMR, ippiMean_32f_C3CMR
|
|
//
|
|
// Purpose: Find mean value for selected region
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsCOIErr COI index is illegal (coi<1 || coi>3)
|
|
//
|
|
// Parameters:
|
|
// pSrc Pointer to image
|
|
// srcStep Image step
|
|
// pMask Pointer to mask image
|
|
// maskStep Step in the mask image
|
|
// roiSize Size of image ROI
|
|
// coi Index of color channel (1..3) (if color image)
|
|
// pMean Returned mean value
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
IPPAPI( IppStatus, ippiMean_8u_C1MR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pMean ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pMean ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_8s_C1MR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pMean ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_8s_C3CMR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pMean ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_16u_C1MR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pMean ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pMean ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pMean ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pMean ))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMean_StdDev_8u_C1R, ippiMean_StdDev_8s_C1R,
|
|
// ippiMean_StdDev_16u_C1R, ippiMean_StdDev_32f_C1R,
|
|
// ippiMean_StdDev_8u_C3CR, ippiMean_StdDev_8s_C3CR,
|
|
// ippiMean_StdDev_16u_C3CR, ippiMean_StdDev_32f_C3CR
|
|
//
|
|
// Purpose: Find mean and standard deviation values for selected region
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsCOIErr COI index is illegal (coi<1 || coi>3)
|
|
//
|
|
// Parameters:
|
|
// pSrc Pointer to image
|
|
// srcStep Image step
|
|
// roiSize Size of image ROI
|
|
// coi Index of color channel (1..3) (if color image)
|
|
// pMean Returned mean value
|
|
// pStdDev Returned standard deviation
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_8u_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
IppiSize roiSize,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_8u_C3CR, ( const Ipp8u* pSrc, int srcStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_8s_C1R, ( const Ipp8s* pSrc, int srcStep,
|
|
IppiSize roiSize,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_8s_C3CR, ( const Ipp8s* pSrc, int srcStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_16u_C1R, ( const Ipp16u* pSrc, int srcStep,
|
|
IppiSize roiSize,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_16u_C3CR, ( const Ipp16u* pSrc, int srcStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_32f_C1R, ( const Ipp32f* pSrc, int srcStep,
|
|
IppiSize roiSize,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_32f_C3CR, ( const Ipp32f* pSrc, int srcStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMean_StdDev_8u_C1MR, ippiMean_StdDev_8s_C1MR,
|
|
// ippiMean_StdDev_16u_C1MR, ippiMean_StdDev_32f_C1MR,
|
|
// ippiMean_StdDev_8u_C3CMR, ippiMean_StdDev_8s_C3CMR,
|
|
// ippiMean_StdDev_16u_C3CMR, ippiMean_StdDev_32f_C3CMR
|
|
//
|
|
// Purpose: Find mean and standard deviation values for selected region
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc Pointer to image
|
|
// srcStep Image step
|
|
// pMask Pointer to mask image
|
|
// maskStep Step in the mask image
|
|
// roiSize Size of image ROI
|
|
// coi Index of color channel (1..3) (if color image)
|
|
// pMean Returned mean value
|
|
// pStdDev Returned standard deviation
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_8u_C1MR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_8s_C1MR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_8s_C3CMR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_16u_C1MR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
IPPAPI( IppStatus, ippiMean_StdDev_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp64f* pMean, Ipp64f* pStdDev ))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Variance on Window *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/*F/////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiRectStdDev_32s32f_C1R, ippiRectStdDev_32f_C1R
|
|
// ippiTiltedRectStdDev_32s32f_C1R, ippiTiltedRectStdDev_32f_C1R
|
|
// ippiRectStdDev_32s_C1RSfs, ippiTiltedRectStdDev_32s_C1RSfs
|
|
//
|
|
// Purpose: Calculates standard deviation on rectangular window
|
|
//
|
|
// Returns:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc The pointer to source image of integrals
|
|
// srcStep The step in source image
|
|
// pSqr The pointer to destination square integral image
|
|
// sqrStep The step in destination image
|
|
// pDst The pointer to destination image
|
|
// dstStep The step in destination image
|
|
// roiSize The destination image ROI size.
|
|
// rect The rectangular window for standard deviation calculation.
|
|
// scaleFactor Output scale factor
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiRectStdDev_32s_C1RSfs, (const Ipp32s* pSrc, int srcStep,
|
|
const Ipp32s* pSqr, int sqrStep, Ipp32s* pDst, int dstStep, IppiSize roi,
|
|
IppiRect rect, int scaleFactor))
|
|
|
|
IPPAPI(IppStatus, ippiRectStdDev_32s32f_C1R, (const Ipp32s* pSrc, int srcStep,
|
|
const Ipp64f* pSqr, int sqrStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiRect rect))
|
|
|
|
IPPAPI(IppStatus, ippiTiltedRectStdDev_32s32f_C1R, (const Ipp32s* pSrc, int srcStep,
|
|
const Ipp64f* pSqr, int sqrStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiRect rect))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiTiltedRectStdDev_32s_C1RSfs, (const Ipp32s* pSrc, int srcStep,
|
|
const Ipp32s* pSqr, int sqrStep, Ipp32s* pDst, int dstStep, IppiSize roi,
|
|
IppiRect rect, int scaleFactor))
|
|
|
|
IPPAPI(IppStatus, ippiRectStdDev_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
const Ipp64f* pSqr, int sqrStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiRect rect))
|
|
|
|
IPPAPI(IppStatus, ippiTiltedRectStdDev_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
const Ipp64f* pSqr, int sqrStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, IppiRect rect))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Image Minimum and Maximum *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMinMaxIndx_8u_C1R, ippiMinMaxIndx_8s_C1R,
|
|
// ippiMinMaxIndx_16u_C1R, ippiMinMaxIndx_32f_C1R,
|
|
// ippiMinMaxIndx_8u_C3CR, ippiMinMaxIndx_8s_C3CR,
|
|
// ippiMinMaxIndx_16u_C3CR, ippiMinMaxIndx_32f_C3CR,
|
|
//
|
|
// Purpose: Finds minimum and maximum values in the image and their coordinates
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc Pointer to image
|
|
// srcStep Image step
|
|
// roiSize Size of image ROI
|
|
// coi Index of color channel (1..3) (if color image)
|
|
// pMinVal Pointer to minimum value
|
|
// pMaxVal Pointer to maximum value
|
|
// pMinIndex Minimum's coordinates
|
|
// pMaxIndex Maximum's coordinates
|
|
//
|
|
// Notes:
|
|
// Any of output parameters is optional
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiMinMaxIndx_8u_C1R,( const Ipp8u* pSrc, int srcStep, IppiSize roiSize,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI(IppStatus, ippiMinMaxIndx_8u_C3CR,( const Ipp8u* pSrc, int srcStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI(IppStatus, ippiMinMaxIndx_8s_C1R,( const Ipp8s* pSrc, int step, IppiSize roiSize,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI(IppStatus, ippiMinMaxIndx_8s_C3CR,( const Ipp8s* pSrc, int step, IppiSize roiSize,
|
|
int coi, Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI(IppStatus, ippiMinMaxIndx_16u_C1R,( const Ipp16u* pSrc, int srcStep, IppiSize roiSize,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI(IppStatus, ippiMinMaxIndx_16u_C3CR,( const Ipp16u* pSrc, int srcStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI(IppStatus, ippiMinMaxIndx_32f_C1R,( const Ipp32f* pSrc, int step, IppiSize roiSize,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI(IppStatus, ippiMinMaxIndx_32f_C3CR,( const Ipp32f* pSrc, int step, IppiSize roiSize,
|
|
int coi, Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMinMaxIndx_8u_C1MR, ippiMinMaxIndx_8s_C1MR,
|
|
// ippiMinMaxIndx_16u_C1MR, ippiMinMaxIndx_32f_C1MR,
|
|
// ippiMinMaxIndx_8u_C3CMR, ippiMinMaxIndx_8s_C3CMR,
|
|
// ippiMinMaxIndx_16u_C3CMR, ippiMinMaxIndx_32f_C3CMR,
|
|
//
|
|
// Purpose: Finds minimum and maximum values in the image and their coordinates
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc Pointer to image
|
|
// srcStep Image step
|
|
// pMask Pointer to mask image
|
|
// maskStep Step in the mask image
|
|
// roiSize Size of image ROI
|
|
// coi Index of color channel (1..3) (if color image)
|
|
// pMinVal Pointer to minimum value
|
|
// pMaxVal Pointer to maximum value
|
|
// pMinIndex Minimum's coordinates
|
|
// pMaxIndex Maximum's coordinates
|
|
//
|
|
// Notes:
|
|
// Any of output parameters is optional
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiMinMaxIndx_8u_C1MR,( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI( IppStatus, ippiMinMaxIndx_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI( IppStatus, ippiMinMaxIndx_8s_C1MR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI( IppStatus, ippiMinMaxIndx_8s_C3CMR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI(IppStatus, ippiMinMaxIndx_16u_C1MR,( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI( IppStatus, ippiMinMaxIndx_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI( IppStatus, ippiMinMaxIndx_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
IPPAPI( IppStatus, ippiMinMaxIndx_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi,
|
|
Ipp32f* pMinVal, Ipp32f* pMaxVal,
|
|
IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Image Norms *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Names: ippiNorm_Inf_8u_C1MR, ippiNorm_Inf_8s_C1MR,
|
|
// ippiNorm_Inf_16u_C1MR, ippiNorm_Inf_32f_C1MR,
|
|
// ippiNorm_Inf_8u_C3CMR, ippiNorm_Inf_8s_C3CMR,
|
|
// ippiNorm_Inf_16u_C3CMR, ippiNorm_Inf_32f_C3CMR,
|
|
// ippiNormDiff_Inf_8u_C1MR, ippiNormDiff_Inf_8s_C1MR,
|
|
// ippiNormDiff_Inf_16u_C1MR, ippiNormDiff_Inf_32f_C1MR,
|
|
// ippiNormDiff_Inf_8u_C3CMR, ippiNormDiff_Inf_8s_C3CMR,
|
|
// ippiNormDiff_Inf_16u_C3CMR, ippiNormDiff_Inf_32f_C3CMR,
|
|
// ippiNormRel_Inf_8u_C1MR, ippiNormRel_Inf_8s_C1MR,
|
|
// ippiNormRel_Inf_16u_C1MR, ippiNormRel_Inf_32f_C1MR,
|
|
// ippiNormRel_Inf_8u_C3CMR, ippiNormRel_Inf_8s_C3CMR,
|
|
// ippiNormRel_Inf_16u_C3CMR, ippiNormRel_Inf_32f_C3CMR,
|
|
//
|
|
// ippiNorm_L1_8u_C1MR, ippiNorm_L1_8s_C1MR,
|
|
// ippiNorm_L1_16u_C1MR, ippiNorm_L1_32f_C1MR,
|
|
// ippiNorm_L1_8u_C3CMR, ippiNorm_L1_8s_C3CMR,
|
|
// ippiNorm_L1_16u_C3CMR, ippiNorm_L1_32f_C3CMR,
|
|
// ippiNormDiff_L1_8u_C1MR, ippiNormDiff_L1_8s_C1MR,
|
|
// ippiNormDiff_L1_16u_C1MR, ippiNormDiff_L1_32f_C1MR,
|
|
// ippiNormDiff_L1_8u_C3CMR, ippiNormDiff_L1_8s_C3CMR,
|
|
// ippiNormDiff_L1_16u_C3CMR, ippiNormDiff_L1_32f_C3CMR,
|
|
// ippiNormRel_L1_8u_C1MR, ippiNormRel_L1_8s_C1MR,
|
|
// ippiNormRel_L1_16u_C1MR, ippiNormRel_L1_32f_C1MR,
|
|
// ippiNormRel_L1_8u_C3CMR, ippiNormRel_L1_8s_C3CMR,
|
|
// ippiNormRel_L1_16u_C3CMR, ippiNormRel_L1_32f_C3CMR,
|
|
//
|
|
// ippiNorm_L2_8u_C1MR, ippiNorm_L2_8s_C1MR,
|
|
// ippiNorm_L2_16u_C1MR, ippiNorm_L2_32f_C1MR,
|
|
// ippiNorm_L2_8u_C3CMR, ippiNorm_L2_8s_C3CMR,
|
|
// ippiNorm_L2_16u_C3CMR, ippiNorm_L2_32f_C3CMR,
|
|
// ippiNormDiff_L2_8u_C1MR, ippiNormDiff_L2_8s_C1MR,
|
|
// ippiNormDiff_L2_16u_C1MR, ippiNormDiff_L2_32f_C1MR,
|
|
// ippiNormDiff_L2_8u_C3CMR, ippiNormDiff_L2_8s_C3CMR,
|
|
// ippiNormDiff_L2_16u_C3CMR, ippiNormDiff_L2_32f_C3CMR,
|
|
// ippiNormRel_L2_8u_C1MR, ippiNormRel_L2_8s_C1MR,
|
|
// ippiNormRel_L2_16u_C1MR, ippiNormRel_L2_32f_C1MR,
|
|
// ippiNormRel_L2_8u_C3CMR, ippiNormRel_L2_8s_C3CMR,
|
|
// ippiNormRel_L2_16u_C3CMR, ippiNormRel_L2_32f_C3CMR
|
|
//
|
|
// Purpose: Calculates ordinary, differential or relative norms of one or two images
|
|
// in an arbitrary image region.
|
|
//
|
|
// Returns:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc, pSrc1 Pointers to source and mask images
|
|
// pSrc2, pMask
|
|
// srcStep, src1Step Their steps
|
|
// src2Step, maskStep
|
|
// roiSize Their size or ROI size
|
|
// coi COI index (1..3) (if 3-channel images)
|
|
// pNorm The pointer to calculated norm
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
/* ///////////////////////////////// 8uC1 flavor ////////////////////////////////////// */
|
|
|
|
IPPAPI( IppStatus, ippiNorm_Inf_8u_C1MR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_Inf_8s_C1MR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_Inf_16u_C1MR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_Inf_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_Inf_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_Inf_8s_C3CMR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_Inf_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_Inf_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_Inf_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_Inf_8s_C1MR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_Inf_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_Inf_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_Inf_8u_C3CMR, (const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_Inf_8s_C3CMR, (const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_Inf_16u_C3CMR, (const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_Inf_32f_C3CMR, (const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_Inf_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_Inf_8s_C1MR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_Inf_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_Inf_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_Inf_8u_C3CMR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_Inf_8s_C3CMR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_Inf_16u_C3CMR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_Inf_32f_C3CMR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L1_8u_C1MR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L1_8s_C1MR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L1_16u_C1MR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L1_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L1_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L1_8s_C3CMR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L1_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L1_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L1_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L1_8s_C1MR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L1_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L1_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L1_8u_C3CMR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L1_8s_C3CMR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L1_16u_C3CMR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L1_32f_C3CMR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L1_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L1_8s_C1MR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L1_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L1_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L1_8u_C3CMR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L1_8s_C3CMR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L1_16u_C3CMR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L1_32f_C3CMR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L2_8u_C1MR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L2_8s_C1MR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L2_16u_C1MR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L2_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L2_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L2_8s_C3CMR, ( const Ipp8s* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L2_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
|
|
const Ipp8u* pMask,int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNorm_L2_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ) )
|
|
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L2_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L2_8s_C1MR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L2_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L2_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L2_8u_C3CMR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L2_8s_C3CMR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L2_16u_C3CMR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormDiff_L2_32f_C3CMR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L2_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L2_8s_C1MR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L2_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L2_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp64f* pNorm ) )
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L2_8u_C3CMR, ( const Ipp8u* pSrc1, int src1Step,
|
|
const Ipp8u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L2_8s_C3CMR, ( const Ipp8s* pSrc1, int src1Step,
|
|
const Ipp8s* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L2_16u_C3CMR, ( const Ipp16u* pSrc1, int src1Step,
|
|
const Ipp16u* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
IPPAPI( IppStatus, ippiNormRel_L2_32f_C3CMR, ( const Ipp32f* pSrc1, int src1Step,
|
|
const Ipp32f* pSrc2, int src2Step,
|
|
const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int coi, Ipp64f* pNorm ))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Edge/Corner detection *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiCannyGetSize
|
|
//
|
|
// Purpose: Calculates size of temporary buffer, required to run Canny function.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr Pointer bufferSize is NULL
|
|
// ippStsSizeErr roiSize has a field with zero or negative value
|
|
//
|
|
// Parameters:
|
|
// roiSize Size of image ROI in pixel
|
|
// bufferSize Pointer to the variable that returns the size of the temporary buffer
|
|
//F*/
|
|
|
|
IPPAPI( IppStatus, ippiCannyGetSize, ( IppiSize roiSize, int* bufferSize ))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiCanny_16s8u_C1IR, ippiCanny_32f8u_C1IR
|
|
//
|
|
// Purpose: Creates binary image of source's image edges,
|
|
// using derivatives of the first order.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsBadArgErr Bad thresholds
|
|
//
|
|
// Parameters:
|
|
// pSrcDx Pointers to the source image ( first derivatives with respect to X )
|
|
// srcDxStep Step in bytes through the source image pSrcDx
|
|
// pSrcDy Pointers to the source image ( first derivatives with respect to Y )
|
|
// srcDyStep Step in bytes through the source image pSrcDy
|
|
//
|
|
// roiSize Size of the source images ROI in pixels
|
|
// lowThresh Low threshold for edges detection
|
|
// highThresh Upper threshold for edges detection
|
|
// pBuffer Pointer to the pre-allocated temporary buffer, which size can be
|
|
// calculated using ippiCannyGetSize function
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiCanny_16s8u_C1R, ( Ipp16s* pSrcDx, int srcDxStep,
|
|
Ipp16s* pSrcDy, int srcDyStep,
|
|
Ipp8u* pDstEdges, int dstEdgeStep,
|
|
IppiSize roiSize,
|
|
Ipp32f lowThresh,
|
|
Ipp32f highThresh,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiCanny_32f8u_C1R, ( Ipp32f* pSrcDx, int srcDxStep,
|
|
Ipp32f* pSrcDy, int srcDyStep,
|
|
Ipp8u* pDstEdges, int dstEdgeStep,
|
|
IppiSize roiSize,
|
|
Ipp32f lowThresh,
|
|
Ipp32f highThresh,
|
|
Ipp8u* pBuffer ))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiEigenValsVecsGetBufferSize_8u32f_C1R, ippiEigenValsVecsGetBufferSize_32f_C1R
|
|
//
|
|
// Purpose: Calculates size of temporary buffer, required to run one of EigenValsVecs***
|
|
// functions.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width is less or equal zero or bad window size
|
|
//
|
|
// Parameters:
|
|
// roiSize roiSize size in pixels
|
|
// apertureSize Linear size of derivative filter aperture
|
|
// avgWindow Linear size of averaging window
|
|
// bufferSize Output parameter. Calculated buffer size.
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiEigenValsVecsGetBufferSize_8u32f_C1R, ( IppiSize roiSize,int apertureSize,
|
|
int avgWindow, int* bufferSize ))
|
|
IPPAPI(IppStatus, ippiEigenValsVecsGetBufferSize_32f_C1R, ( IppiSize roiSize,int apertureSize,
|
|
int avgWindow, int* bufferSize ))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiEigenValsVecs_8u32f_C1R, ippiEigenValsVecs_32f_C1R
|
|
//
|
|
// Purpose: Calculate both eigen values and eigen vectors of 2x2 autocorrelation
|
|
// gradient matrix for every pixel. Can be used for sophisticated
|
|
// edge and corner detection
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// or bad window size
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc Source image
|
|
// srcStep Its step
|
|
// pEigenVV Image, which is 6 times wider that source image,
|
|
// filled with 6-tuples:
|
|
// (eig_val1, eig_val2, eig_vec1_x, eig_vec1_y,
|
|
// eig_vec2_x, eig_vec2_y)
|
|
// eigStep Output image step
|
|
// roiSize ROI size
|
|
// kernType Kernel type (Scharr 3x3 or Sobel 3x3, 5x5)
|
|
// apertureSize Linear size of derivative filter aperture
|
|
// avgWindow Linear size of averaging window
|
|
// pBuffer Preallocated temporary buffer, which size can be calculated
|
|
// using ippiEigenValsVecsGetSize function
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiEigenValsVecs_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pEigenVV, int eigStep,
|
|
IppiSize roiSize, IppiKernelType kernType,
|
|
int apertureSize, int avgWindow, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiEigenValsVecs_32f_C1R, ( const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pEigenVV, int eigStep,
|
|
IppiSize roiSize, IppiKernelType kernType,
|
|
int apertureSize, int avgWindow, Ipp8u* pBuffer ))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMinEigenValGetBufferSize_8u32f_C1R, ippiMinEigenValGetBufferSize_32f_C1R
|
|
//
|
|
// Purpose: Calculates size of temporary buffer, required to run one of MinEigenVal***
|
|
// functions.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width is less or equal zero or bad window size
|
|
//
|
|
// Parameters:
|
|
// roiSize roiSize size in pixels
|
|
// apertureSize Linear size of derivative filter aperture
|
|
// avgWindow Linear size of averaging window
|
|
// bufferSize Output parameter. Calculated buffer size.
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiMinEigenValGetBufferSize_8u32f_C1R, ( IppiSize roiSize, int apertureSize,
|
|
int avgWindow, int* bufferSize ))
|
|
|
|
IPPAPI(IppStatus, ippiMinEigenValGetBufferSize_32f_C1R, ( IppiSize roiSize, int apertureSize,
|
|
int avgWindow, int* bufferSize ))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiMinEigenVal_8u32f_C1R, ippiMinEigenVal_32f_C1R
|
|
//
|
|
// Purpose: Calculate minimal eigen value of 2x2 autocorrelation gradient matrix
|
|
// for every pixel. Pixels with relatively large minimal eigen values
|
|
// are strong corners on the picture.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// or bad window size
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc Source image
|
|
// srcStep Its step
|
|
// pMinEigenVal Image, filled with minimal eigen values for every pixel
|
|
// minValStep Its step
|
|
// roiSize ROI size
|
|
// kernType Kernel type (Scharr 3x3 or Sobel 3x3, 5x5)
|
|
// apertureSize Linear size of derivative filter aperture
|
|
// avgWindow Linear size of averaging window
|
|
// pBuffer Preallocated temporary buffer, which size can be calculated
|
|
// using ippiMinEigenValGetSize function
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiMinEigenVal_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pMinEigenVal, int minValStep,
|
|
IppiSize roiSize, IppiKernelType kernType,
|
|
int apertureSize, int avgWindow, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiMinEigenVal_32f_C1R, ( const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pMinEigenVal, int minValStep,
|
|
IppiSize roiSize, IppiKernelType kernType,
|
|
int apertureSize, int avgWindow, Ipp8u* pBuffer ))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Distance Transform *
|
|
\****************************************************************************************/
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiTrueDistanceTransformGetBufferSize_8u16u_C1RSfs,
|
|
// ippiTrueDistanceTransformGetBufferSize_8u32f_C1R
|
|
//
|
|
// Purpose: Get size of external buffer.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr Indicates an error condition if roiSize has a field with zero
|
|
// or negative value.
|
|
//
|
|
// Parameters:
|
|
// roiSize The image ROI size
|
|
// pBufferSize The pointer to the buffer size
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiTrueDistanceTransformGetBufferSize_8u16u_C1RSfs, (IppiSize roiSize, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiTrueDistanceTransformGetBufferSize_8u32f_C1R, (IppiSize roiSize, int* pBufferSize))
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiDistanceTransform_3x3_8u32f_C1R, ippiDistanceTransform_5x5_8u32f_C1R,
|
|
// ippiDistanceTransform_3x3_8u16u_C1R, ippiDistanceTransform_5x5_8u16u_C1R,
|
|
// ippiDistanceTransform_3x3_8u_C1R, ippiDistanceTransform_5x5_8u_C1R,
|
|
// ippiDistanceTransform_3x3_8u_C1IR, ippiDistanceTransform_5x5_8u_C1IR,
|
|
// ippiTrueDistanceTransform_8u16u_C1RSfs,
|
|
// ippiTrueDistanceTransform_8u32f_C1R
|
|
//
|
|
// Purpose: For every non-zero pixel in the source image, the functions calculate
|
|
// distance between that pixel and nearest zero pixel.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsCoeffErr Zero mask coefficient
|
|
//
|
|
// Parameters:
|
|
// pSrc Source image
|
|
// pSrcDst Pointer to the input and output image
|
|
// srcStep Its step
|
|
// pDst Output image with distances
|
|
// dstStep Its step
|
|
// roiSize ROI size
|
|
// pMetrics Array that determines metrics used.
|
|
// scaleFactor Scale factor
|
|
// pBuffer The pointer to the working buffer
|
|
//
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiDistanceTransform_3x3_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp32f* pMetrics ))
|
|
|
|
IPPAPI(IppStatus, ippiDistanceTransform_5x5_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp32f* pMetrics ))
|
|
|
|
IPPAPI(IppStatus, ippiDistanceTransform_3x3_8u16u_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp16u* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp32s* pMetrics ))
|
|
|
|
IPPAPI(IppStatus, ippiDistanceTransform_5x5_8u16u_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp16u* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp32s* pMetrics ))
|
|
|
|
IPPAPI(IppStatus, ippiDistanceTransform_3x3_8u_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp32s* pMetrics ))
|
|
|
|
IPPAPI(IppStatus, ippiDistanceTransform_5x5_8u_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp32s* pMetrics ))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiDistanceTransform_3x3_8u_C1IR, ( Ipp8u* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize, Ipp32s* pMetrics ))
|
|
|
|
IPPAPI(IppStatus, ippiDistanceTransform_5x5_8u_C1IR, ( Ipp8u* pSrcDst, int srcDstStep,
|
|
IppiSize roiSize, Ipp32s* pMetrics ))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiTrueDistanceTransform_8u16u_C1RSfs, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp16u* pDst, int dstStep,
|
|
IppiSize roiSize, int scaleFactor,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiTrueDistanceTransform_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiGetDistanceTransformMask_32f, ippiGetDistanceTransformMask_32s
|
|
// ippiGetDistanceTransformMask (deprecated name of ippiGetDistanceTransformMask_32f)
|
|
//
|
|
// Purpose: Calculates optimal mask for given type of metrics and given mask size
|
|
//
|
|
// Return:
|
|
// ippStsOk Succeed
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsBadArgErr Bad kernel size or norm or maskType
|
|
//
|
|
// Parameters:
|
|
// kerSize Kernel size (3,5)
|
|
// norm Norm type (L1,L2,Inf)
|
|
// maskType Type of distance:
|
|
// 30 - 3x3 aperture for infinify norm,
|
|
// 31 - 3x3 aperture for L1 norm,
|
|
// 32 - 3x3 aperture for L2 norm,
|
|
// 50 - 5x5 aperture for infinify norm,
|
|
// 51 - 5x5 aperture for L1 norm,
|
|
// 52 - 5x5 aperture for L2 norm
|
|
// pMetrics Pointer to resultant metrics
|
|
//F*/
|
|
|
|
IPPAPI( IppStatus, ippiGetDistanceTransformMask_32f, ( int kerSize, IppiNorm norm, Ipp32f* pMetrics ))
|
|
|
|
IPPAPI( IppStatus, ippiGetDistanceTransformMask_32s, ( int kerSize, IppiNorm norm, Ipp32s* pMetrics ))
|
|
|
|
IPPAPI( IppStatus, ippiGetDistanceTransformMask, ( int maskType, Ipp32f* pMetrics ))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFastMarchingGetBufferSize_8u32f_C1R
|
|
//
|
|
// Purpose: Get size of external buffer.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image or kernel size are less or equal zero
|
|
//
|
|
// Parameters:
|
|
// roiSize The image ROI size
|
|
// pBufferSize The pointer to the buffer size
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiFastMarchingGetBufferSize_8u32f_C1R, (IppiSize roiSize, int* pBufferSize))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFastMarching_8u32f_C1R
|
|
//
|
|
// Purpose: Calculate distance transform by fast marching method
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image or kernel size are less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Parameters:
|
|
// pSrc Source image
|
|
// srcStep Its step
|
|
// pDst Output image with distances
|
|
// dstStep Its step
|
|
// roiSize The image ROI size
|
|
// radius The radius of external neighborhood
|
|
// pBuffer Pointer to working buffer
|
|
//
|
|
// Note: dst = min((src1+src1+sqrt(2-(src1-src2)**2))/2,min(src1,src2)+1)
|
|
// for four neighbour pairs
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiFastMarching_8u32f_C1R, (const Ipp8u* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp32f radius, Ipp8u* pBuffer))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Flood Fill *
|
|
\****************************************************************************************/
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFloodFillGetSize_4Con, ippiFloodFillGetSize_8Con
|
|
// ippiFloodFillGetSize_Grad4Con, ippiFloodFillGetSize_Grad8Con
|
|
//
|
|
// Purpose: The functions calculate size of temporary buffer, required to run
|
|
// one of the corresponding flood fill functions.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
//
|
|
// Parameters:
|
|
// roiSize ROI size
|
|
// pBufSize Temporary buffer size
|
|
//F*/
|
|
|
|
IPPAPI( IppStatus, ippiFloodFillGetSize, ( IppiSize roiSize, int* pBufSize ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFillGetSize_Grad, ( IppiSize roiSize, int* pBufSize ))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Names: ippiFloodFill_4Con_8u_C1IR, ippiFloodFill_4Con_32f_C1IR,
|
|
// ippiFloodFill_8Con_8u_C1IR, ippiFloodFill_8Con_32f_C1IR,
|
|
// ippiFloodFill_Grad4Con_8u_C1IR, ippiFloodFill_Grad4Con_32f_C1IR,
|
|
// ippiFloodFill_Grad8Con_8u_C1IR, ippiFloodFill_Grad8Con_32f_C1IR
|
|
// ippiFloodFill_Range4Con_8u_C1IR, ippiFloodFill_Range4Con_32f_C1IR,
|
|
// ippiFloodFill_Range8Con_8u_C1IR, ippiFloodFill_Range8Con_32f_C1IR
|
|
// ippiFloodFill_4Con_8u_C3IR, ippiFloodFill_4Con_32f_C3IR,
|
|
// ippiFloodFill_8Con_8u_C3IR, ippiFloodFill_8Con_32f_C3IR,
|
|
// ippiFloodFill_Grad4Con_8u_C3IR, ippiFloodFill_Grad4Con_32f_C3IR,
|
|
// ippiFloodFill_Grad8Con_8u_C3IR, ippiFloodFill_Grad8Con_32f_C3IR
|
|
// ippiFloodFill_Range4Con_8u_C3IR, ippiFloodFill_Range4Con_32f_C3IR,
|
|
// ippiFloodFill_Range8Con_8u_C3IR, ippiFloodFill_Range8Con_32f_C3IR
|
|
// ippiFloodFill_4Con_16u_C1IR,
|
|
// ippiFloodFill_8Con_16u_C1IR,
|
|
// ippiFloodFill_Grad4Con_16u_C1IR,
|
|
// ippiFloodFill_Grad8Con_16u_C1IR,
|
|
// ippiFloodFill_Range4Con_16u_C1IR,
|
|
// ippiFloodFill_Range8Con_16u_C1IR,
|
|
// ippiFloodFill_4Con_16u_C3IR,
|
|
// ippiFloodFill_8Con_16u_C3IR,
|
|
// ippiFloodFill_Grad4Con_16u_C3IR,
|
|
// ippiFloodFill_Grad8Con_16u_C3IR,
|
|
// ippiFloodFill_Range4Con_16u_C3IR,
|
|
// ippiFloodFill_Range8Con_16u_C3IR,
|
|
//
|
|
// Purpose: The functions fill the seed pixel enewValirons inside which all pixel
|
|
// values are equal to (first 4 funcs) or not far from each other (the others).
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok.
|
|
// ippStsNullPtrErr One of pointers is NULL.
|
|
// ippStsSizeErr The width or height of images is less or equal zero.
|
|
// ippStsStepErr The steps in images are too small.
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsOutOfRangeErr Indicates an error condition if the seed point is out of ROI.
|
|
//
|
|
// Parameters:
|
|
// pImage Pointer to ROI of initial image (in the beginning)
|
|
// which is "repainted" during the function action,
|
|
// imageStep Full string length of initial image (in bytes),
|
|
// roi Size of image ROI,
|
|
// seed Coordinates of the seed point inside image ROI,
|
|
// newVal Value to fill with for one-channel data,
|
|
// pNewVal Pointer to the vector containing values to fill with
|
|
// for three-channel data,
|
|
// minDelta Minimum difference between neighbor pixels for one-channel data,
|
|
// maxDelta Maximum difference between neighbor pixels for one-channel data,
|
|
// pMinDelta Pointer to the minimum differences between neighbor pixels for
|
|
// three-channel images,
|
|
// pMaxDelta Pointer to the maximum differences between neighbor pixels for
|
|
// three-channel images,
|
|
// pRegion Pointer to repainted region properties structure,
|
|
// pBuffer Buffer needed for calculations (its size must be
|
|
// calculated by ippiFloodFillGetSize_Grad function).
|
|
//
|
|
// Notes: This function uses a rapid non-recursive algorithm.
|
|
//F*/
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_4Con_8u_C1IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u newVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_8Con_8u_C1IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u newVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_4Con_16u_C1IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u newVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_8Con_16u_C1IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u newVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_4Con_32f_C1IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f newVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_8Con_32f_C1IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f newVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad4Con_8u_C1IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u newVal, Ipp8u minDelta, Ipp8u maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad8Con_8u_C1IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u newVal, Ipp8u minDelta, Ipp8u maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad4Con_16u_C1IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u newVal, Ipp16u minDelta, Ipp16u maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad8Con_16u_C1IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u newVal, Ipp16u minDelta, Ipp16u maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad4Con_32f_C1IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f newVal, Ipp32f minDelta, Ipp32f maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad8Con_32f_C1IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f newVal, Ipp32f minDelta, Ipp32f maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range4Con_8u_C1IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u newVal, Ipp8u minDelta, Ipp8u maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range8Con_8u_C1IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u newVal, Ipp8u minDelta, Ipp8u maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range4Con_16u_C1IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u newVal, Ipp16u minDelta, Ipp16u maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range8Con_16u_C1IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u newVal, Ipp16u minDelta, Ipp16u maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range4Con_32f_C1IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f newVal, Ipp32f minDelta, Ipp32f maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range8Con_32f_C1IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f newVal, Ipp32f minDelta, Ipp32f maxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_4Con_8u_C3IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u *pNewVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_8Con_8u_C3IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u *pNewVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_4Con_16u_C3IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u *pNewVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_8Con_16u_C3IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u *pNewVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_4Con_32f_C3IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f *pNewVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_8Con_32f_C3IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f *pNewVal, IppiConnectedComp* pRegion,
|
|
Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad4Con_8u_C3IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u *pNewVal, Ipp8u *pMinDelta, Ipp8u *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad8Con_8u_C3IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u *pNewVal, Ipp8u *pMinDelta, Ipp8u *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad4Con_16u_C3IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u *pNewVal, Ipp16u *pMinDelta, Ipp16u *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad8Con_16u_C3IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u *pNewVal, Ipp16u *pMinDelta, Ipp16u *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad4Con_32f_C3IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f *pNewVal, Ipp32f *pMinDelta, Ipp32f *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Grad8Con_32f_C3IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f *pNewVal, Ipp32f *pMinDelta, Ipp32f *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range4Con_8u_C3IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u *pNewVal, Ipp8u *pMinDelta, Ipp8u *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range8Con_8u_C3IR, ( Ipp8u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp8u *pNewVal, Ipp8u *pMinDelta, Ipp8u *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range4Con_16u_C3IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u *pNewVal, Ipp16u *pMinDelta, Ipp16u *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range8Con_16u_C3IR, ( Ipp16u* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp16u *pNewVal, Ipp16u *pMinDelta, Ipp16u *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range4Con_32f_C3IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f *pNewVal, Ipp32f *pMinDelta, Ipp32f *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI( IppStatus, ippiFloodFill_Range8Con_32f_C3IR, ( Ipp32f* pImage, int imageStep,
|
|
IppiSize roiSize, IppiPoint seed,
|
|
Ipp32f *pNewVal, Ipp32f *pMinDelta, Ipp32f *pMaxDelta,
|
|
IppiConnectedComp* pRegion, Ipp8u* pBuffer ))
|
|
|
|
/****************************************************************************************\
|
|
* Motion Templates *
|
|
\****************************************************************************************/
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiUpdateMotionHistory_8u32f_C1IR, ippiUpdateMotionHistory_16u32f_C1IR
|
|
// ippiUpdateMotionHistory_32f_C1IR
|
|
//
|
|
// Purpose: Sets motion history image (MHI) pixels to the current time stamp
|
|
// when the corrensonding pixels in the silhoette image are non zero.
|
|
// Else (silhouette pixels are zero) MHI pixels are
|
|
// cleared if their values are too small (less than timestamp - mhiDuration),
|
|
// i.e. they were updated far ago last time. Else MHI pixels remain unchanged.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsOutOfRangeErr Maximal duration is negative
|
|
//
|
|
// Arguments:
|
|
// pSilhouette The pointer to silhouette image
|
|
// silhStep The step in silhouette image
|
|
// pMHI The pointer to motion history image
|
|
// mhiStep The step in mhi image
|
|
// roiSize ROI size
|
|
// timestamp Current time stamp (milliseconds)
|
|
// mhiDuration Maximal duration of motion track (milliseconds)
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiUpdateMotionHistory_8u32f_C1IR,
|
|
( const Ipp8u* pSilhouette, int silhStep,
|
|
Ipp32f* pMHI, int mhiStep, IppiSize roiSize,
|
|
Ipp32f timestamp, Ipp32f mhiDuration ))
|
|
|
|
IPPAPI(IppStatus, ippiUpdateMotionHistory_16u32f_C1IR,
|
|
( const Ipp16u* pSilhouette, int silhStep,
|
|
Ipp32f* pMHI, int mhiStep, IppiSize roiSize,
|
|
Ipp32f timestamp, Ipp32f mhiDuration ))
|
|
|
|
IPPAPI(IppStatus, ippiUpdateMotionHistory_32f_C1IR,
|
|
( const Ipp32f* pSilhouette, int silhStep,
|
|
Ipp32f* pMHI, int mhiStep, IppiSize roiSize,
|
|
Ipp32f timestamp, Ipp32f mhiDuration ))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Optical Flow *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiOpticalFlowPyrLKInitAlloc_8u_C1R, ippiOpticalFlowPyrLKInitAlloc_16u_C1R,
|
|
// ippiOpticalFlowPyrLKInitAlloc_32f_C1R
|
|
//
|
|
// Purpose: allocates memory and initializes a structure for pyramidal L-K algorithm
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Indicates no error. Any other value indicates an error or a warning.
|
|
// ippStsNullPtrErr Indicates an error if ppState is NULL.
|
|
// ippStsSizeErr Indicates an error condition if roiSize has a field with zero
|
|
// or negative value or if winSize is equal to or less than 0.
|
|
// ippStsMemAllocErr Memory allocation error
|
|
//
|
|
// Arguments:
|
|
// pState Pointer to initialized structure
|
|
// roi Maximal image ROI
|
|
// winSize Size of search window (2*winSize+1)
|
|
// hint Option to select the algorithmic implementation of the function
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiOpticalFlowPyrLKInitAlloc_8u_C1R, (IppiOptFlowPyrLK_8u_C1R** ppState, IppiSize roiSize,
|
|
int winSize, IppHintAlgorithm hint))
|
|
|
|
IPPAPI(IppStatus, ippiOpticalFlowPyrLKInitAlloc_16u_C1R, (IppiOptFlowPyrLK_16u_C1R** ppState, IppiSize roiSize,
|
|
int winSize, IppHintAlgorithm hint))
|
|
|
|
IPPAPI(IppStatus, ippiOpticalFlowPyrLKInitAlloc_32f_C1R, (IppiOptFlowPyrLK_32f_C1R** ppState, IppiSize roiSize,
|
|
int winSize, IppHintAlgorithm hint))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiOpticalFlowPyrLKFree_8u_C1R, ippiOpticalFlowPyrLKFree_16u_C1R,
|
|
// ippiOpticalFlowPyrLKFree_32f_C1R
|
|
//
|
|
// Purpose: Free structure for pyramidal L-K algorithm
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
//
|
|
// Arguments:
|
|
// pState Pointer to initialized structure
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiOpticalFlowPyrLKFree_8u_C1R, (IppiOptFlowPyrLK_8u_C1R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiOpticalFlowPyrLKFree_16u_C1R, (IppiOptFlowPyrLK_16u_C1R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiOpticalFlowPyrLKFree_32f_C1R, (IppiOptFlowPyrLK_32f_C1R* pState))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiOpticalFlowPyrLK_8u_C1R, ippiOpticalFlowPyrLK_16u_C1R,
|
|
// ippiOpticalFlowPyrLK_32f_C1R
|
|
//
|
|
// Purpose:
|
|
// Pyramidal version of Lucas - Kanade method of optical flow calculation
|
|
//
|
|
// Returns:
|
|
// ippStsNoErr Indicates no error. Any other value indicates an error or a warning
|
|
// ippStsNullPtrErr Indicates an error if one of the specified pointer is NULL
|
|
// ippStsSizeErr Indicates an error condition if numFeat or winSize has zero or
|
|
// negative value.
|
|
// ippStsBadArgErr Indicates an error condition if maxLev or threshold has negative
|
|
// value, or maxIter has zero or negative value.
|
|
//
|
|
// Arguments:
|
|
// pPyr1 Pointer to the first image pyramid (time t)
|
|
// pPyr2 Pointer to the second image pyramid (time t+dt)
|
|
// pPrev Array of points, for which the flow needs to be found
|
|
// pNext Array of new positions of pPrev points
|
|
// pError Array of differences between pPrev and pNext points
|
|
// pStatus Array of result indicator (0 - not calculated)
|
|
// numFeat Number of points to calculate optical flow
|
|
// winSize Size of search window (2*winSize+1)
|
|
// maxLev Pyramid level to start the operation
|
|
// maxIter Maximum number of algorithm iterations for each pyramid level
|
|
// threshold Threshold value to stop new position search
|
|
// pState Pointer to structure
|
|
//
|
|
// Notes: For calculating spatial derivatives 3x3 Scharr operator is used.
|
|
// The values of pixels beyond the image are determined using replication mode.
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiOpticalFlowPyrLK_8u_C1R, (IppiPyramid *pPyr1, IppiPyramid *pPyr2,
|
|
const IppiPoint_32f *pPrev, IppiPoint_32f *pNext, Ipp8s *pStatus, Ipp32f *pError,
|
|
int numFeat, int winSize, int maxLev, int maxIter, Ipp32f threshold,
|
|
IppiOptFlowPyrLK_8u_C1R *pState))
|
|
|
|
IPPAPI(IppStatus, ippiOpticalFlowPyrLK_16u_C1R, (IppiPyramid *pPyr1, IppiPyramid *pPyr2,
|
|
const IppiPoint_32f *pPrev, IppiPoint_32f *pNext, Ipp8s *pStatus, Ipp32f *pError,
|
|
int numFeat, int winSize, int maxLev, int maxIter, Ipp32f threshold,
|
|
IppiOptFlowPyrLK_16u_C1R *pState))
|
|
|
|
IPPAPI(IppStatus, ippiOpticalFlowPyrLK_32f_C1R, (IppiPyramid *pPyr1, IppiPyramid *pPyr2,
|
|
const IppiPoint_32f *pRrev, IppiPoint_32f *pNext, Ipp8s *pStatus, Ipp32f *pError,
|
|
int numFeat, int winSize, int maxLev, int maxIter, Ipp32f threshold,
|
|
IppiOptFlowPyrLK_32f_C1R *pState))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Gaussian Pyramids *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiPyrUpGetBufSize_Gauss5x5, ippiPyrDownGetBufSize_Gauss5x5
|
|
//
|
|
// Purpose: Calculates cyclic buffer size for pyramids.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr The pbufSize pointer is NULL
|
|
// ippStsSizeErr The value of roiWidth is zerro or negative
|
|
// ippStsDataTypeErr The dataType is not Ipp8u, Ipp8s or Ipp32f
|
|
// ippStsNumChannensErr The channels is not 1 or 3
|
|
//
|
|
// Arguments:
|
|
// roiWidth Width of image ROI in pixels
|
|
// dataType Data type of the source image
|
|
// channels Number of image channels
|
|
// pbufSize Pointer to the variable that return the size of the temporary buffer.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiPyrUpGetBufSize_Gauss5x5, (int roiWidth, IppDataType dataType,
|
|
int channels, int* bufSize))
|
|
|
|
IPPAPI(IppStatus, ippiPyrDownGetBufSize_Gauss5x5, (int roiWidth, IppDataType dataType,
|
|
int channels, int* bufSize))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiPyrDown_Gauss5x5_8u_C1R, ippiPyrDown_Gauss5x5_8u_C3R,
|
|
// ippiPyrDown_Gauss5x5_8s_C1R, ippiPyrDown_Gauss5x5_8s_C3R,
|
|
// ippiPyrDown_Gauss5x5_32f_C1R, ippiPyrDown_Gauss5x5_32f_C3R,
|
|
//
|
|
// ippiPyrUp_Gauss5x5_8u_C1R, ippiPyrUp_Gauss5x5_8u_C3R,
|
|
// ippiPyrUp_Gauss5x5_8s_C1R, ippiPyrUp_Gauss5x5_8s_C3R,
|
|
// ippiPyrUp_Gauss5x5_32f_C1R, ippiPyrUp_Gauss5x5_32f_C3R,
|
|
//
|
|
// Purpose: Perform downsampling/upsampling of the image with 5x5 gaussian.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero.
|
|
// ippStsStepErr Step is too small to fit image.
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Arguments:
|
|
// pSrc Pointer to source image
|
|
// srcStep Step in bytes through the source image
|
|
// pDst Pointer to destination image
|
|
// dstStep Step in bytes through the destination image
|
|
// roiSize Size of the source image ROI in pixel. Destination image width and
|
|
// height will be twice large (PyrUp)
|
|
// or twice smaller (PyrDown)
|
|
// pBuffer Pointer to the the temporary buffer of the size calculated by
|
|
// ippPyrUpGetSize_Gauss_5x5 or ippPyrDownGetSize_Gauss_5x5
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiPyrUp_Gauss5x5_8u_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrUp_Gauss5x5_8u_C3R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrUp_Gauss5x5_8s_C1R, (const Ipp8s* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrUp_Gauss5x5_8s_C3R, (const Ipp8s* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrUp_Gauss5x5_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrUp_Gauss5x5_32f_C3R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrDown_Gauss5x5_8u_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrDown_Gauss5x5_8u_C3R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrDown_Gauss5x5_8s_C1R, (const Ipp8s* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrDown_Gauss5x5_8s_C3R, (const Ipp8s* pSrc, int srcStep,
|
|
Ipp8s* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrDown_Gauss5x5_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
IPPAPI(IppStatus, ippiPyrDown_Gauss5x5_32f_C3R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize, Ipp8u* pBuffer ))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Universal Pyramids *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiPyramidInitAlloc, ippiPyramidFree
|
|
//
|
|
// Purpose: Initializes structure for pyramids, calculates ROI for layers,
|
|
// allocates images for layers.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsBadArgErr Bad rate or level
|
|
// ippStsMemAllocErr Memory allocation error
|
|
//
|
|
// Arguments:
|
|
// ppPyr Pointer to the pointer to the pyramid structure.
|
|
// pPyr Pointer to the pyramid structure.
|
|
// level Maximal number pyramid level.
|
|
// roiSize Lowest level image ROI size.
|
|
// rate Neighbour levels ratio (1<rate<=10)
|
|
*/
|
|
IPPAPI(IppStatus, ippiPyramidInitAlloc,(IppiPyramid** ppPyr, int level, IppiSize roiSize, Ipp32f rate))
|
|
IPPAPI(IppStatus, ippiPyramidFree,(IppiPyramid* pPyr))
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiPyramidLayerDownInitAlloc_8u_C1R, ippiPyramidLayerDownInitAlloc_8u_C3R
|
|
// ippiPyramidLayerDownInitAlloc_16u_C1R, ippiPyramidLayerDownInitAlloc_16u_C3R
|
|
// ippiPyramidLayerDownInitAlloc_32f_C1R, ippiPyramidLayerDownInitAlloc_32f_C3R
|
|
// ippiPyramidLayerUpInitAlloc_8u_C1R, ippiPyramidLayerUpInitAlloc_8u_C3R
|
|
// ippiPyramidLayerUpInitAlloc_16u_C1R, ippiPyramidLayerUpInitAlloc_16u_C3R
|
|
// ippiPyramidLayerUpInitAlloc_32f_C1R, ippiPyramidLayerUpInitAlloc_32f_C3R
|
|
//
|
|
// Purpose: Initializes structure for pyramid layer calculation
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsBadArgErr Bad mode, rate or kernel size
|
|
// ippStsMemAllocErr Memory allocation error
|
|
//
|
|
// Arguments:
|
|
// ppState Pointer to the pointer to initialized structure
|
|
// srcRoi Source image ROI size.
|
|
// dstRoi Destination image ROI size.
|
|
// rate Neighbour levels ratio (1<rate<4)
|
|
// pKernel Separable symmetric kernel of odd length
|
|
// kerSize Kernel size
|
|
// mode IPPI_INTER_LINEAR - bilinear interpolation
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownInitAlloc_8u_C1R, (IppiPyramidDownState_8u_C1R** ppState, IppiSize srcRoi,
|
|
Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownInitAlloc_16u_C1R,(IppiPyramidDownState_16u_C1R** ppState, IppiSize srcRoi,
|
|
Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownInitAlloc_32f_C1R,(IppiPyramidDownState_32f_C1R** ppState, IppiSize srcRoi,
|
|
Ipp32f rate, Ipp32f* pKernel, int kerSize, int mode))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownInitAlloc_8u_C3R, (IppiPyramidDownState_8u_C3R** ppState, IppiSize srcRoi,
|
|
Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownInitAlloc_16u_C3R,(IppiPyramidDownState_16u_C3R** ppState, IppiSize srcRoi,
|
|
Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownInitAlloc_32f_C3R,(IppiPyramidDownState_32f_C3R** ppState, IppiSize srcRoi,
|
|
Ipp32f rate, Ipp32f* pKernel, int kerSize, int mode))
|
|
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpInitAlloc_8u_C1R, (IppiPyramidUpState_8u_C1R** ppState, IppiSize dstRoi,
|
|
Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpInitAlloc_16u_C1R,(IppiPyramidUpState_16u_C1R** ppState, IppiSize dstRoi,
|
|
Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpInitAlloc_32f_C1R,(IppiPyramidUpState_32f_C1R** ppState, IppiSize dstRoi,
|
|
Ipp32f rate, Ipp32f* pKernel, int kerSize, int mode))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpInitAlloc_8u_C3R, (IppiPyramidUpState_8u_C3R** ppState, IppiSize dstRoi,
|
|
Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpInitAlloc_16u_C3R,(IppiPyramidUpState_16u_C3R** ppState, IppiSize dstRoi,
|
|
Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpInitAlloc_32f_C3R,(IppiPyramidUpState_32f_C3R** ppState, IppiSize dstRoi,
|
|
Ipp32f rate, Ipp32f* pKernel, int kerSize, int mode))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiPyramidLayerDownFree_8u_C1R, ippiPyramidLayerDownFree_8u_C3R
|
|
// ippiPyramidLayerDownFree_16u_C1R, ippiPyramidLayerDownFree_16u_C3R
|
|
// ippiPyramidLayerDownFree_32f_C1R, ippiPyramidLayerDownFree_32f_C3R
|
|
// ippiPyramidLayerUpFree_8u_C1R, ippiPyramidLayerUpFree_8u_C3R
|
|
// ippiPyramidLayerUpFree_16u_C1R, ippiPyramidLayerUpFree_16u_C3R
|
|
// ippiPyramidLayerUpFree_32f_C1R, ippiPyramidLayerUpFree_32f_C3R
|
|
//
|
|
// Purpose: Initializes structure for pyramid layer calculation
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
//
|
|
// Arguments:
|
|
// pState Pointer to initialized structure
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownFree_8u_C1R, (IppiPyramidDownState_8u_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownFree_16u_C1R,(IppiPyramidDownState_16u_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownFree_32f_C1R,(IppiPyramidDownState_32f_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownFree_8u_C3R, (IppiPyramidDownState_8u_C3R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownFree_16u_C3R,(IppiPyramidDownState_16u_C3R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDownFree_32f_C3R,(IppiPyramidDownState_32f_C3R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpFree_8u_C1R, (IppiPyramidUpState_8u_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpFree_16u_C1R,(IppiPyramidUpState_16u_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpFree_32f_C1R,(IppiPyramidUpState_32f_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpFree_8u_C3R, (IppiPyramidUpState_8u_C3R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpFree_16u_C3R,(IppiPyramidUpState_16u_C3R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUpFree_32f_C3R,(IppiPyramidUpState_32f_C3R* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiGetPyramidDownROI, ippiGetPyramidUpROI
|
|
//
|
|
// Purpose: Calculate possible size of destination ROI.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr Wrong src roi
|
|
// ippStsBadArgErr Wrong rate
|
|
//
|
|
// Arguments:
|
|
// srcRoi Source image ROI size.
|
|
// pDstRoi Pointer to destination image ROI size (down).
|
|
// pDstRoiMin Pointer to minimal destination image ROI size (up).
|
|
// pDstRoiMax Pointer to maximal destination image ROI size (up).
|
|
// rate Neighbour levels ratio (1<rate<=10)
|
|
//
|
|
// Notes: For up case destination size belongs to interval
|
|
// max((int)((float)((src-1)*rate)),src+1)<=dst<=
|
|
// max((int)((float)(src)*rate)),src+1)
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiGetPyramidDownROI,(IppiSize srcRoi, IppiSize *pDstRoi, Ipp32f rate))
|
|
IPPAPI(IppStatus, ippiGetPyramidUpROI,(IppiSize srcRoi, IppiSize *pDstRoiMin, IppiSize *pDstRoiMax, Ipp32f rate))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiPyramidLayerDown_8u_C1R, ippiPyramidLayerDown_16u_C1R, ippiPyramidLayerDown_32f_C1R
|
|
// ippiPyramidLayerDown_8u_C3R, ippiPyramidLayerDown_16u_C3R, ippiPyramidLayerDown_32f_C3R
|
|
// ippiPyramidLayerUp_8u_C1R, ippiPyramidLayerUp_16u_C1R, ippiPyramidLayerUp_32f_C1R
|
|
// ippiPyramidLayerUp_8u_C3R, ippiPyramidLayerUp_16u_C3R, ippiPyramidLayerUp_32f_C3R
|
|
//
|
|
// Purpose: Perform downsampling/upsampling of the image with 5x5 gaussian.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of the specified pointers is NULL
|
|
// ippStsSizeErr The srcRoiSize or dstRoiSize has a fild with zero or negativ value
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsBadArgErr pState->rate has wrong value
|
|
// ippStsNotEvenStepErr One of the step values is not divisibly by 4 for floating-point
|
|
// images, or by 2 for short-integer images.
|
|
// Arguments:
|
|
// pSrc Pointer to the source image
|
|
// srcStep Step in byte through the source image
|
|
// srcRoiSize Size of the source image ROI in pixel.
|
|
// dstRoiSize Size of the destination image ROI in pixel.
|
|
// pDst Pointer to destination image
|
|
// dstStep Step in byte through the destination image
|
|
// pState Pointer to the pyramid layer structure
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiPyramidLayerDown_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_8u_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDown_8u_C3R, (const Ipp8u* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_8u_C3R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDown_16u_C1R,(const Ipp16u* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_16u_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDown_16u_C3R,(const Ipp16u* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_16u_C3R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDown_32f_C1R,(const Ipp32f* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_32f_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerDown_32f_C3R,(const Ipp32f* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_32f_C3R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiPyramidLayerUp_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_8u_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUp_8u_C3R, (const Ipp8u* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_8u_C3R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUp_16u_C1R,(const Ipp16u* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_16u_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUp_16u_C3R,(const Ipp16u* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_16u_C3R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUp_32f_C1R,(const Ipp32f* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_32f_C1R* pState))
|
|
IPPAPI(IppStatus, ippiPyramidLayerUp_32f_C3R,(const Ipp32f* pSrc, int srcStep, IppiSize srcRoiSize,
|
|
Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_32f_C3R* pState))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Haar Classifier *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiHaarClassifierInitAlloc_32f, ippiTiltedHaarClassifierInitAlloc_32f
|
|
// ippiHaarClassifierInitAlloc_32s, ippiTiltedHaarClassifierInitAlloc_32s
|
|
//
|
|
// Purpose: Allocates and initializes memory for the stage of the Haar classifier
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The number of classifiers or features is less or equal zero
|
|
// ippStsbadArgErr The bad feature rectangular
|
|
// ippStsMemAllocErr Memory allocation error
|
|
//
|
|
// Arguments:
|
|
// pState The pointer to the pointer to the Haar classifier structure.
|
|
// pFeature The pointer to the array of features.
|
|
// pWeight The pointer to the array of feature weights.
|
|
// pThreshold The pointer to the array of classifier thresholds [length].
|
|
// pVal1, pVal2 Pointers to arrays of classifier results [length].
|
|
// pNum The pointer to the array of classifier lengths [length].
|
|
// length The number of classifiers in the stage.
|
|
//
|
|
// Notes: For integer version feature weights pWeight are in Q0, classifier thresholds
|
|
// pThreshold are in QT (see ApplyHaarClassifier), pVal1 and pVal2 are scale as
|
|
// stage thresholds threshold of ApplyHaarClassifier function
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiHaarClassifierInitAlloc_32f, (IppiHaarClassifier_32f **pState,
|
|
const IppiRect* pFeature, const Ipp32f* pWeight, const Ipp32f* pThreshold,
|
|
const Ipp32f* pVal1, const Ipp32f* pVal2, const int* pNum, int length))
|
|
|
|
IPPAPI(IppStatus, ippiTiltedHaarClassifierInitAlloc_32f, (IppiHaarClassifier_32f **pState,
|
|
const IppiRect* pFeature, const Ipp32f* pWeight, const Ipp32f* pThreshold,
|
|
const Ipp32f* pVal1, const Ipp32f* pVal2, const int* pNum, int length))
|
|
|
|
IPPAPI(IppStatus, ippiHaarClassifierInitAlloc_32s, (IppiHaarClassifier_32s **pState,
|
|
const IppiRect* pFeature, const Ipp32s* pWeight, const Ipp32s* pThreshold,
|
|
const Ipp32s* pVal1, const Ipp32s* pVal2, const int* pNum, int length))
|
|
|
|
IPPAPI(IppStatus, ippiTiltedHaarClassifierInitAlloc_32s, (IppiHaarClassifier_32s **pState,
|
|
const IppiRect* pFeature, const Ipp32s* pWeight, const Ipp32s* pThreshold,
|
|
const Ipp32s* pVal1, const Ipp32s* pVal2, const int* pNum, int length))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiHaarClassifierFree_32f, ippiHaarClassifierFree_32s
|
|
//
|
|
// Purpose: Free structure for Haar classifier
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
//
|
|
// Arguments:
|
|
// pState Pointer to the structure to be freed
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiHaarClassifierFree_32f,(IppiHaarClassifier_32f *pState))
|
|
|
|
IPPAPI(IppStatus, ippiHaarClassifierFree_32s,(IppiHaarClassifier_32s *pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiTiltHaarFeatures_32f, ippiTiltHaarFeatures_32s
|
|
//
|
|
// Purpose: Tilts marked feature on -45 degree
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
//
|
|
// Arguments:
|
|
// pMask The mask of feature to tilt.
|
|
// flag 1 - left bottom -45 degree
|
|
// 0 - left top +45 degree
|
|
// pState The pointer to the Haar classifier structure.
|
|
//
|
|
// Notes: The mask length is equal to the number of classifiers in the classifier
|
|
// If pMask[i] != 0 i-th feature is tilted
|
|
// Classifiers with tilted features require two input integral images and
|
|
// can be used by rippiApplyMixedHaarClassifier functions
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiTiltHaarFeatures_32f, (const Ipp8u *pMask, int flag, IppiHaarClassifier_32f *pState))
|
|
|
|
IPPAPI(IppStatus, ippiTiltHaarFeatures_32s, (const Ipp8u *pMask, int flag, IppiHaarClassifier_32s *pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiGetHaarClassifierSize_32f, ippiGetHaarClassifierSize_32s
|
|
//
|
|
// Purpose: Returns the size of the Haar classifier.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
//
|
|
// Arguments:
|
|
// pState Pointer to the Haar classifier structure.
|
|
// pSize Pointer to the returned value of Haar classifier size.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiGetHaarClassifierSize_32f, (IppiHaarClassifier_32f* pState, IppiSize* pSize))
|
|
|
|
IPPAPI(IppStatus, ippiGetHaarClassifierSize_32s, (IppiHaarClassifier_32s* pState, IppiSize* pSize))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiApplyHaarClassifier_32f_C1R, ippiApplyMixedHaarClassifier_32f_C1R,
|
|
// ippiApplyHaarClassifier_32s32f_C1R, ippiApplyMixedHaarClassifier_32s32f_C1R,
|
|
// ippiApplyHaarClassifier_32s_C1RSfs, ippiApplyMixedHaarClassifier_32s_C1RSfs
|
|
//
|
|
// Purpose: Applies the stage of Haar classifiers to the image
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The number of classifiers or features is less or equal zero
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
//
|
|
// Arguments:
|
|
// pSrc The pointer to the source image of integrals.
|
|
// srcStep The step in bytes through the source image.
|
|
// pNorm The pointer to the source image of norm factors.
|
|
// normStep The step in bytes through the image of norm factors.
|
|
// pMask The pointer to the source and destination image of classification decisions.
|
|
// maskStep The step in bytes through the image of classification decisions.
|
|
// pPositive The pointer to the number of positive decisions.
|
|
// roiSize The size of source and destination images ROI in pixels.
|
|
// threshold The stage threshold value.
|
|
// pState The pointer to the Haar classifier structure.
|
|
// scaleFactor Scale factor for classifier threshold*norm, <= 0
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiApplyHaarClassifier_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
const Ipp32f* pNorm, int normStep, Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int *pPositive, Ipp32f threshold,
|
|
IppiHaarClassifier_32f *pState))
|
|
|
|
IPPAPI(IppStatus, ippiApplyHaarClassifier_32s32f_C1R, (const Ipp32s* pSrc, int srcStep,
|
|
const Ipp32f* pNorm, int normStep, Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int *pPositive, Ipp32f threshold,
|
|
IppiHaarClassifier_32f *pState))
|
|
|
|
IPPAPI(IppStatus, ippiApplyHaarClassifier_32s_C1RSfs, (const Ipp32s* pSrc, int srcStep,
|
|
const Ipp32s* pNorm, int normStep, Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, int *pPositive, Ipp32s threshold,
|
|
IppiHaarClassifier_32s *pState, int scaleFactor))
|
|
|
|
IPPAPI(IppStatus, ippiApplyMixedHaarClassifier_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
const Ipp32f* pTilt, int tiltStep, const Ipp32f* pNorm, int normStep,
|
|
Ipp8u* pMask, int maskStep, IppiSize roiSize, int *pPositive, Ipp32f threshold,
|
|
IppiHaarClassifier_32f *pState))
|
|
|
|
IPPAPI(IppStatus, ippiApplyMixedHaarClassifier_32s32f_C1R, (const Ipp32s* pSrc, int srcStep,
|
|
const Ipp32s* pTilt, int tiltStep, const Ipp32f* pNorm, int normStep,
|
|
Ipp8u* pMask, int maskStep, IppiSize roiSize, int *pPositive, Ipp32f threshold,
|
|
IppiHaarClassifier_32f *pState))
|
|
|
|
IPPAPI(IppStatus, ippiApplyMixedHaarClassifier_32s_C1RSfs, (const Ipp32s* pSrc, int srcStep,
|
|
const Ipp32s* pTilt, int tiltStep, const Ipp32s* pNorm, int normStep,
|
|
Ipp8u* pMask, int maskStep, IppiSize roiSize, int *pPositive, Ipp32s threshold,
|
|
IppiHaarClassifier_32s *pState, int scaleFactor))
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Correction of Camera Distortions *
|
|
\****************************************************************************************/
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiUndistortGetSize
|
|
//
|
|
// Purpose: calculate the buffer size for Undistort functions
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
//
|
|
// Parameters:
|
|
// roiSize Maximal image size
|
|
// pBufsize Pointer to work buffer size
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiUndistortGetSize, (IppiSize roiSize, int *pBufsize))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiCreateMapCameraUndistort_32f_C1R
|
|
//
|
|
// Purpose: initialize x and y maps for undistortion by ippiRemap function
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr pxMap or pyMap is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsBadArgErr Bad fx or fy
|
|
//
|
|
// Parameters:
|
|
// pxMap Pointer to x map (result, free by ippiFree)
|
|
// xStep Pointer to x map row step (result)
|
|
// pyMap Pointer to x map (result, free by ippiFree)
|
|
// yStep Pointer to x map row step (result)
|
|
// roiSize Maximal image size
|
|
// fx, fy Focal lengths
|
|
// cx, cy Coordinates of principal point
|
|
// k1, k2 Coeffs of radial distortion
|
|
// p1, p2 Coeffs of tangential distortion
|
|
// pBuffer Pointer to work buffer
|
|
//
|
|
// Notes:
|
|
// fx, fy != 0
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiCreateMapCameraUndistort_32f_C1R, (Ipp32f *pxMap, int xStep,
|
|
Ipp32f *pyMap, int yStep, IppiSize roiSize, Ipp32f fx, Ipp32f fy, Ipp32f cx, Ipp32f cy,
|
|
Ipp32f k1, Ipp32f k2, Ipp32f p1, Ipp32f p2, Ipp8u *pBuffer))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiUndistortRadial_8u_C1R, ippiUndistortRadial_8u_C3R,
|
|
// ippiUndistortRadial_16u_C1R, ippiUndistortRadial_16u_C3R
|
|
// ippiUndistortRadial_32f_C1R, ippiUndistortRadial_32f_C3R
|
|
//
|
|
// Purpose: correct camera distortion
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr pSrc or pDst is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element.
|
|
// ippStsBadArgErr Bad fx or fy
|
|
//
|
|
// Parameters:
|
|
// pSrc Source image
|
|
// srcStep Step in source image
|
|
// pDst Pointer to destination image
|
|
// dstStep Step in destination image
|
|
// roiSize Source and destination image ROI size.
|
|
// fx, fy Focal lengths
|
|
// cx, cy Coordinates of principal point
|
|
// k1, k2 Coeffs of radial distortion
|
|
// pBuffer Pointer to work buffer
|
|
//
|
|
// Notes:
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiUndistortRadial_8u_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp32f fx, Ipp32f fy,
|
|
Ipp32f cx, Ipp32f cy, Ipp32f k1, Ipp32f k2, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiUndistortRadial_16u_C1R, (const Ipp16u* pSrc, int srcStep,
|
|
Ipp16u* pDst, int dstStep, IppiSize roiSize, Ipp32f fx, Ipp32f fy,
|
|
Ipp32f cx, Ipp32f cy, Ipp32f k1, Ipp32f k2, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiUndistortRadial_32f_C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f fx, Ipp32f fy,
|
|
Ipp32f cx, Ipp32f cy, Ipp32f k1, Ipp32f k2, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiUndistortRadial_8u_C3R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp32f fx, Ipp32f fy,
|
|
Ipp32f cx, Ipp32f cy, Ipp32f k1, Ipp32f k2, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiUndistortRadial_16u_C3R, (const Ipp16u* pSrc, int srcStep,
|
|
Ipp16u* pDst, int dstStep, IppiSize roiSize, Ipp32f fx, Ipp32f fy,
|
|
Ipp32f cx, Ipp32f cy, Ipp32f k1, Ipp32f k2, Ipp8u *pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiUndistortRadial_32f_C3R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f fx, Ipp32f fy,
|
|
Ipp32f cx, Ipp32f cy, Ipp32f k1, Ipp32f k2, Ipp8u *pBuffer))
|
|
|
|
|
|
/*F/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiGradientColorToGray_8u_C3C1R,
|
|
// ippiGradientColorToGray_16u_C3C1R,
|
|
// ippiGradientColorToGray_32f_C3C1R
|
|
//
|
|
// Purpose: Calculate gray gradient from 3-channel gradient image.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
//
|
|
// Parameters:
|
|
// pSrc The source image
|
|
// srcStep Its step
|
|
// pDst The destination image
|
|
// dstStep Its step
|
|
// roiSize ROI size
|
|
// norm The norm type
|
|
// rippiNormInf = max(|a|,|b|,|c|)
|
|
// rippiNormL1 = (|a|+|b|+|c|)/3
|
|
// rippiNormL2 = sqrt((a*a+b*b+c*c)/3)
|
|
//
|
|
// Note: For integer flavors, the result is scaled to the full range of the
|
|
// destination data type
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiGradientColorToGray_8u_C3C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pDst, int dstStep, IppiSize roiSize, IppiNorm norm))
|
|
|
|
IPPAPI(IppStatus, ippiGradientColorToGray_16u_C3C1R, (const Ipp16u* pSrc, int srcStep,
|
|
Ipp16u* pDst, int dstStep, IppiSize roiSize, IppiNorm norm))
|
|
|
|
IPPAPI(IppStatus, ippiGradientColorToGray_32f_C3C1R, (const Ipp32f* pSrc, int srcStep,
|
|
Ipp32f* pDst, int dstStep, IppiSize roiSize, IppiNorm norm))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiInpaintInitAlloc_8u_C1R, ippiInpaintInitAlloc_8u_C3R
|
|
//
|
|
// Purpose: allocates memory and initializes a structure for direct inpainting algorithm
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image are less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsNotEvenStepErr Step is not multiple of element
|
|
// ippStsBadArgErr Wrong radius or flags
|
|
//
|
|
// Parameters:
|
|
// ppState Pointer to pointer to inpainting structure
|
|
// pDist Distance image
|
|
// distStep Its step
|
|
// pMask Distance image
|
|
// maskStep Its step
|
|
// roiSize The image ROI size
|
|
// radius Neighborhood radius (dist<=radius pixels are processed)
|
|
// flags Inpainting flags
|
|
// IPP_INPAINT_TELEA Telea algorithm is used
|
|
// IPP_INPAINT_NS Navier-Stokes equation is used
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiInpaintInitAlloc_8u_C1R, (IppiInpaintState_8u_C1R** ppState, const Ipp32f* pDist,
|
|
int distStep, const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp32f radius, IppiInpaintFlag flags))
|
|
|
|
IPPAPI(IppStatus, ippiInpaintInitAlloc_8u_C3R, (IppiInpaintState_8u_C3R** ppState, const Ipp32f* pDist,
|
|
int distStep, const Ipp8u* pMask, int maskStep,
|
|
IppiSize roiSize, Ipp32f radius, IppiInpaintFlag flags))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiInpaintFree_8u_C1R, ippiInpaintFree_8u_C3R
|
|
//
|
|
// Purpose: Free structure for inpainting algorithm
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
//
|
|
// Arguments:
|
|
// pState Pointer to structure to free
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiInpaintFree_8u_C1R, (IppiInpaintState_8u_C1R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiInpaintFree_8u_C3R, (IppiInpaintState_8u_C3R* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiInpaint_8u_C1R, ippiInpaint_8u_C3R
|
|
//
|
|
// Purpose: restores damaged image area by direct inpainting
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image are less or equal zero or different from initalloc
|
|
// ippStsStepErr The steps in images are too small
|
|
//
|
|
// Parameters:
|
|
// pSrc Source image
|
|
// srcStep Its step
|
|
// pDst Destination image
|
|
// dstStep Its step
|
|
// roiSize The image ROI size
|
|
// pState Pointer to inpainting structure
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiInpaint_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiInpaintState_8u_C1R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiInpaint_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppiInpaintState_8u_C1R* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiSegmentGradientGetBufferSize_8u_C1R
|
|
// ippiSegmentGradientGetBufferSize_8u_C3R
|
|
//
|
|
// Purpose: Get size of external buffer.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image or kernel size are less or equal zero
|
|
//
|
|
// Parameters:
|
|
// roiSize The image ROI size
|
|
// pBufSize The pointer to the buffer size
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiSegmentGradientGetBufferSize_8u_C1R, (IppiSize roiSize, int* pBufSize))
|
|
|
|
IPPAPI(IppStatus, ippiSegmentGradientGetBufferSize_8u_C3R, (IppiSize roiSize, int* pBufSize))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiSegmentGradient_8u_C1R, ippiSegmentGradient_8u_C3R
|
|
//
|
|
// Purpose: Draw bounds between image segments
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image or kernel size are less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
//
|
|
// Parameters:
|
|
// pSrc Source image
|
|
// srcStep Its step
|
|
// pMarker Source and destination marker image
|
|
// markerStep Its step
|
|
// roiSize Image ROI size
|
|
// norm Type of norm to form the mask for maximum search:
|
|
// rippiNormInf Infinity norm (8-connectivity, 3x3 rectangular mask).
|
|
// rippiNormL1 L1 norm (4-connectivity, 3x3 cross mask).
|
|
// flag Flags
|
|
// IPP_SEGMENT_BORDER_4 Draw L1 segment borders.
|
|
// IPP_SEGMENT_BORDER_8 Draw Linf segment borders.
|
|
// pBuffer Pointer to working buffer
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiSegmentGradient_8u_C3IR, (const Ipp8u* pSrc, int srcStep, Ipp8u* pMarker,
|
|
int markerStep, IppiSize roiSize, IppiNorm norm, int flags, Ipp8u* pBuffer))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiSegmentGradient_8u_C1IR, (const Ipp8u* pSrc, int srcStep, Ipp8u* pMarker,
|
|
int markerStep, IppiSize roiSize, IppiNorm norm, int flags, Ipp8u* pBuffer))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiSegmentWatershedGetBufferSize_8u_C1R, ippiSegmentWatershedGetBufferSize_8u16u_C1R
|
|
//
|
|
// Purpose: Get size of external buffer.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image or kernel size are less or equal zero
|
|
//
|
|
// Parameters:
|
|
// roiSize The image ROI size
|
|
// pBufferSize The pointer to the buffer size
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiSegmentWatershedGetBufferSize_8u_C1R, (IppiSize roiSize, int *pBufSize))
|
|
|
|
IPPAPI(IppStatus, ippiSegmentWatershedGetBufferSize_8u16u_C1R, (IppiSize roiSize, int *pBufSize))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiSegmentWatershed_8u_C1IR, ippiSegmentWatershed_8u16u_C1IR
|
|
//
|
|
// Purpose: Draw bounds between image segments
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image or kernel size are less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
//
|
|
// Parameters:
|
|
// pSrc Source image
|
|
// srcStep Its step
|
|
// pMarker Source and destination marker image
|
|
// markerStep Its step
|
|
// roiSize Image ROI size
|
|
// norm Type of norm to form the mask for maximum search:
|
|
// rippiNormInf Infinity norm (8-connectivity, 3x3 rectangular mask).
|
|
// rippiNormL1 L1 norm (4-connectivity, 3x3 cross mask).
|
|
// rippiNormL2 approximation of L2 norm (8-connectivity, 3x3 mask 11,15).
|
|
// rippiNormFM Fast marching distance (4-connectivity).
|
|
// flag Flags
|
|
// IPP_SEGMENT_QUEUE Via priority queue.
|
|
// IPP_SEGMENT_DISTANCE Via distance transform.
|
|
// IPP_SEGMENT_BORDER_4 Draw L1 segment borders.
|
|
// IPP_SEGMENT_BORDER_8 Draw Linf segment borders.
|
|
// pBuffer Pointer to working buffer
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiSegmentWatershed_8u_C1IR, (const Ipp8u* pSrc, int srcStep, Ipp8u* pMarker, int markerStep, IppiSize roiSize,
|
|
IppiNorm norm, int flag, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiSegmentWatershed_8u16u_C1IR, (const Ipp8u* pSrc, int srcStep, Ipp16u* pMarker, int markerStep, IppiSize roiSize,
|
|
IppiNorm norm, int flag, Ipp8u* pBuffer))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiBoundSegments_8u_C1IR, ippiBoundSegments_16u_C1IR
|
|
//
|
|
// Purpose: Draw bounds between image segments
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image or kernel size are less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
//
|
|
// Parameters:
|
|
// pMarker Source and destination marker image
|
|
// markerStep Its step
|
|
// roiSize Image ROI size
|
|
// norm Type of norm to form the mask for maximum search:
|
|
// ippiNormInf Infinity norm (8-connectivity, 3x3 rectangular mask).
|
|
// ippiNormL1 L1 norm (4-connectivity, 3x3 cross mask).
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiBoundSegments_8u_C1IR, (Ipp8u* pMarker, int markerStep, IppiSize roiSize,
|
|
Ipp8u val, IppiNorm norm))
|
|
|
|
IPPAPI(IppStatus, ippiBoundSegments_16u_C1IR, (Ipp16u* pMarker, int markerStep, IppiSize roiSize,
|
|
Ipp16u val, IppiNorm norm))
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiLabelMarkersGetBufferSize_8u_C1R, ippiLabelMarkersGetBufferSize_16u_C1R
|
|
//
|
|
// Purpose: The functions calculate size of temporary buffer, required to run
|
|
// marker labeling function
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width or height of images is less or equal zero
|
|
//
|
|
// Parameters:
|
|
// roiSize ROI size
|
|
// pBufSize Temporary buffer size
|
|
//F*/
|
|
|
|
IPPAPI(IppStatus, ippiLabelMarkersGetBufferSize_8u_C1R, (IppiSize roiSize, int* pBufSize))
|
|
|
|
IPPAPI(IppStatus, ippiLabelMarkersGetBufferSize_16u_C1R, (IppiSize roiSize, int* pBufSize))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiLabelMarkers_8u_C1IR, ippiLabelMarkers_16u_C1IR
|
|
//
|
|
// Purpose: Labels connected non-zero components with different label values
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image or kernel size are less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
//
|
|
// Parameters:
|
|
// pMarker Source and destination marker image
|
|
// markerStep Its step
|
|
// roiSize Image ROI size
|
|
// minLabel Minimal label value > 0
|
|
// maxLabel Maximal label value < 255
|
|
// norm Type of norm to form the mask for maximum search:
|
|
// ippiNormL1 L1 norm (4-connectivity, 3x3 cross mask).
|
|
// ippiNormInf Infinity norm (8-connectivity, 3x3 rectangular mask).
|
|
// pNumber Pointer to number of markers
|
|
// pBuffer Pointer to working buffer
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiLabelMarkers_8u_C1IR, (Ipp8u* pMarker, int markerStep, IppiSize roiSize,
|
|
int minLabel, int maxLabel, IppiNorm norm, int *pNumber, Ipp8u* pBuffer))
|
|
|
|
IPPAPI(IppStatus, ippiLabelMarkers_16u_C1IR, (Ipp16u* pMarker, int markerStep, IppiSize roiSize,
|
|
int minLabel, int maxLabel, IppiNorm norm, int *pNumber, Ipp8u* pBuffer))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippibFastArctan
|
|
//
|
|
// Purpose: Given "X" and "Y" images, calculates "angle" image
|
|
// (i.e. atan(y/x)). Resultant angles are in degrees.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The length is less or equal zero
|
|
//
|
|
// Arguments:
|
|
// pSrcY Pointer to source "Y" image
|
|
// pSrcX Pointer to source "X" image
|
|
// pDst Pointer to "angle" image
|
|
// length Vector length
|
|
//
|
|
// Note:
|
|
// For current version angle precision is ~0.1 degree
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippibFastArctan_32f, ( const Ipp32f* pSrcY, const Ipp32f* pSrcX,
|
|
Ipp32f* pDst, int length ))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiForegroundHistogramInitAlloc
|
|
//
|
|
// Purpose: Allocates and initializes a state structure for
|
|
// foreground/background segmentation using histograms
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
// ippStsBadArgErr Wrong value of pModel field
|
|
//
|
|
// Arguments:
|
|
// pSrc Source image
|
|
// srcStep Step in source image
|
|
// roiSize Source image ROI size.
|
|
// pModel Pointer to the structure of the histogram statistical model.
|
|
// pState Pointer to the pointer to the segmentation state structure.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiForegroundHistogramInitAlloc_8u_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
IppiSize roiSize, IppFGHistogramModel* pModel, IppFGHistogramState_8u_C1R** pState))
|
|
|
|
IPPAPI(IppStatus, ippiForegroundHistogramInitAlloc_8u_C3R, ( const Ipp8u* pSrc, int srcStep,
|
|
IppiSize roiSize, IppFGHistogramModel* pModel, IppFGHistogramState_8u_C3R** pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiForegroundHistogramFree
|
|
//
|
|
// Purpose: Frees memory allocated for the foreground/background segmentation structure
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
//
|
|
// Arguments:
|
|
// pState Pointer to the structure to be freed
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiForegroundHistogramFree_8u_C1R, (IppFGHistogramState_8u_C1R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiForegroundHistogramFree_8u_C3R, (IppFGHistogramState_8u_C3R* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiForegroundHistogram
|
|
//
|
|
// Purpose: Calculates foreground mask using histograms
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
//
|
|
// Arguments:
|
|
// pSrc Source image
|
|
// srcStep Step in source image
|
|
// pMask Pointer to mask
|
|
// maskStep Step in the mask image
|
|
// roiSize Source image ROI size.
|
|
// pState Pointer to the pointer to the segmentation state structure.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiForegroundHistogram_8u_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pMask, int maskStep, IppiSize roiSize, IppFGHistogramState_8u_C1R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiForegroundHistogram_8u_C3R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pMask, int maskStep, IppiSize roiSize, IppFGHistogramState_8u_C3R* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiForegroundHistogramUpdate
|
|
//
|
|
// Purpose: Updates histogram statistical model for foreground segmentation
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
//
|
|
// Arguments:
|
|
// pSrc Source image
|
|
// srcStep Step in source image
|
|
// pMask Pointer to mask
|
|
// maskStep Step in the mask image
|
|
// pRef Pointer to reference image
|
|
// refStep Step in the reference image
|
|
// roiSize Source image ROI size.
|
|
// pState Pointer to the pointer to the segmentation state structure.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiForegroundHistogramUpdate_8u_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pMask, int maskStep, Ipp8u* pRef, int refStep, IppiSize roiSize,
|
|
IppFGHistogramState_8u_C1R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiForegroundHistogramUpdate_8u_C3R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pMask, int maskStep, Ipp8u* pRef, int refStep, IppiSize roiSize,
|
|
IppFGHistogramState_8u_C3R* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiForegroundGaussianInitAlloc
|
|
//
|
|
// Purpose: Allocates and initializes a state structure for
|
|
// foreground/background segmentation using Gaussian mixtures
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
//
|
|
// Arguments:
|
|
// pSrc Source image
|
|
// srcStep Step in source image
|
|
// roiSize Source image ROI size.
|
|
// pModel Pointer to the structure of the gaussian model.
|
|
// pState Pointer to the pointer to the segmentation state structure.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiForegroundGaussianInitAlloc_8u_C1R, ( const Ipp8u* pSrc, int srcStep,
|
|
IppiSize roiSize, IppFGGaussianModel* pModel, IppFGGaussianState_8u_C1R** pState))
|
|
|
|
IPPAPI(IppStatus, ippiForegroundGaussianInitAlloc_8u_C3R, ( const Ipp8u* pSrc, int srcStep,
|
|
IppiSize roiSize, IppFGGaussianModel* pModel, IppFGGaussianState_8u_C3R** pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiForegroundGaussianFree
|
|
//
|
|
// Purpose: Frees memory allocated for the foreground/background segmentation structure
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
//
|
|
// Arguments:
|
|
// pState Pointer to the structure to be freed
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiForegroundGaussianFree_8u_C1R, (IppFGGaussianState_8u_C1R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiForegroundGaussianFree_8u_C3R, (IppFGGaussianState_8u_C3R* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiForegroundGaussian
|
|
//
|
|
// Purpose: Calculates foreground mask using Gaussians
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr One of pointers is NULL
|
|
// ippStsSizeErr The width of the image is less or equal zero
|
|
// ippStsStepErr The steps in images are too small
|
|
//
|
|
// Arguments:
|
|
// pSrc Source image
|
|
// srcStep Step in source image
|
|
// pRef Pointer to reference image
|
|
// refStep Step in the reference image
|
|
// pDst Pointer to destination image
|
|
// dstStep Step in the destination image
|
|
// roiSize Source image ROI size.
|
|
// pState Pointer to the pointer to the segmentation state structure.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiForegroundGaussian_8u_C1R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pRef, int refStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppFGGaussianState_8u_C1R* pState))
|
|
|
|
IPPAPI(IppStatus, ippiForegroundGaussian_8u_C3R, (const Ipp8u* pSrc, int srcStep,
|
|
Ipp8u* pRef, int refStep, Ipp8u* pDst, int dstStep,
|
|
IppiSize roiSize, IppFGGaussianState_8u_C3R* pState))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFilterGaussGetBufferSize
|
|
//
|
|
// Purpose: Computes the size of the working buffer for the Gaussian filter
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok. Any other value indicates an error or a warning.
|
|
// ippStsNullPtrErr One of the pointers is NULL.
|
|
// ippStsSizeErr roiSize has a field with zero or negative value .
|
|
// ippStsBadArgErr KernelSize is odd or is less than 3.
|
|
//
|
|
// Arguments:
|
|
// roiSize Maximal size of the image ROI in pixels.
|
|
// kernelSize Size of the Gaussian kernel (odd, greater or equal to 3).
|
|
// pBufferSize Pointer to the computed size of the buffer:
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiFilterGaussGetBufferSize_32f_C1R,(IppiSize roiSize, int KernelSize,
|
|
int* pBufferSize))
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFilterGaussBorder
|
|
//
|
|
// Purpose: Applies Gaussian filter with borders
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok. Any other value indicates an error or a warning.
|
|
// ippStsNullPtrErr One of the specified pointers is NULL.
|
|
// ippStsSizeErr roiSize has a field with zero or negative value.
|
|
// ippStsStepErr srcStep is less than roiSize.width * <pixelSize>,
|
|
// or dstStep is less than roiSize.width * <pixelSize>.
|
|
// ippStsNotEvenStepErr One of the step values is not divisible by 4 for floating-point images.
|
|
// ippStsBadArgErr kernelSize is less than 3 or sigma is less or equal than 0.
|
|
//
|
|
// Arguments:
|
|
// pSrc Pointer to the source image ROI.
|
|
// srcStep Distance in bytes between starts of consecutive lines in the source image.
|
|
// pDst Pointer to the destination image ROI.
|
|
// dstStep Distance in bytes between starts of consecutive lines in the destination image.
|
|
// roiSize Size of the source and destination image ROI.
|
|
// kernelSize Size of the Gaussian kernel (odd, greater or equal to 3).
|
|
// sigma Standard deviation of the Gaussian kernel.
|
|
// pBuffer Pointer to the working buffer.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiFilterGaussBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,Ipp32f* pDst, int dstStep,
|
|
IppiSize roiSize,int KernelSize,Ipp32f sigma,
|
|
IppiBorderType borderType, Ipp32f borderValue,
|
|
Ipp8u* pBuffer))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFindPeaks3x3GetBufferSize
|
|
//
|
|
// Purpose: Computes the size of the working buffer for the peak search
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok. Any other value indicates an error or a warning.
|
|
// ippStsNullPtrErr Indicates an error condition if the pointer pBufferSize is NULL.
|
|
// ippStsSizeErr Indicates an error condition if maskSize has a field with zero
|
|
// or negative value, or if roiWidth is less than 1.
|
|
//
|
|
// Arguments:
|
|
// roiWidth Maximal image width (in pixels).
|
|
// pBufferSize Pointer to the computed size of the buffer.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiFindPeaks3x3GetBufferSize_32f_C1R,(int roiWidth, int* pBufferSize))
|
|
|
|
IPPAPI(IppStatus, ippiFindPeaks3x3GetBufferSize_32s_C1R,(int roiWidth, int* pBufferSize))
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiFindPeaks3x3
|
|
//
|
|
// Purpose: Finds coordinates of peaks (maximums or minimums) with absolute value
|
|
// exceeding threshold value
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok. Any other value indicates an error or a warning.
|
|
// ippStsNullPtrErr One of the specified pointers is NULL.
|
|
// ippStsSizeErr Indicates an error condition if roiSize has a field
|
|
// with zero or negative value or if maxPeakCount is less
|
|
// than or equal to zero, or if Border is less than 1 or
|
|
// greater than 0.5* roiSize.width or. greater than 0.5* roiSize.hight
|
|
// ippStsStepErr Indicates an error condition if srcStep is less than roiSize.width * <pixelSize>
|
|
// ippStsNotEvenStepErr Indicates an error condition if one of the step values is
|
|
// not divisible by 4 for floating-point or 32-bit integer images.
|
|
// ippStsBadArgErr Indicates an error condition if norm value is wrong.
|
|
//
|
|
// Arguments:
|
|
// pSrc Pointer to the source image ROI.
|
|
// srcStep Distance in bytes between starts of consecutive lines in the source image.
|
|
// roiSize Size of the image ROI in pixels.
|
|
// threshold Threshold value.
|
|
// pPeak Pointer to the maximum coordinates [maxPeakCount].
|
|
// maxPeakCount Maximal number of peaks.
|
|
// pPeakCount Number of detected peaks.
|
|
// norm Type of norm to form the mask for maximum search:
|
|
// ippiNormInf Infinity norm (8-connectivity, 3x3 rectangular mask).
|
|
// ippiNormL1 L1 norm (4-connectivity, 3x3 cross mask).
|
|
// Border Border value, only pixel with distance from the edge of the image
|
|
// greater than Border are processed.
|
|
// pBuffer Pointer to the working buffer.
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiFindPeaks3x3_32f_C1R,(const Ipp32f* pSrc, int srcStep, IppiSize roiSize,
|
|
Ipp32f threshold, IppiPoint* pPeak, int maxPeakCount,
|
|
int* pPeakCount, IppiNorm norm, int Border, Ipp8u* pBuffer))
|
|
|
|
|
|
IPPAPI(IppStatus, ippiFindPeaks3x3_32s_C1R,(const Ipp32s* pSrc, int srcStep, IppiSize roiSize,
|
|
Ipp32s threshold, IppiPoint* pPeak, int maxPeakCount,
|
|
int* pPeakCount, IppiNorm norm, int Border, Ipp8u* pBuffer))
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiHoughLineGetSize_8u_C1R()
|
|
//
|
|
//
|
|
// Purpose: Calculate the size of temporary buffer for ippiHoughLine_8u32f_C1R function.
|
|
//
|
|
// Arguments:
|
|
// roiSize The size of source ROI.
|
|
// delta Discretization step, delta.rho - distance resolution in pixels, delta.theta - angle resolution in radians
|
|
// maxLineCount The size of detected line buffer
|
|
// pBufSize Pointer to the computed size of the temporary buffer
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr pBufSize is NULL
|
|
// ippStsSizeErr The roiSize or delta has a field with zero or negative value
|
|
// ippStsOverflow The size of buffer too big. Overflow.
|
|
//
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiHoughLineGetSize_8u_C1R, (IppiSize roiSize, IppPointPolar delta, int maxLineCount, int* pBufSize))
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiHoughLine_8u32f_C1R()
|
|
//
|
|
//
|
|
// Purpose: Perform Hough transform algorithm
|
|
//
|
|
//
|
|
// Arguments:
|
|
// pSrc Pointer to the source image ROI
|
|
// srcStep Distance in bytes between starts of consecutive lines in the source image
|
|
// roiSize The size of source ROI.
|
|
// delta Discretization step, delta.rho - distance resolution in pixels, delta.theta - angle resolution in radians
|
|
// threshold Threshold for a line is detected (if accumulator value > threshold)
|
|
// pLine Pointer to output array of detected lines
|
|
// maxLineCount Size of output array pLine in elements
|
|
// pLineCount Number of detected lines. If founded more than maxLineCount lines than function returns "ippStsDstSizeLessExpected" status
|
|
// pBuffer Pointer to the pre-allocated temporary buffer
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr pSrc or pLine or pLineCount or pBuffer is NULL
|
|
// ippStsStepErr srcStep is not valid
|
|
// ippStsSizeErr roiSize has a field with zero or negative value or maxLineCount is zero or negative
|
|
// ippStsBadArgErr threshold or is less than or equal to zero or delta.rho less 0 or more ROI width+height or delta.theta less 0 or more PI
|
|
// ippStsDstSizeLessExpected Ok, but lines detected more than maxLineCount
|
|
//
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiHoughLine_8u32f_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize, IppPointPolar delta, int threshold,
|
|
IppPointPolar* pLine, int maxLineCount, int* pLineCount, Ipp8u* pBuffer))
|
|
|
|
/*
|
|
// Name: ippiHoughLine_Region_8u32f_C1R
|
|
//
|
|
//
|
|
// Purpose: Perform Hough transform algorithm in defined region
|
|
//
|
|
//
|
|
// Arguments:
|
|
// pSrc Pointer to the source image ROI
|
|
// srcStep Distance in bytes between starts of consecutive lines in the source image
|
|
// roiSize The size of source ROI.
|
|
// pLine Pointer to output array of detected lines
|
|
// dstRoi Bottom left and top right corners of searched lines. All founded lines must be
|
|
// in this area. (line[n].rho>=dstRoi[0].rho && line[n].theta>=dstRoi[0].theta &&
|
|
// line[n].rho<=dstRoi[1].rho && line[n].theta<=dstRoi[1].theta)
|
|
// maxLineCount Size of output array pLine in elements
|
|
// pLineCount Number of detected lines. If founded more than maxLineCount lines than function returns "ippStsDstSizeLessExpected" status
|
|
// delta Discretization step, delta.rho - distance resolution in pixels, delta.theta - angle resolution in radians
|
|
// threshold Threshold for a line is detected (if accumulator value > threshold)
|
|
// pBuffer Pointer to the pre-allocated temporary buffer
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr pSrc or pLine or pLineCount or pBuffer is NULL
|
|
// ippStsStepErr srcStep is not valid
|
|
// ippStsSizeErr roiSize has a field with zero or negative value or maxLineCount is zero or negative
|
|
// ippStsBadArgErr threshold or is less than or equal to zero or delta.rho less 0 or more ROI width+height or
|
|
// delta.theta less 0 or more PI or dstRoi[0].rho more dstRoi[1].rho or dstRoi[0].theta more dstRoi[1].theta
|
|
// ippStsDstSizeLessExpected Ok, but lines detected more than maxLineCount
|
|
//
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiHoughLine_Region_8u32f_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize,
|
|
IppPointPolar* pLine, IppPointPolar dstRoi[2], int maxLineCount, int* pLineCount, IppPointPolar delta, int threshold, Ipp8u* pBuffer))
|
|
|
|
|
|
#if !defined( _OWN_BLDPCS )
|
|
typedef struct _IppiSRHNSpec_PSF3x3 IppiSRHNSpec_PSF3x3;
|
|
typedef struct _IppiSRHNSpec_PSF2x2 IppiSRHNSpec_PSF2x2;
|
|
#endif
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiSRHNInitAlloc_PSF3x3,
|
|
// ippiSRHNInitAlloc_PSF2x2
|
|
//
|
|
// Purpose: Allocate and initialize the internal PSF structures.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr Some of the pointers are NULL
|
|
// ippStsSizeErr The table size is incorrect
|
|
// Arguments:
|
|
// ppPSF Double pointer to the created PSF structure
|
|
// pcTab Input table with coefficients
|
|
// tabSize The number of elements in cTab
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiSRHNInitAlloc_PSF3x3, (IppiSRHNSpec_PSF3x3** ppPSF,
|
|
const Ipp32f pcTab[][9], int tabSize))
|
|
|
|
IPPAPI(IppStatus, ippiSRHNInitAlloc_PSF2x2, (IppiSRHNSpec_PSF2x2** ppPSF,
|
|
const Ipp32f pcTab[][4], int tabSize))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiSRHNFree_PSF3x3,
|
|
// ippiSRHNFree_PSF2x2
|
|
//
|
|
// Purpose: Deallocate PSF structures
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr The PSF pointer is NULL
|
|
// Arguments:
|
|
// pPSF Pointer to the PSF structure
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiSRHNFree_PSF3x3, (IppiSRHNSpec_PSF3x3* pPSF))
|
|
IPPAPI(IppStatus, ippiSRHNFree_PSF2x2, (IppiSRHNSpec_PSF2x2* pPSF))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiSRHNCalcResidual_PSF3x3_8u32f_C1R,
|
|
// ippiSRHNCalcResidual_PSF2x2_8u32f_C1R,
|
|
// ippiSRHNCalcResidual_PSF3x3_16u32f_C1R,
|
|
// ippiSRHNCalcResidual_PSF2x2_16u32f_C1R,
|
|
//
|
|
// Purpose: Compute residuals for likelihood part of target function
|
|
// or its gradient.
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr Some of the pointers are NULL's
|
|
// ippStsSizeErr The length is negative
|
|
// ippStsStepErr hiResStep is too small or
|
|
// is not divisible by sizeof(pHiRes[0])
|
|
//
|
|
// Arguments:
|
|
// pHiRes Pointer to high-resolution image
|
|
// pHiResStep High-resolution image step
|
|
// pLowRes Array of pixel values from low-resolution images
|
|
// pOfs Array of offsets of 3x3 areas
|
|
// inside high-resolution image
|
|
// pCoeff Array of indices in cTab
|
|
// pResidual The output array
|
|
// len Length of lowRes, ofs, coeff and residual arrays
|
|
// pPSF Previously created PSF table for 3x3 or 2x2 case
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiSRHNCalcResidual_PSF3x3_8u32f_C1R, (
|
|
const Ipp32f* pHiRes, int hiResStep, const Ipp8u* pLowRes,
|
|
const Ipp32s* pOfs, const Ipp16u* pCoeff, Ipp32f* pResidual,
|
|
int len, const IppiSRHNSpec_PSF3x3* pPSF))
|
|
|
|
IPPAPI(IppStatus, ippiSRHNCalcResidual_PSF2x2_8u32f_C1R, (
|
|
const Ipp32f* pHiRes, int hiResStep, const Ipp8u* pLowRes,
|
|
const Ipp32s* pOfs, const Ipp16u* pCoeff, Ipp32f* pResidual,
|
|
int len, const IppiSRHNSpec_PSF2x2* pPSF))
|
|
|
|
IPPAPI(IppStatus, ippiSRHNCalcResidual_PSF3x3_16u32f_C1R, (
|
|
const Ipp32f* pHiRes, int hiResStep, const Ipp16u* pLowRes,
|
|
const Ipp32s* pOfs, const Ipp16u* pCoeff, Ipp32f* pResidual,
|
|
int len, const IppiSRHNSpec_PSF3x3* pPSF))
|
|
|
|
IPPAPI(IppStatus, ippiSRHNCalcResidual_PSF2x2_16u32f_C1R, (
|
|
const Ipp32f* pHiRes, int hiResStep, const Ipp16u* pLowRes,
|
|
const Ipp32s* pOfs, const Ipp16u* pCoeff, Ipp32f* pResidual,
|
|
int len, const IppiSRHNSpec_PSF2x2* pPSF))
|
|
|
|
|
|
/* ///////////////////////////////////////////////////////////////////////////
|
|
// Name: ippiSRHNUpdateGradient_PSF3x3_32f_C1R,
|
|
// ippiSRHNUpdateGradient_PSF2x2_32f_C1R
|
|
//
|
|
// Purpose: Update likelihood part of the gradient
|
|
//
|
|
// Return:
|
|
// ippStsNoErr Ok
|
|
// ippStsNullPtrErr Some of the pointers are NULL's
|
|
// ippStsSizeErr Length is negative
|
|
// ippStsStepErr gradStep is too small or is not divisible by
|
|
// sizeof(pGrad[0])
|
|
//
|
|
// Arguments:
|
|
// pGrad Pointer to gradient
|
|
// gradStep The gradient step
|
|
// pOfs Array of offsets of 3x3 or 2x2 areas
|
|
// inside high-resolution image
|
|
// pCoeff Array of indices in cTab
|
|
// pRob Array of computed robust function derivatives
|
|
// pWeight Array of indices in wTab
|
|
// len Length of ofs, coeff, errVal and weight arrays
|
|
// pwTab A table of confidence weights
|
|
// pPSF PSF structure
|
|
*/
|
|
|
|
IPPAPI(IppStatus, ippiSRHNUpdateGradient_PSF3x3_32f_C1R, (
|
|
Ipp32f* pGrad, int gradStep, const Ipp32s* pOfs, const Ipp16u* pCoeff,
|
|
const Ipp32f* pRob, const Ipp8u* pWeight, int len, const Ipp32f* pwTab,
|
|
const IppiSRHNSpec_PSF3x3* pPSF))
|
|
|
|
IPPAPI(IppStatus, ippiSRHNUpdateGradient_PSF2x2_32f_C1R, (
|
|
Ipp32f* pGrad, int gradStep, const Ipp32s* pOfs, const Ipp16u* pCoeff,
|
|
const Ipp32f* pRob, const Ipp8u* pWeight, int len, const Ipp32f* pwTab,
|
|
const IppiSRHNSpec_PSF2x2* pPSF))
|
|
|
|
|
|
#if defined __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#if defined (_IPP_STDCALL_CDECL)
|
|
#undef _IPP_STDCALL_CDECL
|
|
#define __stdcall __cdecl
|
|
#endif
|
|
|
|
#endif /* __IPPCV_H__ */
|
|
/* ////////////////////////// End of file "ippCV.h" ////////////////////////// */
|