amy/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-12 01:21:00 -05:00
Code Issues 1 Projects Releases Packages Wiki Activity Actions
winamp/Src/external_dependencies/intel_ipp_6.1.1.035/ia32/include/ippcv.h
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

5106 lines
269 KiB
C
Raw Blame History

/* ///////////////////////////////////////////////////////////////////////////////////////
//
// 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" ////////////////////////// */
Reference in a new issue View git blame Copy permalink