1/*
2// Copyright 2014 Intel Corporation All Rights Reserved.
3//
4//
5// This software and the related documents are Intel copyrighted materials, and your use of them is governed by
6// the express license under which they were provided to you ('License'). Unless the License provides otherwise,
7// you may not use, modify, copy, publish, distribute, disclose or transmit this software or the related
8// documents without Intel's prior written permission.
9// This software and the related documents are provided as is, with no express or implied warranties, other than
10// those that are expressly stated in the License.
11//
12*/
13
14/* Intel(R) Integrated Performance Primitives (Intel(R) IPP) */
15
16#if !defined( __IPPICV_H__ )
17#define __IPPICV_H__
18
19#ifdef __cplusplus
20extern "C" {
21#endif
22
23#include "ippicv_l.h"
24#include "ippicv_defs.h"
25#include "ippicv_types.h"
26#include "ippicv_redefs.h"
27#include "ippversion.h"
28
29
30/* =============================================================================
31 ippCore
32============================================================================= */
33
34
35/* /////////////////////////////////////////////////////////////////////////////
36// Name: ippGetLibVersion
37// Purpose: getting of the library version
38// Returns: the structure of information about version
39// of ippcore library
40// Parameters:
41//
42// Notes: not necessary to release the returned structure
43*/
44IPPAPI( const IppLibraryVersion*, ippGetLibVersion, (void) )
45
46/* /////////////////////////////////////////////////////////////////////////////
47// Name: ippInit
48// Purpose: Automatic switching to best for current cpu library code using.
49// Returns:
50// ippStsNoErr
51//
52// Parameter: nothing
53//
54// Notes: At the moment of this function execution no any other Intel(R) IPP function
55// has to be working
56*/
57IPPAPI( IppStatus, ippInit, ( void ))
58
59
60/* /////////////////////////////////////////////////////////////////////////////
61// Name: ippFree
62// Purpose: free memory allocated by the ippMalloc function
63// Parameter:
64// ptr pointer to the memory allocated by the ippMalloc function
65//
66// Notes: use the function to free memory allocated by ippMalloc
67*/
68IPPAPI( void, ippFree, (void* ptr) )
69
70
71/*
72// Name: ippGetCpuFeatures
73// Purpose: Detects CPU features.
74// Parameters:
75// pFeaturesMask Pointer to the features mask.
76// Nonzero value of bit means the corresponding feature is supported.
77// Features mask values are defined in the ippdefs.h
78// [ 0] - MMX ( ippCPUID_MMX )
79// [ 1] - SSE ( ippCPUID_SSE )
80// [ 2] - SSE2 ( ippCPUID_SSE2 )
81// [ 3] - SSE3 ( ippCPUID_SSE3 )
82// [ 4] - SSSE3 ( ippCPUID_SSSE3 )
83// [ 5] - MOVBE ( ippCPUID_MOVBE )
84// [ 6] - SSE41 ( ippCPUID_SSE41 )
85// [ 7] - SSE42 ( ippCPUID_SSE42 )
86// [ 8] - AVX ( ippCPUID_AVX )
87// [ 9] - ENABLEDBYOS( ippAVX_ENABLEDBYOS )
88// [10] - AES ( ippCPUID_AES )
89// [11] - PCLMULQDQ ( ippCPUID_CLMUL )
90// [12] - ABR ( ippCPUID_ABR )
91// [13] - RDRAND ( ippCPUID_RDRAND )
92// [14] - F16C ( ippCPUID_F16C )
93// [15] - AVX2 ( ippCPUID_AVX2 )
94// [16] - ADOX/ADCX ( ippCPUID_ADCOX ) ADCX and ADOX instructions
95// [17] - RDSEED ( ippCPUID_RDSEED ) The RDSEED instruction
96// [18] - PREFETCHW ( ippCPUID_PREFETCHW ) The PREFETCHW instruction
97// [19] - SHA ( ippCPUID_SHA ) Intel(R) Secure Hash Algorithm Extensions (Intel(R) SHA Extensions)
98// [20:63] - Reserved
99//
100// pCpuidInfoRegs Pointer to the 4-element vector.
101// Result of CPUID.1 are stored in this vector.
102// [0] - register EAX
103// [1] - register EBX
104// [2] - register ECX
105// [3] - register EDX
106// If pointer pCpuidInfoRegs is set to NULL, registers are not stored.
107//
108// Returns:
109// ippStsNullPtrErr The pointer to the features mask (pFeaturesMask) is NULL.
110// ippStsNotSupportedCpu CPU is not supported.
111// ippStsNoErr Ok
112//
113// Note: Only IA-32 and Intel(R) 64 are supported
114*/
115IPPAPI( IppStatus, ippGetCpuFeatures, ( Ipp64u* pFeaturesMask,
116 Ipp32u pCpuidInfoRegs[4] ) )
117
118/*
119// Name: ippGetEnabledCpuFeatures
120// Purpose: Detects enabled features for loaded libraries
121// Returns: Features mask
122// Features mask values are defined in the ippdefs.h
123// [ 0] - ippCPUID_MMX
124// [ 1] - ippCPUID_SSE
125// [ 2] - ippCPUID_SSE2
126// [ 3] - ippCPUID_SSE3
127// [ 4] - ippCPUID_SSSE3
128// [ 5] - ippCPUID_MOVBE
129// [ 6] - ippCPUID_SSE41
130// [ 7] - ippCPUID_SSE42
131// [ 8] - ippCPUID_AVX
132// [ 9] - ippAVX_ENABLEDBYOS
133// [10] - ippCPUID_AES
134// [11] - ippCPUID_CLMUL
135// [12] - ippCPUID_ABR
136// [13] - ippCPUID_RDRAND
137// [14] - ippCPUID_F16C
138// [15] - ippCPUID_AVX2
139// [16] - ippCPUID_ADCOX
140// [17] - ippCPUID_RDSEED
141// [18] - ippCPUID_PREFETCHW
142// [19] - ippCPUID_SHA
143// [20:63] - Reserved
144//
145*/
146IPPAPI( Ipp64u, ippGetEnabledCpuFeatures, ( void ) )
147
148/* ////////////////////////////////////////////////////////////////////////////
149// Name: ippSetCpuFeatures
150//
151// Purpose: Changes the set of enabled/disabled CPU features.
152// This function sets the processor-specific code of the Intel IPP
153// library according to the processor features specified in cpuFeatures.
154//
155// Return:
156// ippStsNoErr No errors.
157// Warnings:
158// ippStsFeatureNotSupported Current CPU doesn't support at least 1 of the
159// desired features;
160// ippStsUnknownFeature At least one of the desired features is unknown;
161// ippStsFeaturesCombination Wrong combination of features;
162// ippStsCpuMismatch Indicates that the specified processor features
163// are not valid. Previously set code is used.
164//
165// Arguments:
166// cpuFeatures Desired features to support by the library
167// (see ippdefs.h for ippCPUID_XX definition)
168//
169// NOTE: this function can re-initializes dispatcher and after the
170// call another library (letter) may work
171// CAUTION: At the moment of this function excecution no any other Intel(R) IPP
172// function has to be working
173//
174// The next pre-defined sets of features can be used:
175// 32-bit code:
176// #define PX_FM ( ippCPUID_MMX | ippCPUID_SSE )
177// #define W7_FM ( PX_FM | ippCPUID_SSE2 )
178// #define V8_FM ( W7_FM | ippCPUID_SSE3 | ippCPUID_SSSE3 )
179// #define S8_FM ( V8_FM | ippCPUID_MOVBE )
180// #define P8_FM ( V8_FM | ippCPUID_SSE41 | ippCPUID_SSE42 | ippCPUID_AES | ippCPUID_CLMUL | ippCPUID_SHA )
181// #define G9_FM ( P8_FM | ippCPUID_AVX | ippAVX_ENABLEDBYOS | ippCPUID_RDRAND | ippCPUID_F16C )
182// #define H9_FM ( G9_FM | ippCPUID_AVX2 | ippCPUID_MOVBE | ippCPUID_ADCOX | ippCPUID_RDSEED | ippCPUID_PREFETCHW )
183//
184// 64-bit code:
185// #define PX_FM ( ippCPUID_MMX | ippCPUID_SSE | ippCPUID_SSE2 )
186// #define M7_FM ( PX_FM | ippCPUID_SSE3 )
187// #define N8_FM ( S8_FM )
188// #define U8_FM ( V8_FM )
189// #define Y8_FM ( P8_FM )
190// #define E9_FM ( G9_FM )
191// #define L9_FM ( H9_FM )
192//
193*/
194
195IPPAPI( IppStatus, ippSetCpuFeatures,( Ipp64u cpuFeatures ))
196
197/* /////////////////////////////////////////////////////////////////////////////
198// Name: ippGetCacheParams
199// Purpose: Retrieves cache parameters: cache type, level and size
200// Parameter: pointer to array of structures describing cpu cache:
201// typedef struct {
202// int type;
203// int level;
204// int size
205// } IppCache;
206// where type can be: 0 = Null - No more caches,
207// 1 = Data Cache,
208// 2 = Instruction Cache,
209// 3 = Unified Cache.
210// level means cache level starting from 1
211// cache size field is in bytes
212// Returns:
213// ippStsNullPtrErr Input pointer is NULL
214// ippStsCpuNotSupportedErr Cpu arch is too old to be supported by this function
215// ippStsNoErr No error
216//
217// Notes: don't free pointer!
218*/
219IPPAPI( IppStatus, ippGetCacheParams,( IppCache** ppCacheInfo ))
220
221/* /////////////////////////////////////////////////////////////////////////////
222// Name: ippGetL2CacheSize
223// Purpose: Retrieves L2 cache size in bytes
224// Parameter: pointer to int where to store L2 cache size
225// if returned size is 0 - than cpu is not supported by this function
226// Returns:
227// ippStsNullPtrErr Input pointer is NULL
228// ippStsCpuNotSupportedErr Cpu arch is too old to be supported by this function
229// ippStsNoErr No error
230*/
231IPPAPI( IppStatus, ippGetL2CacheSize,( int* pSize ))
232
233/* =============================================================================
234 ippVM
235============================================================================= */
236
237/* /////////////////////////////////////////////////////////////////////////////
238// Name: ippvmGetLibVersion
239// Purpose: getting of the library version
240// Returns: the structure of information about version
241// of ippVM library
242// Parameters:
243//
244// Notes: not necessary to release the returned structure
245*/
246
247IPPAPI( const IppLibraryVersion*, ippvmGetLibVersion, (void) )
248
249
250IPPAPI( IppStatus, ippsExp_32f_A21, (const Ipp32f a[],Ipp32f r[],Ipp32s n))
251IPPAPI( IppStatus, ippsExp_64f_A50, (const Ipp64f a[],Ipp64f r[],Ipp32s n))
252IPPAPI( IppStatus, ippsLn_32f_A21, (const Ipp32f a[],Ipp32f r[],Ipp32s n))
253IPPAPI( IppStatus, ippsLn_64f_A50, (const Ipp64f a[],Ipp64f r[],Ipp32s n))
254IPPAPI( IppStatus, ippsInvSqrt_32f_A21, (const Ipp32f a[],Ipp32f r[],Ipp32s n))
255IPPAPI( IppStatus, ippsInvSqrt_64f_A50, (const Ipp64f a[],Ipp64f r[],Ipp32s n))
256IPPAPI( IppStatus, ippsSqrt_32f_A21, (const Ipp32f a[],Ipp32f r[],Ipp32s n))
257IPPAPI( IppStatus, ippsSqrt_64f_A50, (const Ipp64f a[],Ipp64f r[],Ipp32s n))
258IPPAPI( IppStatus, ippsPowx_32f_A21, (const Ipp32f a[],const Ipp32f b,Ipp32f r[],Ipp32s n))
259IPPAPI( IppStatus, ippsPowx_64f_A50, (const Ipp64f a[],const Ipp64f b,Ipp64f r[],Ipp32s n))
260IPPAPI( IppStatus, ippsRound_64f, (const Ipp64f a[],Ipp64f r[],Ipp32s n))
261
262
263/* =============================================================================
264 ippSP
265============================================================================= */
266
267
268/* /////////////////////////////////////////////////////////////////////////////
269// Name: ippsGetLibVersion
270// Purpose: get the library version
271// Parameters:
272// Returns: pointer to structure describing version of the ipps library
273//
274// Notes: don't free the pointer
275*/
276IPPAPI( const IppLibraryVersion*, ippsGetLibVersion, (void) )
277
278/* /////////////////////////////////////////////////////////////////////////////
279// Name: ippsFree
280// Purpose: Free memory allocated by ippsMalloc function
281// Parameter:
282// ptr Pointer to memory allocated by ippsMalloc function
283//
284// Notes: Use this function to free memory allocated by ippsMalloc_* only
285*/
286IPPAPI(void, ippsFree, (void* ptr))
287
288/* /////////////////////////////////////////////////////////////////////////////
289// Name: ippsZero
290// Purpose: set elements of the vector to zero of corresponding type
291// Parameters:
292// pDst pointer to the destination vector
293// len length of the vectors
294// Return:
295// ippStsNullPtrErr pointer to the vector is NULL
296// ippStsSizeErr length of the vectors is less or equal zero
297// ippStsNoErr otherwise
298*/
299IPPAPI(IppStatus, ippsZero_8u, ( Ipp8u* pDst, int len ))
300
301
302/* /////////////////////////////////////////////////////////////////////////////
303// Name: ippsSet
304// Purpose: set elements of the destination vector to the value
305// Parameters:
306// val value to set the elements of the vector
307// pDst pointer to the destination vector
308// len length of the vectors
309// Return:
310// ippStsNullPtrErr pointer to the vector is NULL
311// ippStsSizeErr length of the vector is less or equal zero
312// ippStsNoErr otherwise
313*/
314IPPAPI(IppStatus, ippsSet_8u, ( Ipp8u val, Ipp8u* pDst, int len ))
315IPPAPI(IppStatus, ippsSet_16s, ( Ipp16s val, Ipp16s* pDst, int len ))
316IPPAPI(IppStatus, ippsSet_32s, ( Ipp32s val, Ipp32s* pDst, int len ))
317IPPAPI(IppStatus, ippsSet_32f, ( Ipp32f val, Ipp32f* pDst, int len ))
318IPPAPI(IppStatus, ippsSet_64f, ( Ipp64f val, Ipp64f* pDst, int len ))
319
320/* /////////////////////////////////////////////////////////////////////////////
321// Name: ippsCopy
322// Purpose: Copy data from source to destination vector
323// Parameters:
324// pSrc Pointer to input vector
325// pDst Pointer to output vector
326// len Length of vectors in elements
327// Returns:
328// ippStsNullPtrErr One of the pointers is NULL
329// ippStsSizeErr Vector length is less than 1
330// ippStsNoErr Otherwise
331*/
332IPPAPI(IppStatus, ippsCopy_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))
333
334/* /////////////////////////////////////////////////////////////////////////////////////
335// Names: ippsSortRadixGetBufferSize, ippsSortRadixIndexGetBufferSize
336// Purpose: : Get the size (in bytes) of the buffer for ippsSortRadix internal calculations.
337// Arguments:
338// len length of the vectors
339// dataType data type of the vector.
340// pBufferSize pointer to the calculated buffer size (in bytes).
341// Return:
342// ippStsNoErr OK
343// ippStsNullPtrErr pBufferSize is NULL
344// ippStsSizeErr vector's length is not positive
345// ippStsDataTypeErr unsupported data type
346*/
347IPPAPI(IppStatus, ippsSortRadixGetBufferSize, (int len, IppDataType dataType, int *pBufferSize))
348IPPAPI(IppStatus, ippsSortRadixIndexGetBufferSize, (int len, IppDataType dataType, int *pBufferSize))
349
350/* /////////////////////////////////////////////////////////////////////////////////////
351// Names: ippsSortRadixAscend, ippsSortRadixDescend
352//
353// Purpose: Rearrange elements of input vector using radix sort algorithm.
354// ippsSortRadixAscend - sorts input array in increasing order
355// ippsSortRadixDescend - sorts input array in decreasing order
356//
357// Arguments:
358// pSrcDst pointer to the source/destination vector
359// len length of the vectors
360// pBuffer pointer to the work buffer
361// Return:
362// ippStsNoErr OK
363// ippStsNullPtrErr pointer to the data or work buffer is NULL
364// ippStsSizeErr length of the vector is less or equal zero
365*/
366IPPAPI(IppStatus, ippsSortRadixAscend_8u_I, (Ipp8u *pSrcDst, int len, Ipp8u *pBuffer))
367IPPAPI(IppStatus, ippsSortRadixAscend_16u_I, (Ipp16u *pSrcDst, int len, Ipp8u *pBuffer))
368IPPAPI(IppStatus, ippsSortRadixAscend_16s_I, (Ipp16s *pSrcDst, int len, Ipp8u *pBuffer))
369IPPAPI(IppStatus, ippsSortRadixAscend_32s_I, (Ipp32s *pSrcDst, int len, Ipp8u *pBuffer))
370IPPAPI(IppStatus, ippsSortRadixAscend_32f_I, (Ipp32f *pSrcDst, int len, Ipp8u *pBuffer))
371IPPAPI(IppStatus, ippsSortRadixAscend_64f_I, (Ipp64f *pSrcDst, int len, Ipp8u *pBuffer))
372
373IPPAPI(IppStatus, ippsSortRadixDescend_8u_I, (Ipp8u *pSrcDst, int len, Ipp8u *pBuffer))
374IPPAPI(IppStatus, ippsSortRadixDescend_16u_I, (Ipp16u *pSrcDst, int len, Ipp8u *pBuffer))
375IPPAPI(IppStatus, ippsSortRadixDescend_16s_I, (Ipp16s *pSrcDst, int len, Ipp8u *pBuffer))
376IPPAPI(IppStatus, ippsSortRadixDescend_32s_I, (Ipp32s *pSrcDst, int len, Ipp8u *pBuffer))
377IPPAPI(IppStatus, ippsSortRadixDescend_32f_I, (Ipp32f *pSrcDst, int len, Ipp8u *pBuffer))
378IPPAPI(IppStatus, ippsSortRadixDescend_64f_I, (Ipp64f *pSrcDst, int len, Ipp8u *pBuffer))
379
380/* /////////////////////////////////////////////////////////////////////////////////////
381// Names: ippsSortRadixIndexAscend, ippsSortRadixIndexDescend
382//
383// Purpose: Indirectly sorts possibly sparse input vector, using indexes.
384// For a dense input array the following will be true:
385//
386// ippsSortRadixIndexAscend - pSrc[pDstIndx[i-1]] <= pSrc[pDstIndx[i]];
387// ippsSortRadixIndexDescend - pSrc[pDstIndx[i]] <= pSrc[pDstIndx[i-1]];
388//
389// Arguments:
390// pSrc pointer to the first element of a sparse input vector;
391// srcStrideBytes step between two consecutive elements of input vector in bytes;
392// pDstIndx pointer to the output indexes vector;
393// len length of the vectors
394// pBuffer pointer to the work buffer
395// Return:
396// ippStsNoErr OK
397// ippStsNullPtrErr pointers to the vectors or poiter to work buffer is NULL
398// ippStsSizeErr length of the vector is less or equal zero
399*/
400IPPAPI(IppStatus, ippsSortRadixIndexAscend_8u, (const Ipp8u* pSrc, Ipp32s srcStrideBytes, Ipp32s *pDstIndx, int len, Ipp8u *pBuffer))
401IPPAPI(IppStatus, ippsSortRadixIndexAscend_16s, (const Ipp16s* pSrc, Ipp32s srcStrideBytes, Ipp32s *pDstIndx, int len, Ipp8u *pBuffer))
402IPPAPI(IppStatus, ippsSortRadixIndexAscend_16u, (const Ipp16u* pSrc, Ipp32s srcStrideBytes, Ipp32s *pDstIndx, int len, Ipp8u *pBuffer))
403IPPAPI(IppStatus, ippsSortRadixIndexAscend_32s, (const Ipp32s* pSrc, Ipp32s srcStrideBytes, Ipp32s *pDstIndx, int len, Ipp8u *pBuffer))
404IPPAPI(IppStatus, ippsSortRadixIndexAscend_32f, (const Ipp32f* pSrc, Ipp32s srcStrideBytes, Ipp32s *pDstIndx, int len, Ipp8u *pBuffer))
405
406IPPAPI(IppStatus, ippsSortRadixIndexDescend_8u, (const Ipp8u* pSrc, Ipp32s srcStrideBytes, Ipp32s *pDstIndx, int len, Ipp8u *pBuffer))
407IPPAPI(IppStatus, ippsSortRadixIndexDescend_16s, (const Ipp16s* pSrc, Ipp32s srcStrideBytes, Ipp32s *pDstIndx, int len, Ipp8u *pBuffer))
408IPPAPI(IppStatus, ippsSortRadixIndexDescend_16u, (const Ipp16u* pSrc, Ipp32s srcStrideBytes, Ipp32s *pDstIndx, int len, Ipp8u *pBuffer))
409IPPAPI(IppStatus, ippsSortRadixIndexDescend_32s, (const Ipp32s* pSrc, Ipp32s srcStrideBytes, Ipp32s *pDstIndx, int len, Ipp8u *pBuffer))
410IPPAPI(IppStatus, ippsSortRadixIndexDescend_32f, (const Ipp32f* pSrc, Ipp32s srcStrideBytes, Ipp32s *pDstIndx, int len, Ipp8u *pBuffer))
411
412
413/* /////////////////////////////////////////////////////////////////////////////
414// Name: ippsConvert
415// Purpose: Converts vector data type
416// Parameters:
417// pSrc Pointer to input vector
418// pDst Pointer to output vector
419// len Vectors' length in elements
420// rndMode Round mode - ippRndZero, ippRndNear or ippRndFinancial
421// scaleFactor Scale factor (for some integer outputs)
422// Return:
423// ippStsNullPtrErr One of pointers is NULL
424// ippStsSizeErr Vectors' length is less than 1
425// ippStsRoundModeNotSupportedErr Specified round mode is not supported
426// ippStsNoErr No error
427// Note:
428// all out-of-range result are saturated
429*/
430IPPAPI(IppStatus, ippsConvert_64f32f, (const Ipp64f* pSrc, Ipp32f* pDst, int len))
431
432/* /////////////////////////////////////////////////////////////////////////////
433// Names: ippsMagnitude
434// Purpose: compute magnitude of every complex element of the source
435// Parameters:
436// pSrcDst pointer to the source/destination vector
437// pSrc pointer to the source vector
438// pDst pointer to the destination vector
439// len length of the vector(s), number of items
440// scaleFactor scale factor value
441// Return:
442// ippStsNullPtrErr pointer(s) to data vector is NULL
443// ippStsSizeErr length of a vector is less or equal 0
444// ippStsNoErr otherwise
445// Notes:
446// dst = sqrt( src.re^2 + src.im^2 )
447*/
448
449IPPAPI(IppStatus,ippsMagnitude_32f,(const Ipp32f* pSrcRe,const Ipp32f* pSrcIm,
450 Ipp32f* pDst,int len))
451
452IPPAPI(IppStatus,ippsMagnitude_64f,(const Ipp64f* pSrcRe,const Ipp64f* pSrcIm,
453 Ipp64f* pDst,int len))
454
455
456/* /////////////////////////////////////////////////////////////////////////////
457// Name: ippsFlip
458// Purpose: dst[i] = src[len-i-1], i=0..len-1
459// Parameters:
460// pSrc pointer to the input vector
461// pDst pointer to the output vector
462// len length of the vectors, number of items
463// Return:
464// ippStsNullPtrErr pointer(s) to the data is NULL
465// ippStsSizeErr length of the vectors is less or equal zero
466// ippStsNoErr otherwise
467*/
468
469IPPAPI(IppStatus, ippsFlip_16u_I,( Ipp16u* pSrcDst, int len ))
470
471IPPAPI(IppStatus, ippsFlip_32f_I,( Ipp32f* pSrcDst, int len ))
472
473IPPAPI(IppStatus, ippsFlip_64f_I,( Ipp64f* pSrcDst, int len ))
474
475IPPAPI(IppStatus, ippsFlip_8u_I,( Ipp8u* pSrcDst, int len ))
476
477
478/* /////////////////////////////////////////////////////////////////////////////
479// Names: ippsPolarToCart
480//
481// Purpose: Convert polar coordinate to cartesian. Output data are formed as
482// two real vectors.
483//
484// Parameters:
485// pDstMagn an input vector containing the magnitude components
486// pDstPhase an input vector containing the phase components(in radians)
487// pSrcRe an output complex vector to store the coordinates X
488// pSrcIm an output complex vector to store the coordinates Y
489// len a length of the arrays
490// Return:
491// ippStsNoErr Ok
492// ippStsNullPtrErr Some of pointers to input or output data are NULL
493// ippStsSizeErr The length of the arrays is less or equal zero
494//
495*/
496
497IPPAPI(IppStatus, ippsPolarToCart_32f,(const Ipp32f* pSrcMagn,
498 const Ipp32f* pSrcPhase, Ipp32f* pDstRe, Ipp32f* pDstIm, int len))
499IPPAPI(IppStatus, ippsPolarToCart_64f,(const Ipp64f* pSrcMagn,
500 const Ipp64f* pSrcPhase, Ipp64f* pDstRe, Ipp64f* pDstIm, int len))
501
502
503/* /////////////////////////////////////////////////////////////////////////////
504// DFT Init Functions
505///////////////////////////////////////////////////////////////////////////// */
506/* /////////////////////////////////////////////////////////////////////////////
507// Name: ippsDFTInit_C, ippsDFTInit_R
508// Purpose: initialize of DFT context
509// Arguments:
510// length Length of the DFT transform
511// flag Flag to choose the results normalization factors
512// hint Option to select the algorithmic implementation of the transform
513// function
514// pDFTSpec Double pointer to the DFT context structure
515// pMemInit Pointer to initialization buffer
516// Return:
517// ippStsNoErr No errors
518// ippStsNullPtrErr One of the specified pointers is NULL
519// ippStsOrderErr Invalid length value
520// ippStsFFTFlagErr Incorrect normalization flag value
521// ippStsSizeErr Indicates an error when length is less than or equal to 0
522*/
523
524IPPAPI (IppStatus, ippsDFTInit_C_32fc,
525 ( int length, int flag, IppHintAlgorithm hint,
526 IppsDFTSpec_C_32fc* pDFTSpec, Ipp8u* pMemInit ))
527
528IPPAPI (IppStatus, ippsDFTInit_C_64fc,
529 ( int length, int flag, IppHintAlgorithm hint,
530 IppsDFTSpec_C_64fc* pDFTSpec, Ipp8u* pMemInit ))
531
532IPPAPI (IppStatus, ippsDFTInit_R_32f,
533 ( int length, int flag, IppHintAlgorithm hint,
534 IppsDFTSpec_R_32f* pDFTSpec, Ipp8u* pMemInit ))
535
536IPPAPI (IppStatus, ippsDFTInit_R_64f,
537 ( int length, int flag, IppHintAlgorithm hint,
538 IppsDFTSpec_R_64f* pDFTSpec, Ipp8u* pMemInit ))
539
540
541/* /////////////////////////////////////////////////////////////////////////////
542// DFT Context Functions
543///////////////////////////////////////////////////////////////////////////// */
544/* /////////////////////////////////////////////////////////////////////////////
545// Name: ippsDFTGetSize_C, ippsDFTGetSize_R
546// Purpose: Computes the size of the DFT context structure and the size
547 of the required work buffer (in bytes)
548// Arguments:
549// length Length of the DFT transform
550// flag Flag to choose the results normalization factors
551// hint Option to select the algorithmic implementation of the transform
552// function
553// pSizeSpec Pointer to the size value of DFT specification structure
554// pSizeInit Pointer to the size value of the buffer for DFT initialization function
555// pSizeBuf Pointer to the size value of the DFT external work buffer
556// Return:
557// ippStsNoErr No errors
558// ippStsNullPtrErr One of the specified pointers is NULL
559// ippStsOrderErr Invalid length value
560// ippStsFFTFlagErr Incorrect normalization flag value
561// ippStsSizeErr Indicates an error when length is less than or equal to 0
562*/
563
564IPPAPI (IppStatus, ippsDFTGetSize_R_32f,
565 ( int length, int flag, IppHintAlgorithm hint,
566 int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
567
568IPPAPI (IppStatus, ippsDFTGetSize_R_64f,
569 ( int length, int flag, IppHintAlgorithm hint,
570 int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
571
572IPPAPI (IppStatus, ippsDFTGetSize_C_32fc,
573 ( int length, int flag, IppHintAlgorithm hint,
574 int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
575
576IPPAPI (IppStatus, ippsDFTGetSize_C_64fc,
577 ( int length, int flag, IppHintAlgorithm hint,
578 int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
579
580
581/* /////////////////////////////////////////////////////////////////////////////
582// DFT Complex Transforms
583///////////////////////////////////////////////////////////////////////////// */
584/* /////////////////////////////////////////////////////////////////////////////
585// Name: ippsDFTFwd_CToC, ippsDFTInv_CToC
586// Purpose: Computes forward and inverse DFT of a complex signal
587// Arguments:
588// pDFTSpec Pointer to the DFT context
589// pSrc Pointer to the source complex signal
590// pDst Pointer to the destination complex signal
591// pSrcRe Pointer to the real part of source signal
592// pSrcIm Pointer to the imaginary part of source signal
593// pDstRe Pointer to the real part of destination signal
594// pDstIm Pointer to the imaginary part of destination signal
595// pBuffer Pointer to the work buffer
596// scaleFactor Scale factor for output result
597// Return:
598// ippStsNoErr No errors
599// ippStsNullPtrErr One of the specified pointers with the exception of
600// pBuffer is NULL
601// ippStsContextMatchErr Invalid context structure
602// ippStsMemAllocErr Memory allocation fails
603*/
604
605IPPAPI (IppStatus, ippsDFTInv_CToC_32fc,
606 ( const Ipp32fc* pSrc, Ipp32fc* pDst,
607 const IppsDFTSpec_C_32fc* pDFTSpec, Ipp8u* pBuffer ))
608
609IPPAPI (IppStatus, ippsDFTInv_CToC_64fc,
610 ( const Ipp64fc* pSrc, Ipp64fc* pDst,
611 const IppsDFTSpec_C_64fc* pDFTSpec, Ipp8u* pBuffer ))
612
613IPPAPI (IppStatus, ippsDFTFwd_CToC_32fc,
614 ( const Ipp32fc* pSrc, Ipp32fc* pDst,
615 const IppsDFTSpec_C_32fc* pDFTSpec, Ipp8u* pBuffer ))
616
617IPPAPI (IppStatus, ippsDFTFwd_CToC_64fc,
618 ( const Ipp64fc* pSrc, Ipp64fc* pDst,
619 const IppsDFTSpec_C_64fc* pDFTSpec, Ipp8u* pBuffer ))
620
621
622/* /////////////////////////////////////////////////////////////////////////////
623// DFT Real Packed Transforms
624///////////////////////////////////////////////////////////////////////////// */
625/* /////////////////////////////////////////////////////////////////////////////
626// Name: ippsDFTFwd_RToPerm, ippsDFTFwd_RToPack, ippsDFTFwd_RToCCS
627// ippsDFTInv_PermToR, ippsDFTInv_PackToR, ippsDFTInv_CCSToR
628// Purpose: Compute forward and inverse DFT of a real signal
629// using Perm, Pack or Ccs packed format
630// Arguments:
631// pFFTSpec Pointer to the DFT context
632// pSrc Pointer to the source signal
633// pDst Pointer to the destination signal
634// pSrcDst Pointer to the source/destination signal (in-place)
635// pBuffer Pointer to the work buffer
636// scaleFactor Scale factor for output result
637// Return:
638// ippStsNoErr No errors
639// ippStsNullPtrErr One of the specified pointers with the exception of
640// pBuffer is NULL
641// ippStsContextMatchErr Invalid context structure
642// ippStsMemAllocErr Memory allocation fails
643*/
644
645IPPAPI (IppStatus, ippsDFTInv_PackToR_32f,
646 ( const Ipp32f* pSrc, Ipp32f* pDst,
647 const IppsDFTSpec_R_32f* pDFTSpec, Ipp8u* pBuffer ))
648
649IPPAPI (IppStatus, ippsDFTInv_PackToR_64f,
650 ( const Ipp64f* pSrc, Ipp64f* pDst,
651 const IppsDFTSpec_R_64f* pDFTSpec, Ipp8u* pBuffer ))
652
653IPPAPI (IppStatus, ippsDFTFwd_RToPack_32f,
654 ( const Ipp32f* pSrc, Ipp32f* pDst,
655 const IppsDFTSpec_R_32f* pDFTSpec, Ipp8u* pBuffer ))
656
657IPPAPI (IppStatus, ippsDFTFwd_RToPack_64f,
658 ( const Ipp64f* pSrc, Ipp64f* pDst,
659 const IppsDFTSpec_R_64f* pDFTSpec, Ipp8u* pBuffer ))
660
661
662/* /////////////////////////////////////////////////////////////////////////////
663// Dot Product Functions
664///////////////////////////////////////////////////////////////////////////// */
665/* /////////////////////////////////////////////////////////////////////////////
666// Name: ippsDotProd
667// Purpose: compute Dot Product value
668// Arguments:
669// pSrc1 pointer to the source vector
670// pSrc2 pointer to the another source vector
671// len vector's length, number of items
672// pDp pointer to the result
673// scaleFactor scale factor value
674// Return:
675// ippStsNullPtrErr pointer(s) pSrc pDst is NULL
676// ippStsSizeErr length of the vectors is less or equal 0
677// ippStsNoErr otherwise
678// Notes:
679// the functions don't conjugate one of the source vectors
680*/
681
682IPPAPI ( IppStatus, ippsDotProd_32f64f,
683 ( const Ipp32f* pSrc1, const Ipp32f* pSrc2, int len, Ipp64f* pDp ))
684
685IPPAPI(IppStatus, ippsDotProd_64f, (const Ipp64f* pSrc1,
686 const Ipp64f* pSrc2, int len, Ipp64f* pDp))
687
688
689/* ////////////////////////////////////////////////////////////////////////////
690// Names: ippsMinEvery, ippsMaxEvery
691// Purpose: calculation min/max value for every element of two vectors
692// Parameters:
693// pSrc pointer to input vector
694// pSrcDst pointer to input/output vector
695// len vector's length
696// Return:
697// ippStsNullPtrErr pointer(s) to the data is NULL
698// ippStsSizeErr vector`s length is less or equal zero
699// ippStsNoErr otherwise
700*/
701
702IPPAPI(IppStatus, ippsMaxEvery_32f, ( const Ipp32f* pSrc1, const Ipp32f* pSrc2, Ipp32f* pDst, Ipp32u len ))
703IPPAPI(IppStatus, ippsMinEvery_32f, ( const Ipp32f* pSrc1, const Ipp32f* pSrc2, Ipp32f* pDst, Ipp32u len ))
704
705IPPAPI(IppStatus, ippsMinEvery_16u, ( const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, Ipp32u len ))
706IPPAPI(IppStatus, ippsMaxEvery_16u, ( const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, Ipp32u len ))
707
708IPPAPI(IppStatus, ippsMinEvery_8u, ( const Ipp8u* pSrc1, const Ipp8u* pSrc2, Ipp8u* pDst, Ipp32u len ))
709IPPAPI(IppStatus, ippsMaxEvery_8u, ( const Ipp8u* pSrc1, const Ipp8u* pSrc2, Ipp8u* pDst, Ipp32u len ))
710
711IPPAPI(IppStatus, ippsMinEvery_64f, ( const Ipp64f* pSrc1, const Ipp64f* pSrc2, Ipp64f* pDst, Ipp32u len ))
712IPPAPI(IppStatus, ippsMaxEvery_64f, ( const Ipp64f* pSrc1, const Ipp64f* pSrc2, Ipp64f* pDst, Ipp32u len ))
713
714
715/* =============================================================================
716 ippIP
717============================================================================= */
718
719/* /////////////////////////////////////////////////////////////////////////////
720// Name: ippiGetLibVersion
721// Purpose: gets the version of the library
722// Returns: structure containing information about the current version of
723// the Intel IPP library for image processing
724// Parameters:
725//
726// Notes: there is no need to release the returned structure
727*/
728IPPAPI( const IppLibraryVersion*, ippiGetLibVersion, (void) )
729
730
731/* ////////////////////////////////////////////////////////////////////////////
732// Name: ippiScaleC
733//
734// Purpose: Converts data with scaling by formula: dst = src*Val + aVal
735//
736// Parameters:
737// pSrc - Pointer to the source image ROI.
738// srcStep - Distance, in bytes, between the starting points of consecutive lines in the source image.
739// mVal - Multiply value for scaling.
740// aVal - Add value for scaling.
741// pDst - Pointer to the destination image ROI.
742// dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
743// roiSize - Size of the ROI.
744// hint - Option to specify the computation algorithm: ippAlgHintFast(default) or ippAlgHintAccurate.
745// Returns:
746// ippStsNoErr - OK.
747// ippStsNullPtrErr - Error when any of the specified pointers is NULL.
748// ippStsStepErr - Error when srcStep or dstStep has a zero or negative value.
749// ippStsSizeErr - Error when roiSize has a zero or negative value.
750*/
751IPPAPI(IppStatus, ippiScaleC_8u_C1R , ( const Ipp8u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
752IPPAPI(IppStatus, ippiScaleC_8u8s_C1R , ( const Ipp8u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
753IPPAPI(IppStatus, ippiScaleC_8u16u_C1R, ( const Ipp8u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
754IPPAPI(IppStatus, ippiScaleC_8u16s_C1R, ( const Ipp8u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
755IPPAPI(IppStatus, ippiScaleC_8u32s_C1R, ( const Ipp8u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
756IPPAPI(IppStatus, ippiScaleC_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
757IPPAPI(IppStatus, ippiScaleC_8u64f_C1R, ( const Ipp8u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp64f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
758
759IPPAPI(IppStatus, ippiScaleC_8s8u_C1R , ( const Ipp8s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
760IPPAPI(IppStatus, ippiScaleC_8s_C1R , ( const Ipp8s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
761IPPAPI(IppStatus, ippiScaleC_8s16u_C1R, ( const Ipp8s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
762IPPAPI(IppStatus, ippiScaleC_8s16s_C1R, ( const Ipp8s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
763IPPAPI(IppStatus, ippiScaleC_8s32s_C1R, ( const Ipp8s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
764IPPAPI(IppStatus, ippiScaleC_8s32f_C1R, ( const Ipp8s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
765IPPAPI(IppStatus, ippiScaleC_8s64f_C1R, ( const Ipp8s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp64f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
766
767IPPAPI(IppStatus, ippiScaleC_16u8u_C1R , ( const Ipp16u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
768IPPAPI(IppStatus, ippiScaleC_16u8s_C1R , ( const Ipp16u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
769IPPAPI(IppStatus, ippiScaleC_16u_C1R , ( const Ipp16u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
770IPPAPI(IppStatus, ippiScaleC_16u16s_C1R, ( const Ipp16u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
771IPPAPI(IppStatus, ippiScaleC_16u32s_C1R, ( const Ipp16u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
772IPPAPI(IppStatus, ippiScaleC_16u32f_C1R, ( const Ipp16u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
773IPPAPI(IppStatus, ippiScaleC_16u64f_C1R, ( const Ipp16u* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp64f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
774
775IPPAPI(IppStatus, ippiScaleC_16s8u_C1R , ( const Ipp16s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
776IPPAPI(IppStatus, ippiScaleC_16s8s_C1R , ( const Ipp16s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
777IPPAPI(IppStatus, ippiScaleC_16s16u_C1R, ( const Ipp16s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
778IPPAPI(IppStatus, ippiScaleC_16s_C1R , ( const Ipp16s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
779IPPAPI(IppStatus, ippiScaleC_16s32s_C1R, ( const Ipp16s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
780IPPAPI(IppStatus, ippiScaleC_16s32f_C1R, ( const Ipp16s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
781IPPAPI(IppStatus, ippiScaleC_16s64f_C1R, ( const Ipp16s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp64f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
782
783IPPAPI(IppStatus, ippiScaleC_32s8u_C1R , ( const Ipp32s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
784IPPAPI(IppStatus, ippiScaleC_32s8s_C1R , ( const Ipp32s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
785IPPAPI(IppStatus, ippiScaleC_32s16u_C1R, ( const Ipp32s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
786IPPAPI(IppStatus, ippiScaleC_32s16s_C1R, ( const Ipp32s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
787IPPAPI(IppStatus, ippiScaleC_32s_C1R , ( const Ipp32s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
788IPPAPI(IppStatus, ippiScaleC_32s32f_C1R, ( const Ipp32s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
789IPPAPI(IppStatus, ippiScaleC_32s64f_C1R, ( const Ipp32s* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp64f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
790
791IPPAPI(IppStatus, ippiScaleC_32f8u_C1R , ( const Ipp32f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
792IPPAPI(IppStatus, ippiScaleC_32f8s_C1R , ( const Ipp32f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
793IPPAPI(IppStatus, ippiScaleC_32f16u_C1R, ( const Ipp32f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
794IPPAPI(IppStatus, ippiScaleC_32f16s_C1R, ( const Ipp32f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
795IPPAPI(IppStatus, ippiScaleC_32f32s_C1R, ( const Ipp32f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
796IPPAPI(IppStatus, ippiScaleC_32f_C1R , ( const Ipp32f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
797IPPAPI(IppStatus, ippiScaleC_32f64f_C1R, ( const Ipp32f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp64f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
798
799IPPAPI(IppStatus, ippiScaleC_64f8u_C1R , ( const Ipp64f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
800IPPAPI(IppStatus, ippiScaleC_64f8s_C1R , ( const Ipp64f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp8s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
801IPPAPI(IppStatus, ippiScaleC_64f16u_C1R, ( const Ipp64f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16u* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
802IPPAPI(IppStatus, ippiScaleC_64f16s_C1R, ( const Ipp64f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp16s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
803IPPAPI(IppStatus, ippiScaleC_64f32s_C1R, ( const Ipp64f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32s* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
804IPPAPI(IppStatus, ippiScaleC_64f32f_C1R, ( const Ipp64f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp32f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
805IPPAPI(IppStatus, ippiScaleC_64f_C1R , ( const Ipp64f* pSrc, int srcStep, Ipp64f mVal, Ipp64f aVal, Ipp64f* pDst, int dstStep, IppiSize roiSize, IppHintAlgorithm hint ))
806
807
808IPPAPI(IppStatus, ippiScaleC_8u_C1IR, ( const Ipp8u* pSrcDst, int srcDstStep, Ipp64f mVal, Ipp64f aVal, IppiSize roiSize, IppHintAlgorithm hint ))
809IPPAPI(IppStatus, ippiScaleC_8s_C1IR, ( const Ipp8s* pSrcDst, int srcDstStep, Ipp64f mVal, Ipp64f aVal, IppiSize roiSize, IppHintAlgorithm hint ))
810IPPAPI(IppStatus, ippiScaleC_16u_C1IR, ( const Ipp16u* pSrcDst, int srcDstStep, Ipp64f mVal, Ipp64f aVal, IppiSize roiSize, IppHintAlgorithm hint ))
811IPPAPI(IppStatus, ippiScaleC_16s_C1IR, ( const Ipp16s* pSrcDst, int srcDstStep, Ipp64f mVal, Ipp64f aVal, IppiSize roiSize, IppHintAlgorithm hint ))
812IPPAPI(IppStatus, ippiScaleC_32s_C1IR, ( const Ipp32s* pSrcDst, int srcDstStep, Ipp64f mVal, Ipp64f aVal, IppiSize roiSize, IppHintAlgorithm hint ))
813IPPAPI(IppStatus, ippiScaleC_32f_C1IR, ( const Ipp32f* pSrcDst, int srcDstStep, Ipp64f mVal, Ipp64f aVal, IppiSize roiSize, IppHintAlgorithm hint ))
814IPPAPI(IppStatus, ippiScaleC_64f_C1IR, ( const Ipp64f* pSrcDst, int srcDstStep, Ipp64f mVal, Ipp64f aVal, IppiSize roiSize, IppHintAlgorithm hint ))
815
816/* /////////////////////////////////////////////////////////////////////////////
817// Name: ippiMin
818// Purpose: computes the minimum of image pixel values
819// Returns: IppStatus
820// ippStsNoErr OK
821// ippStsNullPtrErr One of the pointers is NULL
822// ippStsSizeErr roiSize has a field with zero or negative value
823// Parameters:
824// pSrc Pointer to the source image.
825// srcStep Step through the source image
826// roiSize Size of the source image ROI.
827// pMin Pointer to the result (C1)
828// min Array containing results (C3, AC4, C4)
829*/
830
831IPPAPI(IppStatus, ippiMin_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize, Ipp8u* pMin))
832IPPAPI(IppStatus, ippiMin_16s_C1R, (const Ipp16s* pSrc, int srcStep, IppiSize roiSize, Ipp16s* pMin))
833IPPAPI(IppStatus, ippiMin_16u_C1R, (const Ipp16u* pSrc, int srcStep, IppiSize roiSize, Ipp16u* pMin))
834IPPAPI(IppStatus, ippiMin_32f_C1R, (const Ipp32f* pSrc, int srcStep, IppiSize roiSize, Ipp32f* pMin))
835
836/* /////////////////////////////////////////////////////////////////////////////
837// Name: ippiMinIndx
838// Purpose: computes the minimum of image pixel values and retrieves
839// the x and y coordinates of pixels with this value
840// Returns: IppStatus
841// ippStsNoErr OK
842// ippStsNullPtrErr One of the pointers is NULL
843// ippStsSizeErr roiSize has a field with zero or negative value
844// Parameters:
845// pSrc Pointer to the source image.
846// srcStep Step in bytes through the source image
847// roiSize Size of the source image ROI.
848// pMin Pointer to the result (C1)
849// min Array of the results (C3, AC4, C4)
850// pIndexX Pointer to the x coordinate of the pixel with min value (C1)
851// pIndexY Pointer to the y coordinate of the pixel with min value (C1)
852// indexX Array containing the x coordinates of the pixel with min value (C3, AC4, C4)
853// indexY Array containing the y coordinates of the pixel with min value (C3, AC4, C4)
854*/
855
856IPPAPI(IppStatus, ippiMinIndx_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize, Ipp8u* pMin, int* pIndexX, int* pIndexY))
857IPPAPI(IppStatus, ippiMinIndx_16s_C1R, (const Ipp16s* pSrc, int srcStep, IppiSize roiSize, Ipp16s* pMin, int* pIndexX, int* pIndexY))
858IPPAPI(IppStatus, ippiMinIndx_16u_C1R, (const Ipp16u* pSrc, int srcStep, IppiSize roiSize, Ipp16u* pMin, int* pIndexX, int* pIndexY))
859IPPAPI(IppStatus, ippiMinIndx_32f_C1R, (const Ipp32f* pSrc, int srcStep, IppiSize roiSize, Ipp32f* pMin, int* pIndexX, int* pIndexY))
860
861/* /////////////////////////////////////////////////////////////////////////////
862// Name: ippiMax
863// Purpose: computes the maximum of image pixel values
864// Returns: IppStatus
865// ippStsNoErr OK
866// ippStsNullPtrErr One of the pointers is NULL
867// ippStsSizeErr roiSize has a field with zero or negative value
868// Parameters:
869// pSrc Pointer to the source image.
870// srcStep Step in bytes through the source image
871// roiSize Size of the source image ROI.
872// pMax Pointer to the result (C1)
873// max Array containing the results (C3, AC4, C4)
874*/
875
876IPPAPI(IppStatus, ippiMax_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize, Ipp8u* pMax))
877IPPAPI(IppStatus, ippiMax_16s_C1R, (const Ipp16s* pSrc, int srcStep, IppiSize roiSize, Ipp16s* pMax))
878IPPAPI(IppStatus, ippiMax_16u_C1R, (const Ipp16u* pSrc, int srcStep, IppiSize roiSize, Ipp16u* pMax))
879IPPAPI(IppStatus, ippiMax_32f_C1R, (const Ipp32f* pSrc, int srcStep, IppiSize roiSize, Ipp32f* pMax))
880
881/* /////////////////////////////////////////////////////////////////////////////
882// Name: ippiMaxIndx
883// Purpose: computes the maximum of image pixel values and retrieves
884// the x and y coordinates of pixels with this value
885// Returns: IppStatus
886// ippStsNoErr OK
887// ippStsNullPtrErr One of the pointers is NULL
888// ippStsSizeErr roiSize has a field with zero or negative value
889// Parameters:
890// pSrc Pointer to the source image.
891// srcStep Step in bytes through the source image
892// roiSize Size of the source image ROI.
893// pMax Pointer to the result (C1)
894// max Array of the results (C3, AC4, C4)
895// pIndexX Pointer to the x coordinate of the pixel with max value (C1)
896// pIndexY Pointer to the y coordinate of the pixel with max value (C1)
897// indexX Array containing the x coordinates of the pixel with max value (C3, AC4, C4)
898// indexY Array containing the y coordinates of the pixel with max value (C3, AC4, C4)
899*/
900
901IPPAPI(IppStatus, ippiMaxIndx_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize, Ipp8u* pMax, int* pIndexX, int* pIndexY))
902IPPAPI(IppStatus, ippiMaxIndx_16s_C1R, (const Ipp16s* pSrc, int srcStep, IppiSize roiSize, Ipp16s* pMax, int* pIndexX, int* pIndexY))
903IPPAPI(IppStatus, ippiMaxIndx_16u_C1R, (const Ipp16u* pSrc, int srcStep, IppiSize roiSize, Ipp16u* pMax, int* pIndexX, int* pIndexY))
904IPPAPI(IppStatus, ippiMaxIndx_32f_C1R, (const Ipp32f* pSrc, int srcStep, IppiSize roiSize, Ipp32f* pMax, int* pIndexX, int* pIndexY))
905
906/* /////////////////////////////////////////////////////////////////////////////
907// Name: ippiMinMax
908// Purpose: computes the minimum and maximum of image pixel value
909// Returns: IppStatus
910// ippStsNoErr OK
911// ippStsNullPtrErr One of the pointers is NULL
912// ippStsSizeErr roiSize has a field with zero or negative value
913// Parameters:
914// pSrc Pointer to the source image
915// srcStep Step in bytes through the source image
916// roiSize Size of the source image ROI.
917// pMin, pMax Pointers to the results (C1)
918// min, max Arrays containing the results (C3, AC4, C4)
919*/
920
921IPPAPI(IppStatus, ippiMinMax_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize, Ipp8u* pMin, Ipp8u* pMax))
922IPPAPI(IppStatus, ippiMinMax_16s_C1R, (const Ipp16s* pSrc, int srcStep, IppiSize roiSize, Ipp16s* pMin, Ipp16s* pMax))
923IPPAPI(IppStatus, ippiMinMax_16u_C1R, (const Ipp16u* pSrc, int srcStep, IppiSize roiSize, Ipp16u* pMin, Ipp16u* pMax))
924IPPAPI(IppStatus, ippiMinMax_32f_C1R, (const Ipp32f* pSrc, int srcStep, IppiSize roiSize, Ipp32f* pMin, Ipp32f* pMax))
925
926/*****************************************************************************************************
927// Name: ippiFilterBorderGetSize, ippiFilterBorderInit, ippiFilterBorder
928// Purpose: Filters an image using a general integer rectangular kernel
929// Returns:
930// ippStsNoErr OK
931// ippStsNullPtrErr One of the pointers is NULL
932// ippStsSizeErr dstRoiSize or kernelSize has a field with zero or negative value
933// ippStsDivisorErr Divisor value is zero, function execution is interrupted
934//
935// Parameters:
936// pSrc Distance, in bytes, between the starting points of consecutive lines in the source image
937// srcStep Step in bytes through the source image buffer
938// pDst Pointer to the destination buffer
939// dstStep Distance, in bytes, between the starting points of consecutive lines in the destination image
940// dstRoiSize Size of the source and destination ROI in pixels
941// pKernel Pointer to the kernel values
942// kernelSize Size of the rectangular kernel in pixels.
943// divisor The integer value by which the computed result is divided.
944// kernelType Kernel type {ipp16s|ipp32f}
945// dataType Data type {ipp8u|ipp16u|ipp32f}
946// numChannels Number of channels, possible values are 1, 3 or 4
947// roundMode Rounding mode (ippRndZero, ippRndNear or ippRndFinancial)
948// pSpecSize Pointer to the size (in bytes) of the spec structure
949// pBufSize Pointer to the size (in bytes) of the external buffer
950// pSpec Pointer to pointer to the allocated and initialized context structure
951// borderType Type of the border
952// borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
953// pBuffer Pointer to the work buffer. It can be equal to NULL if optimization algorithm doesn't demand a work buffer
954*/
955
956IPPAPI( IppStatus, ippiFilterBorderGetSize, (IppiSize kernelSize, IppiSize dstRoiSize, IppDataType dataType, IppDataType kernelType, int numChannels,int* pSpecSize, int* pBufferSize ))
957IPPAPI( IppStatus, ippiFilterBorderInit_16s, ( const Ipp16s* pKernel, IppiSize kernelSize, int divisor, IppDataType dataType, int numChannels , IppRoundMode roundMode, IppiFilterBorderSpec* pSpec ))
958IPPAPI( IppStatus, ippiFilterBorderInit_32f, ( const Ipp32f* pKernel, IppiSize kernelSize, IppDataType dataType, int numChannels , IppRoundMode roundMode, IppiFilterBorderSpec* pSpec ))
959IPPAPI( IppStatus, ippiFilterBorder_8u_C1R, ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp8u borderValue[1], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
960IPPAPI( IppStatus, ippiFilterBorder_8u_C3R, ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp8u borderValue[3], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
961IPPAPI( IppStatus, ippiFilterBorder_8u_C4R, ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp8u borderValue[4], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
962IPPAPI( IppStatus, ippiFilterBorder_16u_C1R, ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp16u borderValue[1], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
963IPPAPI( IppStatus, ippiFilterBorder_16u_C3R, ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp16u borderValue[3], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
964IPPAPI( IppStatus, ippiFilterBorder_16u_C4R, ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp16u borderValue[4], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
965IPPAPI( IppStatus, ippiFilterBorder_16s_C1R, ( const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp16s borderValue[1], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
966IPPAPI( IppStatus, ippiFilterBorder_16s_C3R, ( const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp16s borderValue[3], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
967IPPAPI( IppStatus, ippiFilterBorder_16s_C4R, ( const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp16s borderValue[4], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
968IPPAPI( IppStatus, ippiFilterBorder_32f_C1R, ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp32f borderValue[1], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
969IPPAPI( IppStatus, ippiFilterBorder_32f_C3R, ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp32f borderValue[3], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
970IPPAPI( IppStatus, ippiFilterBorder_32f_C4R, ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiBorderType border, const Ipp32f borderValue[4], const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer ))
971
972/*
973// Name: ippiFilterBorderSetMode
974// Purpose: Set offset value for Ipp8u and Ipp16u and roundMode (Fast or Accurate)
975//
976// Parameters:
977// hint ippAlgHintNone, ippAlgHintFast, ippAlgHintAccurate. Default, fast or accurate rounding.
978// ippAlgHintNone and ippAlgHintFast - default modes, mean that the most common rounding is performed with
979// roundMode passed to Init function, but function performance takes precedence over accuracy and some output
980// pixels can differ on +-1 from exact result
981// ippAlgHintAccurate means that all output pixels are exact and accuracy takes precedence over performance
982// offset offset value. It is just a constant that is added to the final signed result before converting it to unsigned for Ipp8u and Ipp16u data types
983// pSpec Pointer to the initialized ippiFilter Spec
984
985// Returns:
986// ippStsNoErr no errors
987// ippStsNullPtrErr one of the pointers is NULL
988// ippStsNotSupportedModeErr the offset value is not supported, for Ipp16s and Ipp32f data types.
989// ippStsAccurateModeNotSupported the accurate mode not supported for some data types. The result of rounding can be inexact.
990*/
991
992IPPAPI( IppStatus, ippiFilterBorderSetMode, (IppHintAlgorithm hint, int offset, IppiFilterBorderSpec* pSpec))
993
994/* /////////////////////////////////////////////////////////////////////////////
995// Names: ippiHistogramGetBufferSize
996// Purpose: Get the sizes (in bytes) of the spec and the buffer for ippiHistogram_.
997// Parameters:
998// dataType - Data type for source image. Possible values are ipp8u, ipp16u, ipp16s or ipp32f.
999// roiSize - Size, in pixels, of the source image.
1000// nLevels - Number of levels values, separate for each channel.
1001// numChannels - Number of image channels. Possible values are 1, 3, or 4.
1002// uniform - Type of levels distribution: 0 - with random step, 1 - with uniform step.
1003// pSpecSize - Pointer to the calculated spec size (in bytes).
1004// pBufferSize - Pointer to the calculated buffer size (in bytes).
1005// Return:
1006// ippStsNoErr - OK.
1007// ippStsNullPtrErr - Error when any of the specified pointers is NULL.
1008// ippStsSizeErr - Error when the roiSize has a zero or negative value.
1009// ippStsHistoNofLevelsErr - Error when the number of levels is less than 2.
1010// ippStsNumChannelsErr - Error when the numChannels value differs from 1, 3, or 4.
1011// ippStsDataTypeErr - Error when the dataType value differs from the ipp8u, ipp16u, ipp16s or ipp32f.
1012*/
1013IPPAPI(IppStatus, ippiHistogramGetBufferSize, (IppDataType dataType, IppiSize roiSize, const int nLevels[], int numChannels, int uniform, int* pSpecSize, int* pBufferSize))
1014
1015/* /////////////////////////////////////////////////////////////////////////////
1016// Names: ippiHistogramInit, ippiHistogramUniformInit
1017// Purpose: Initializes the Spec for ippiHistogram.
1018// Parameters:
1019// dataType - Data type for source image. Possible values are ipp8u, ipp16u, ipp16s or ipp32f.
1020// pLevels - Pointer to the array of level values. In case of multi-channel data, pLevels is an array of pointers to the level values array for each channel.
1021// lowerLevel - The lower levels for uniform histogram, separate for each channel.
1022// upperLevel - The upper levels for uniform histogram, separate for each channel.
1023// nLevels - Number of levels values, separate for each channel.
1024// numChannels - Number of image channels. Possible values are 1, 3, or 4.
1025// pSpec - Pointer to the spec object.
1026// Return:
1027// ippStsNoErr - OK.
1028// ippStsNullPtrErr - Error when any of the specified pointers is NULL.
1029// ippStsNumChannelsErr - Error when the numChannels value differs from 1, 3, or 4.
1030// ippStsHistoNofLevelsErr - Error when the number of levels is less than 2.
1031// ippStsRangeErr - Error when consecutive pLevels values don't satisfy the condition: pLevel[i] < pLevel[i+1].
1032// ippStsDataTypeErr - Error when the dataType value differs from the ipp8u, ipp16u, ipp16s or ipp32f.
1033// ippStsSizeWrn - Warning ( in case of uniform histogram of integer data type) when rated level step is less than 1.
1034*/
1035IPPAPI(IppStatus, ippiHistogramInit, (IppDataType dataType, const Ipp32f *pLevels[], int nLevels[], int numChannels, IppiHistogramSpec* pSpec))
1036IPPAPI(IppStatus, ippiHistogramUniformInit, (IppDataType dataType, Ipp32f lowerLevel[], Ipp32f upperLevel[], int nLevels[], int numChannels, IppiHistogramSpec* pSpec))
1037
1038/* /////////////////////////////////////////////////////////////////////////////
1039// Name: ippiHistogramGetLevels
1040// Purpose: Returns levels arrays stored in the pSpec object.
1041// Parameters:
1042// pSpec - Pointer to the spec object.
1043// pLevels - Pointer to the array of level values. In case of multi-channel data, pLevels is an array of pointers to the level values array for each channel.
1044// Return:
1045// ippStsNoErr - OK.
1046// ippStsNullPtrErr - Error when any of the specified pointers is NULL.
1047// ippStsBadArgErr - Error when pSpec object doesn`t initialized.
1048*/
1049IPPAPI(IppStatus, ippiHistogramGetLevels, (const IppiHistogramSpec* pSpec, Ipp32f *pLevels[]))
1050
1051/* /////////////////////////////////////////////////////////////////////////////
1052// Name: ippiHistogram
1053// Purpose: Computes the intensity histogram of an image.
1054// Parameters:
1055// pSrc - Pointer to the source image ROI.
1056// srcStep - Distance, in bytes, between the starting points of consecutive lines in the source image.
1057// roiSize - Size, in pixels, of the source image.
1058// pHist - Pointer to the computed histogram. In case of multi-channel data, pHist is an array of pointers to the histogram for each channel.
1059// pSpec - Pointer to the spec.
1060// pBuffer - Pointer to the buffer for internal calculations.
1061// Returns:
1062// ippStsNoErr - OK.
1063// ippStsNullPtrErr - Error when any of the specified pointers is NULL.
1064// ippStsSizeErr - Error when the roiSize has a zero or negative value.
1065// ippStsStepErr - Error when the srcStep is less than roiSize.width*sizeof(*pSrc)*nChannels.
1066// ippStsBadArgErr - Error when pSpec object doesn`t initialized.
1067*/
1068IPPAPI(IppStatus, ippiHistogram_8u_C1R , (const Ipp8u* pSrc, int srcStep, IppiSize roiSize, Ipp32u* pHist , const IppiHistogramSpec* pSpec, Ipp8u* pBuffer))
1069IPPAPI(IppStatus, ippiHistogram_16s_C1R, (const Ipp16s* pSrc, int srcStep, IppiSize roiSize, Ipp32u* pHist , const IppiHistogramSpec* pSpec, Ipp8u* pBuffer))
1070IPPAPI(IppStatus, ippiHistogram_16u_C1R, (const Ipp16u* pSrc, int srcStep, IppiSize roiSize, Ipp32u* pHist , const IppiHistogramSpec* pSpec, Ipp8u* pBuffer))
1071IPPAPI(IppStatus, ippiHistogram_32f_C1R, (const Ipp32f* pSrc, int srcStep, IppiSize roiSize, Ipp32u* pHist , const IppiHistogramSpec* pSpec, Ipp8u* pBuffer))
1072
1073/* /////////////////////////////////////////////////////////////////////////////
1074// Name: ippiRemap
1075// Purpose: Transforms the source image by remapping its pixels
1076// dst[i,j] = src[xMap[i,j], yMap[i,j]]
1077// Parameters:
1078// pSrc Pointer to the source image (point to pixel (0,0)). An array
1079// of pointers to each plane of the source image for planar data
1080// srcSize Size of the source image
1081// srcStep Step through the source image
1082// srcROI Region if interest in the source image
1083// pxMap Pointer to image with x coordinates of map
1084// xMapStep The step in xMap image
1085// pyMap The pointer to image with y coordinates of map
1086// yMapStep The step in yMap image
1087// pDst Pointer to the destination image. An array of pointers
1088// to each plane of the destination image for planar data
1089// dstStep Step through the destination image
1090// dstRoiSize Size of the destination ROI
1091// interpolation The type of interpolation to perform for image resampling
1092// The following types are currently supported:
1093// IPPI_INTER_NN Nearest neighbor interpolation
1094// IPPI_INTER_LINEAR Linear interpolation
1095// IPPI_INTER_CUBIC Cubic interpolation
1096// IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom cubic filter
1097// IPPI_INTER_LANCZOS Interpolation by Lanczos3-windowed sinc function
1098// The special feature in addition to one of general methods:
1099// IPPI_SMOOTH_EDGE Edges smoothing
1100// Returns:
1101// ippStsNoErr OK
1102// ippStsNullPtrErr One of the pointers is NULL
1103// ippStsSizeErr srcROI or dstRoiSize has a field with zero or negative value
1104// ippStsStepErr One of the step values is zero or negative
1105// ippStsInterpolateErr interpolation has an illegal value
1106*/
1107
1108IPPAPI(IppStatus, ippiRemap_8u_C1R, (const Ipp8u* pSrc, IppiSize srcSize,
1109 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1110 const Ipp32f* pyMap, int yMapStep, Ipp8u* pDst, int dstStep,
1111 IppiSize dstRoiSize, int interpolation))
1112IPPAPI(IppStatus, ippiRemap_8u_C3R, (const Ipp8u* pSrc, IppiSize srcSize,
1113 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1114 const Ipp32f* pyMap, int yMapStep, Ipp8u* pDst, int dstStep,
1115 IppiSize dstRoiSize, int interpolation))
1116IPPAPI(IppStatus, ippiRemap_8u_C4R, (const Ipp8u* pSrc, IppiSize srcSize,
1117 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1118 const Ipp32f* pyMap, int yMapStep, Ipp8u* pDst, int dstStep,
1119 IppiSize dstRoiSize, int interpolation))
1120IPPAPI(IppStatus, ippiRemap_16u_C1R, (const Ipp16u* pSrc, IppiSize srcSize,
1121 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1122 const Ipp32f* pyMap, int yMapStep, Ipp16u* pDst, int dstStep,
1123 IppiSize dstRoiSize, int interpolation))
1124IPPAPI(IppStatus, ippiRemap_16u_C3R, (const Ipp16u* pSrc, IppiSize srcSize,
1125 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1126 const Ipp32f* pyMap, int yMapStep, Ipp16u* pDst, int dstStep,
1127 IppiSize dstRoiSize, int interpolation))
1128IPPAPI(IppStatus, ippiRemap_16u_C4R, (const Ipp16u* pSrc, IppiSize srcSize,
1129 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1130 const Ipp32f* pyMap, int yMapStep, Ipp16u* pDst, int dstStep,
1131 IppiSize dstRoiSize, int interpolation))
1132IPPAPI(IppStatus, ippiRemap_16s_C1R, (const Ipp16s* pSrc, IppiSize srcSize,
1133 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1134 const Ipp32f* pyMap, int yMapStep, Ipp16s* pDst, int dstStep,
1135 IppiSize dstRoiSize, int interpolation))
1136IPPAPI(IppStatus, ippiRemap_16s_C3R, (const Ipp16s* pSrc, IppiSize srcSize,
1137 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1138 const Ipp32f* pyMap, int yMapStep, Ipp16s* pDst, int dstStep,
1139 IppiSize dstRoiSize, int interpolation))
1140IPPAPI(IppStatus, ippiRemap_16s_C4R, (const Ipp16s* pSrc, IppiSize srcSize,
1141 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1142 const Ipp32f* pyMap, int yMapStep, Ipp16s* pDst, int dstStep,
1143 IppiSize dstRoiSize, int interpolation))
1144IPPAPI(IppStatus, ippiRemap_32f_C1R, (const Ipp32f* pSrc, IppiSize srcSize,
1145 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1146 const Ipp32f* pyMap, int yMapStep, Ipp32f* pDst, int dstStep,
1147 IppiSize dstRoiSize, int interpolation))
1148IPPAPI(IppStatus, ippiRemap_32f_C3R, (const Ipp32f* pSrc, IppiSize srcSize,
1149 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1150 const Ipp32f* pyMap, int yMapStep, Ipp32f* pDst, int dstStep,
1151 IppiSize dstRoiSize, int interpolation))
1152IPPAPI(IppStatus, ippiRemap_32f_C4R, (const Ipp32f* pSrc, IppiSize srcSize,
1153 int srcStep, IppiRect srcROI, const Ipp32f* pxMap, int xMapStep,
1154 const Ipp32f* pyMap, int yMapStep, Ipp32f* pDst, int dstStep,
1155 IppiSize dstRoiSize, int interpolation))
1156
1157
1158/* /////////////////////////////////////////////////////////////////////////////
1159// Warp Transform functions
1160// ////////////////////////////////////////////////////////////////////////// */
1161
1162/* /////////////////////////////////////////////////////////////////////////////
1163// Name: ippiGetAffineBound
1164// Purpose: Computes the bounding rectangle of the transformed image ROI
1165// Parameters:
1166// srcROI Source image ROI
1167// coeffs The affine transform matrix
1168// |X'| |a11 a12| |X| |a13|
1169// | | = | |*| |+| |
1170// |Y'| |a21 a22| |Y| |a23|
1171// bound Resultant bounding rectangle
1172// Returns:
1173// ippStsNoErr OK
1174*/
1175
1176IPPAPI(IppStatus, ippiGetAffineBound, (
1177 IppiRect srcROI, double bound[2][2], const double coeffs[2][3]))
1178
1179/* /////////////////////////////////////////////////////////////////////////////
1180// Name: ippiGetRotateTransform
1181// Purpose: Computes the affine coefficients for the transform that
1182// rotates an image around (0, 0) by specified angle + shifts it
1183// | cos(angle) sin(angle) xShift|
1184// | |
1185// |-sin(angle) cos(angle) yShift|
1186// Parameters:
1187// srcROI Source image ROI
1188// angle The angle of rotation in degrees
1189// xShift, yShift The shift along the corresponding axis
1190// coeffs Output array with the affine transform coefficients
1191// Returns:
1192// ippStsNoErr OK
1193// ippStsOutOfRangeErr Indicates an error if the angle is NaN or Infinity
1194*/
1195
1196IPPAPI(IppStatus, ippiGetRotateTransform, (
1197 double angle, double xShift, double yShift, double coeffs[2][3]))
1198
1199/* /////////////////////////////////////////////////////////////////////////////
1200// Name: ippiWarpGetBufferSize
1201// Purpose: Computes the size of external buffer for Warp transform
1202//
1203// Parameters:
1204// pSpec Pointer to the Spec structure for warp transform
1205// dstRoiSize Size of the output image (in pixels)
1206// numChannels Number of channels, possible values are 1 or 3 or 4
1207// pBufSize Pointer to the size (in bytes) of the external buffer
1208//
1209// Return Values:
1210// ippStsNoErr Indicates no error
1211// ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
1212// ippStsNoOperation Indicates a warning if width or height of output image is zero
1213// ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
1214// ippStsNumChannelsErr Indicates an error if numChannels has illegal value
1215// ippStsSizeErr Indicates an error condition in the following cases:
1216// - if width or height of the source image is negative,
1217// - if the calculated buffer size exceeds maximum 32 bit signed integer
1218// positive value (the processed image ROIs are too large ).
1219// ippStsSizeWrn Indicates a warning if the destination image size is more than
1220// the destination image origin size
1221*/
1222IPPAPI (IppStatus, ippiWarpGetBufferSize, (const IppiWarpSpec* pSpec, IppiSize dstRoiSize, int* pBufSize))
1223
1224/* /////////////////////////////////////////////////////////////////////////////
1225// Warp Affine Transform functions
1226// ////////////////////////////////////////////////////////////////////////// */
1227
1228/* /////////////////////////////////////////////////////////////////////////////
1229// Name: ippiWarpAffineGetSize
1230// Purpose: Computes the size of Spec structure and temporal buffer for Affine transform
1231//
1232// Parameters:
1233// srcSize Size of the input image (in pixels)
1234// dstSize Size of the output image (in pixels)
1235// dataType Data type of the source and destination images. Possible values
1236// are ipp8u, ipp16u, ipp16s, ipp32f and ipp64f.
1237// coeffs The affine transform coefficients
1238// interpolation Interpolation method. Supported values: ippNearest, ippLinear and ippCubic.
1239// direction Transformation direction. Possible values are:
1240// ippWarpForward - Forward transformation.
1241// ippWarpBackward - Backward transformation.
1242// border Type of the border
1243// pSpecSize Pointer to the size (in bytes) of the Spec structure
1244// pInitBufSize Pointer to the size (in bytes) of the temporal buffer
1245//
1246// Return Values:
1247// ippStsNoErr Indicates no error
1248// ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
1249// ippStsNoOperation Indicates a warning if width or height of any image is zero
1250// ippStsSizeErr Indicates an error in the following cases:
1251// - if width or height of the source or destination image is negative,
1252// - if one of the calculated sizes exceeds maximum 32 bit signed integer
1253// positive value (the size of the one of the processed images is too large).
1254// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
1255// ippStsWarpDirectionErr Indicates an error when the direction value is illegal.
1256// ippStsInterpolationErr Indicates an error if interpolation has an illegal value
1257// ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
1258// ippStsCoeffErr Indicates an error condition, if affine transformation is singular.
1259// ippStsBorderErr Indicates an error if border type has an illegal value
1260//
1261*/
1262IPPAPI (IppStatus, ippiWarpAffineGetSize, (IppiSize srcSize, IppiSize dstSize, IppDataType dataType, const double coeffs[2][3],
1263 IppiInterpolationType interpolation, IppiWarpDirection direction,
1264 IppiBorderType borderType, int* pSpecSize, int* pInitBufSize))
1265
1266/* /////////////////////////////////////////////////////////////////////////////
1267// Name: ippiWarpAffineNearestInit
1268// ippiWarpAffineLinearInit
1269// ippiWarpAffineCubicInit
1270//
1271// Purpose: Initializes the Spec structure for the Warp affine transform
1272// by different interpolation methods
1273//
1274// Parameters:
1275// srcSize Size of the input image (in pixels)
1276// dstSize Size of the output image (in pixels)
1277// dataType Data type of the source and destination images. Possible values are:
1278// ipp8u, ipp16u, ipp16s, ipp32f, ipp64f.
1279// coeffs The affine transform coefficients
1280// direction Transformation direction. Possible values are:
1281// ippWarpForward - Forward transformation.
1282// ippWarpBackward - Backward transformation.
1283// numChannels Number of channels, possible values are 1 or 3 or 4
1284// valueB The first parameter (B) for specifying Cubic filters
1285// valueC The second parameter (C) for specifying Cubic filters
1286// border Type of the border
1287// borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
1288// smoothEdge The smooth edge flag. Supported values:
1289// 0 - transform without edge smoothing
1290// 1 - transform with edge smoothing
1291// pSpec Pointer to the Spec structure for resize filter
1292// pInitBuf Pointer to the temporal buffer for several initialization cases
1293//
1294// Return Values:
1295// ippStsNoErr Indicates no error
1296// ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
1297// ippStsNoOperation Indicates a warning if width or height of any image is zero
1298// ippStsSizeErr Indicates an error if width or height of the source or destination
1299// image is negative
1300// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
1301// ippStsWarpDirectionErr Indicates an error when the direction value is illegal.
1302// ippStsCoeffErr Indicates an error condition, if the affine transformation is singular.
1303// ippStsNumChannelsErr Indicates an error if numChannels has illegal value
1304// ippStsBorderErr Indicates an error if border type has an illegal value
1305// ippStsWrongIntersectQuad Indicates a warning that no operation is performed, if the transformed
1306// source image has no intersection with the destination image.
1307// ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
1308//
1309// Notes/References:
1310// 1. The equation shows the family of cubic filters:
1311// ((12-9B-6C)*|x|^3 + (-18+12B+6C)*|x|^2 + (6-2B) ) / 6 for |x| < 1
1312// K(x) = (( -B-6C)*|x|^3 + ( 6B+30C)*|x|^2 + (-12B-48C)*|x| + (8B+24C); / 6 for 1 <= |x| < 2
1313// 0 elsewhere
1314// Some values of (B,C) correspond to known cubic splines: Catmull-Rom (B=0,C=0.5), B-Spline (B=1,C=0) and other.
1315// Mitchell, Don P.; Netravali, Arun N. (Aug. 1988). "Reconstruction filters in computer graphics"
1316// http://www.mentallandscape.com/Papers_siggraph88.pdf
1317//
1318// 2. Supported border types are ippBorderRepl, ippBorderConst, ippBorderTransp and ippBorderInMem
1319*/
1320IPPAPI (IppStatus, ippiWarpAffineNearestInit, (IppiSize srcSize, IppiSize dstSize, IppDataType dataType, const double coeffs[2][3],
1321 IppiWarpDirection direction, int numChannels, IppiBorderType borderType,
1322 const Ipp64f *pBorderValue, int smoothEdge, IppiWarpSpec* pSpec))
1323IPPAPI (IppStatus, ippiWarpAffineLinearInit, (IppiSize srcSize, IppiSize dstSize, IppDataType dataType, const double coeffs[2][3],
1324 IppiWarpDirection direction, int numChannels, IppiBorderType borderType,
1325 const Ipp64f *pBorderValue, int smoothEdge, IppiWarpSpec* pSpec))
1326IPPAPI (IppStatus, ippiWarpAffineCubicInit, (IppiSize srcSize, IppiSize dstSize, IppDataType dataType, const double coeffs[2][3],
1327 IppiWarpDirection direction, int numChannels, Ipp64f valueB, Ipp64f valueC,
1328 IppiBorderType borderType, const Ipp64f *pBorderValue, int smoothEdge, IppiWarpSpec* pSpec,
1329 Ipp8u* pInitBuf))
1330
1331/* /////////////////////////////////////////////////////////////////////////////
1332// Name: ippiWarpAffineNearest
1333// ippiWarpAffineLinear
1334// ippiWarpAffineCubic
1335//
1336// Purpose: Performs affine transform of an image with using different interpolation methods
1337//
1338// Parameters:
1339// pSrc Pointer to the source image
1340// srcStep Distance (in bytes) between of consecutive lines in the source image
1341// pDst Pointer to the destination image
1342// dstStep Distance (in bytes) between of consecutive lines in the destination image
1343// dstRoiOffset Offset of tiled image respectively destination image origin
1344// dstRoiSize Size of the destination image (in pixels)
1345// border Type of the border
1346// borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
1347// pSpec Pointer to the Spec structure for resize filter
1348// pBuffer Pointer to the work buffer
1349//
1350// Return Values:
1351// ippStsNoErr Indicates no error
1352// ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
1353// ippStsNoOperation Indicates a warning if width or height of output image is zero
1354// ippStsBorderErr Indicates an error if border type has an illegal value
1355// ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
1356// ippStsNotSupportedModeErr Indicates an error if requested mode is currently not supported
1357// ippStsSizeErr Indicates an error if width or height of the destination image
1358// is negative
1359// ippStsStepErr Indicates an error if the step value is not data type multiple
1360// ippStsOutOfRangeErr Indicates an error if the destination image offset point is outside the
1361// destination image origin
1362// ippStsSizeWrn Indicates a warning if the destination image size is more than
1363// the destination image origin size
1364// ippStsWrongIntersectQuad Indicates a warning that no operation is performed if the destination
1365// ROI has no intersection with the transformed source image origin.
1366//
1367// Notes:
1368// 1. Supported border types are ippBorderRepl, ippBorderConst, ippBorderTransp and ippBorderRepl
1369*/
1370IPPAPI (IppStatus, ippiWarpAffineNearest_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1371 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1372 Ipp8u* pBuffer))
1373IPPAPI (IppStatus, ippiWarpAffineNearest_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1374 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1375 Ipp8u* pBuffer))
1376IPPAPI (IppStatus, ippiWarpAffineNearest_8u_C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1377 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1378 Ipp8u* pBuffer))
1379IPPAPI (IppStatus, ippiWarpAffineNearest_16u_C1R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1380 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1381 Ipp8u* pBuffer))
1382IPPAPI (IppStatus, ippiWarpAffineNearest_16u_C3R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1383 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1384 Ipp8u* pBuffer))
1385IPPAPI (IppStatus, ippiWarpAffineNearest_16u_C4R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1386 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1387 Ipp8u* pBuffer))
1388IPPAPI (IppStatus, ippiWarpAffineNearest_16s_C1R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1389 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1390 Ipp8u* pBuffer))
1391IPPAPI (IppStatus, ippiWarpAffineNearest_16s_C3R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1392 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1393 Ipp8u* pBuffer))
1394IPPAPI (IppStatus, ippiWarpAffineNearest_16s_C4R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1395 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1396 Ipp8u* pBuffer))
1397IPPAPI (IppStatus, ippiWarpAffineNearest_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1398 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1399 Ipp8u* pBuffer))
1400IPPAPI (IppStatus, ippiWarpAffineNearest_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1401 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1402 Ipp8u* pBuffer))
1403IPPAPI (IppStatus, ippiWarpAffineNearest_32f_C4R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1404 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1405 Ipp8u* pBuffer))
1406IPPAPI (IppStatus, ippiWarpAffineNearest_64f_C1R, (const Ipp64f* pSrc, int srcStep, Ipp64f* pDst, int dstStep,
1407 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1408 Ipp8u* pBuffer))
1409IPPAPI (IppStatus, ippiWarpAffineNearest_64f_C3R, (const Ipp64f* pSrc, int srcStep, Ipp64f* pDst, int dstStep,
1410 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1411 Ipp8u* pBuffer))
1412IPPAPI (IppStatus, ippiWarpAffineNearest_64f_C4R, (const Ipp64f* pSrc, int srcStep, Ipp64f* pDst, int dstStep,
1413 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1414 Ipp8u* pBuffer))
1415
1416IPPAPI (IppStatus, ippiWarpAffineLinear_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1417 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1418 Ipp8u* pBuffer))
1419IPPAPI (IppStatus, ippiWarpAffineLinear_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1420 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1421 Ipp8u* pBuffer))
1422IPPAPI (IppStatus, ippiWarpAffineLinear_8u_C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1423 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1424 Ipp8u* pBuffer))
1425IPPAPI (IppStatus, ippiWarpAffineLinear_16u_C1R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1426 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1427 Ipp8u* pBuffer))
1428IPPAPI (IppStatus, ippiWarpAffineLinear_16u_C3R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1429 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1430 Ipp8u* pBuffer))
1431IPPAPI (IppStatus, ippiWarpAffineLinear_16u_C4R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1432 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1433 Ipp8u* pBuffer))
1434IPPAPI (IppStatus, ippiWarpAffineLinear_16s_C1R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1435 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1436 Ipp8u* pBuffer))
1437IPPAPI (IppStatus, ippiWarpAffineLinear_16s_C3R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1438 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1439 Ipp8u* pBuffer))
1440IPPAPI (IppStatus, ippiWarpAffineLinear_16s_C4R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1441 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1442 Ipp8u* pBuffer))
1443IPPAPI (IppStatus, ippiWarpAffineLinear_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1444 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1445 Ipp8u* pBuffer))
1446IPPAPI (IppStatus, ippiWarpAffineLinear_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1447 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1448 Ipp8u* pBuffer))
1449IPPAPI (IppStatus, ippiWarpAffineLinear_32f_C4R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1450 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1451 Ipp8u* pBuffer))
1452IPPAPI (IppStatus, ippiWarpAffineLinear_64f_C1R, (const Ipp64f* pSrc, int srcStep, Ipp64f* pDst, int dstStep,
1453 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1454 Ipp8u* pBuffer))
1455IPPAPI (IppStatus, ippiWarpAffineLinear_64f_C3R, (const Ipp64f* pSrc, int srcStep, Ipp64f* pDst, int dstStep,
1456 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1457 Ipp8u* pBuffer))
1458IPPAPI (IppStatus, ippiWarpAffineLinear_64f_C4R, (const Ipp64f* pSrc, int srcStep, Ipp64f* pDst, int dstStep,
1459 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1460 Ipp8u* pBuffer))
1461
1462IPPAPI (IppStatus, ippiWarpAffineCubic_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1463 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1464 Ipp8u* pBuffer))
1465IPPAPI (IppStatus, ippiWarpAffineCubic_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1466 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1467 Ipp8u* pBuffer))
1468IPPAPI (IppStatus, ippiWarpAffineCubic_8u_C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1469 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1470 Ipp8u* pBuffer))
1471IPPAPI (IppStatus, ippiWarpAffineCubic_16u_C1R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1472 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1473 Ipp8u* pBuffer))
1474IPPAPI (IppStatus, ippiWarpAffineCubic_16u_C3R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1475 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1476 Ipp8u* pBuffer))
1477IPPAPI (IppStatus, ippiWarpAffineCubic_16u_C4R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1478 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1479 Ipp8u* pBuffer))
1480IPPAPI (IppStatus, ippiWarpAffineCubic_16s_C1R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1481 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1482 Ipp8u* pBuffer))
1483IPPAPI (IppStatus, ippiWarpAffineCubic_16s_C3R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1484 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1485 Ipp8u* pBuffer))
1486IPPAPI (IppStatus, ippiWarpAffineCubic_16s_C4R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1487 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1488 Ipp8u* pBuffer))
1489IPPAPI (IppStatus, ippiWarpAffineCubic_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1490 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1491 Ipp8u* pBuffer))
1492IPPAPI (IppStatus, ippiWarpAffineCubic_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1493 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1494 Ipp8u* pBuffer))
1495IPPAPI (IppStatus, ippiWarpAffineCubic_32f_C4R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1496 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1497 Ipp8u* pBuffer))
1498IPPAPI (IppStatus, ippiWarpAffineCubic_64f_C1R, (const Ipp64f* pSrc, int srcStep, Ipp64f* pDst, int dstStep,
1499 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1500 Ipp8u* pBuffer))
1501IPPAPI (IppStatus, ippiWarpAffineCubic_64f_C3R, (const Ipp64f* pSrc, int srcStep, Ipp64f* pDst, int dstStep,
1502 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1503 Ipp8u* pBuffer))
1504IPPAPI (IppStatus, ippiWarpAffineCubic_64f_C4R, (const Ipp64f* pSrc, int srcStep, Ipp64f* pDst, int dstStep,
1505 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1506 Ipp8u* pBuffer))
1507
1508/* /////////////////////////////////////////////////////////////////////////////
1509// Warp Perspective Transform functions
1510// ////////////////////////////////////////////////////////////////////////// */
1511
1512/* /////////////////////////////////////////////////////////////////////////////
1513// Name: ippiWarpGetRectInfinite
1514// Purpose: Returns the constant value ippRectInfinite
1515//
1516// ippRectInfinite = {IPP_MIN_32S/2, IPP_MIN_32S/2,
1517// IPP_MAX_32S, IPP_MAX_32S};
1518//
1519// Return Values:
1520// ippRectInfinite constant value of IppiRect type
1521//
1522*/
1523IPPAPI(IppiRect, ippiWarpGetRectInfinite, (void))
1524
1525/* /////////////////////////////////////////////////////////////////////////////
1526// Name: ippiWarpPerspectiveGetSize
1527// Purpose: Computes the size of Spec structure and temporal buffer
1528// for Perspective transform
1529//
1530// Parameters:
1531// srcSize Size of the input image (in pixels)
1532// srcRoi Region of interest in the source image
1533// dstSize Size of the output image (in pixels)
1534// dataType Data type of the source and destination images. Possible values
1535// are ipp8u, ipp16u, ipp16s, ipp32f and ipp64f.
1536// coeffs The perspective transform coefficients
1537// interpolation Interpolation method. Supported values: ippNearest, ippLinear and ippCubic.
1538// direction Transformation direction. Possible values are:
1539// ippWarpForward - Forward transformation.
1540// ippWarpBackward - Backward transformation.
1541// border Type of the border
1542// pSpecSize Pointer to the size (in bytes) of the Spec structure
1543// pInitBufSize Pointer to the size (in bytes) of the temporal buffer
1544//
1545// Return Values:
1546// ippStsNoErr Indicates no error
1547// ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
1548// ippStsNoOperation Indicates a warning if width or height of any image is zero
1549// ippStsSizeErr Indicates an error in the following cases:
1550// - if width or height of the source or destination image is negative,
1551// - if one of the calculated sizes exceeds maximum 32 bit signed integer
1552// positive value (the size of the one of the processed images is too large).
1553// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
1554// ippStsWarpDirectionErr Indicates an error when the direction value is illegal.
1555// ippStsInterpolationErr Indicates an error if interpolation has an illegal value
1556// ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
1557// ippStsCoeffErr Indicates an error condition, if perspective transformation is singular.
1558// ippStsBorderErr Indicates an error if border type has an illegal value
1559//
1560*/
1561IPPAPI (IppStatus, ippiWarpPerspectiveGetSize, (IppiSize srcSize, IppiRect srcRoi, IppiSize dstSize, IppDataType dataType,
1562 const double coeffs[3][3], IppiInterpolationType interpolation,
1563 IppiWarpDirection direction, IppiBorderType borderType, int* pSpecSize,
1564 int* pInitBufSize))
1565
1566/* /////////////////////////////////////////////////////////////////////////////
1567// Name: ippiWarpPerspectiveNearestInit
1568// ippiWarpPerspectiveLinearInit
1569// ippiWarpPerspectiveCubicInit
1570//
1571// Purpose: Initializes the Spec structure for the Warp perspective transform
1572// by different interpolation methods
1573//
1574// Parameters:
1575// srcSize Size of the input image (in pixels)
1576// srcRoi Region of interest in the source image
1577// dstSize Size of the output image (in pixels)
1578// dataType Data type of the source and destination images. Possible values are:
1579// ipp8u, ipp16u, ipp16s, ipp32f, ipp64f.
1580// coeffs The perspective transform coefficients
1581// direction Transformation direction. Possible values are:
1582// ippWarpForward - Forward transformation.
1583// ippWarpBackward - Backward transformation.
1584// numChannels Number of channels, possible values are 1 or 3 or 4
1585// valueB The first parameter (B) for specifying Cubic filters
1586// valueC The second parameter (C) for specifying Cubic filters
1587// border Type of the border
1588// borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
1589// smoothEdge The smooth edge flag. Supported values:
1590// 0 - transform without edge smoothing
1591// 1 - transform with edge smoothing
1592// pSpec Pointer to the Spec structure for resize filter
1593// pInitBuf Pointer to the temporal buffer for several initialization cases
1594//
1595// Return Values:
1596// ippStsNoErr Indicates no error
1597// ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
1598// ippStsNoOperation Indicates a warning if width or height of any image is zero
1599// ippStsSizeErr Indicates an error if width or height of the source or destination
1600// image is negative
1601// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
1602// ippStsWarpDirectionErr Indicates an error when the direction value is illegal.
1603// ippStsCoeffErr Indicates an error condition, if the perspective transformation is singular.
1604// ippStsNumChannelsErr Indicates an error if numChannels has illegal value
1605// ippStsBorderErr Indicates an error if border type has an illegal value
1606// ippStsWrongIntersectQuad Indicates a warning that no operation is performed, if the transformed
1607// source image has no intersection with the destination image.
1608// ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
1609//
1610// Notes/References:
1611// 1. The equation shows the family of cubic filters:
1612// ((12-9B-6C)*|x|^3 + (-18+12B+6C)*|x|^2 + (6-2B) ) / 6 for |x| < 1
1613// K(x) = (( -B-6C)*|x|^3 + ( 6B+30C)*|x|^2 + (-12B-48C)*|x| + (8B+24C); / 6 for 1 <= |x| < 2
1614// 0 elsewhere
1615// Some values of (B,C) correspond to known cubic splines: Catmull-Rom (B=0,C=0.5), B-Spline (B=1,C=0) and other.
1616// Mitchell, Don P.; Netravali, Arun N. (Aug. 1988). "Reconstruction filters in computer graphics"
1617// http://www.mentallandscape.com/Papers_siggraph88.pdf
1618//
1619// 2. Supported border types are ippBorderRepl, ippBorderConst, ippBorderTransp and ippBorderRepl
1620*/
1621IPPAPI (IppStatus, ippiWarpPerspectiveNearestInit, (IppiSize srcSize, IppiRect srcRoi, IppiSize dstSize, IppDataType dataType,
1622 const double coeffs[3][3], IppiWarpDirection direction, int numChannels,
1623 IppiBorderType borderType, const Ipp64f *pBorderValue, int smoothEdge, IppiWarpSpec* pSpec))
1624IPPAPI (IppStatus, ippiWarpPerspectiveLinearInit, (IppiSize srcSize, IppiRect srcRoi, IppiSize dstSize, IppDataType dataType,
1625 const double coeffs[3][3], IppiWarpDirection direction, int numChannels,
1626 IppiBorderType borderType, const Ipp64f *pBorderValue, int smoothEdge, IppiWarpSpec* pSpec))
1627IPPAPI (IppStatus, ippiWarpPerspectiveCubicInit, (IppiSize srcSize, IppiRect srcRoi, IppiSize dstSize, IppDataType dataType, const double coeffs[3][3],
1628 IppiWarpDirection direction, int numChannels, Ipp64f valueB, Ipp64f valueC,
1629 IppiBorderType borderType, const Ipp64f *pBorderValue, int smoothEdge, IppiWarpSpec* pSpec,
1630 Ipp8u* pInitBuf))
1631
1632/* /////////////////////////////////////////////////////////////////////////////
1633// Name: ippiWarpPerspectiveNearest
1634// ippiWarpPerspectiveLinear
1635// ippiWarpPerspectiveCubic
1636//
1637// Purpose: Performs perspective transform of an image with using
1638// different interpolation methods
1639//
1640// Parameters:
1641// pSrc Pointer to the source image
1642// srcStep Distance (in bytes) between of consecutive lines in the source image
1643// pDst Pointer to the destination image
1644// dstStep Distance (in bytes) between of consecutive lines in the destination image
1645// dstRoiOffset Offset of tiled image respectively destination image origin
1646// dstRoiSize Size of the destination image (in pixels)
1647// border Type of the border
1648// borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
1649// pSpec Pointer to the Spec structure for resize filter
1650// pBuffer Pointer to the work buffer
1651//
1652// Return Values:
1653// ippStsNoErr Indicates no error
1654// ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
1655// ippStsNoOperation Indicates a warning if width or height of output image is zero
1656// ippStsBorderErr Indicates an error if border type has an illegal value
1657// ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
1658// ippStsNotSupportedModeErr Indicates an error if requested mode is currently not supported
1659// ippStsSizeErr Indicates an error if width or height of the destination image
1660// is negative
1661// ippStsStepErr Indicates an error if the step value is not data type multiple
1662// ippStsOutOfRangeErr Indicates an error if the destination image offset point is outside the
1663// destination image origin
1664// ippStsSizeWrn Indicates a warning if the destination image size is more than
1665// the destination image origin size
1666// ippStsWrongIntersectQuad Indicates a warning that no operation is performed if the destination
1667// ROI has no intersection with the transformed source image origin.
1668//
1669// Notes:
1670// 1. Supported border types are ippBorderRepl, ippBorderConst, ippBorderTransp and ippBorderRepl
1671*/
1672IPPAPI (IppStatus, ippiWarpPerspectiveNearest_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1673 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1674 Ipp8u* pBuffer))
1675IPPAPI (IppStatus, ippiWarpPerspectiveNearest_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1676 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1677 Ipp8u* pBuffer))
1678IPPAPI (IppStatus, ippiWarpPerspectiveNearest_8u_C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1679 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1680 Ipp8u* pBuffer))
1681IPPAPI (IppStatus, ippiWarpPerspectiveNearest_16u_C1R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1682 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1683 Ipp8u* pBuffer))
1684IPPAPI (IppStatus, ippiWarpPerspectiveNearest_16u_C3R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1685 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1686 Ipp8u* pBuffer))
1687IPPAPI (IppStatus, ippiWarpPerspectiveNearest_16u_C4R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1688 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1689 Ipp8u* pBuffer))
1690IPPAPI (IppStatus, ippiWarpPerspectiveNearest_16s_C1R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1691 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1692 Ipp8u* pBuffer))
1693IPPAPI (IppStatus, ippiWarpPerspectiveNearest_16s_C3R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1694 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1695 Ipp8u* pBuffer))
1696IPPAPI (IppStatus, ippiWarpPerspectiveNearest_16s_C4R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1697 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1698 Ipp8u* pBuffer))
1699IPPAPI (IppStatus, ippiWarpPerspectiveNearest_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1700 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1701 Ipp8u* pBuffer))
1702IPPAPI (IppStatus, ippiWarpPerspectiveNearest_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1703 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1704 Ipp8u* pBuffer))
1705IPPAPI (IppStatus, ippiWarpPerspectiveNearest_32f_C4R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1706 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1707 Ipp8u* pBuffer))
1708
1709IPPAPI (IppStatus, ippiWarpPerspectiveLinear_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1710 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1711 Ipp8u* pBuffer))
1712IPPAPI (IppStatus, ippiWarpPerspectiveLinear_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1713 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1714 Ipp8u* pBuffer))
1715IPPAPI (IppStatus, ippiWarpPerspectiveLinear_8u_C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1716 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1717 Ipp8u* pBuffer))
1718IPPAPI (IppStatus, ippiWarpPerspectiveLinear_16u_C1R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1719 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1720 Ipp8u* pBuffer))
1721IPPAPI (IppStatus, ippiWarpPerspectiveLinear_16u_C3R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1722 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1723 Ipp8u* pBuffer))
1724IPPAPI (IppStatus, ippiWarpPerspectiveLinear_16u_C4R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1725 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1726 Ipp8u* pBuffer))
1727IPPAPI (IppStatus, ippiWarpPerspectiveLinear_16s_C1R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1728 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1729 Ipp8u* pBuffer))
1730IPPAPI (IppStatus, ippiWarpPerspectiveLinear_16s_C3R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1731 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1732 Ipp8u* pBuffer))
1733IPPAPI (IppStatus, ippiWarpPerspectiveLinear_16s_C4R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1734 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1735 Ipp8u* pBuffer))
1736IPPAPI (IppStatus, ippiWarpPerspectiveLinear_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1737 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1738 Ipp8u* pBuffer))
1739IPPAPI (IppStatus, ippiWarpPerspectiveLinear_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1740 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1741 Ipp8u* pBuffer))
1742IPPAPI (IppStatus, ippiWarpPerspectiveLinear_32f_C4R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1743 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1744 Ipp8u* pBuffer))
1745
1746IPPAPI (IppStatus, ippiWarpPerspectiveCubic_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1747 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1748 Ipp8u* pBuffer))
1749IPPAPI (IppStatus, ippiWarpPerspectiveCubic_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1750 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1751 Ipp8u* pBuffer))
1752IPPAPI (IppStatus, ippiWarpPerspectiveCubic_8u_C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1753 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1754 Ipp8u* pBuffer))
1755IPPAPI (IppStatus, ippiWarpPerspectiveCubic_16u_C1R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1756 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1757 Ipp8u* pBuffer))
1758IPPAPI (IppStatus, ippiWarpPerspectiveCubic_16u_C3R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1759 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1760 Ipp8u* pBuffer))
1761IPPAPI (IppStatus, ippiWarpPerspectiveCubic_16u_C4R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
1762 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1763 Ipp8u* pBuffer))
1764IPPAPI (IppStatus, ippiWarpPerspectiveCubic_16s_C1R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1765 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1766 Ipp8u* pBuffer))
1767IPPAPI (IppStatus, ippiWarpPerspectiveCubic_16s_C3R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1768 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1769 Ipp8u* pBuffer))
1770IPPAPI (IppStatus, ippiWarpPerspectiveCubic_16s_C4R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
1771 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1772 Ipp8u* pBuffer))
1773IPPAPI (IppStatus, ippiWarpPerspectiveCubic_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1774 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1775 Ipp8u* pBuffer))
1776IPPAPI (IppStatus, ippiWarpPerspectiveCubic_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1777 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1778 Ipp8u* pBuffer))
1779IPPAPI (IppStatus, ippiWarpPerspectiveCubic_32f_C4R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
1780 IppiPoint dstRoiOffset, IppiSize dstRoiSize, const IppiWarpSpec* pSpec,
1781 Ipp8u* pBuffer))
1782
1783
1784/* /////////////////////////////////////////////////////////////////////////////
1785// Alpha Compositing Operations
1786///////////////////////////////////////////////////////////////////////////// */
1787/*
1788// Contents:
1789// ippiAlphaPremul_8u_AC4R, ippiAlphaPremul_16u_AC4R
1790// ippiAlphaPremul_8u_AC4IR, ippiAlphaPremul_16u_AC4IR
1791// ippiAlphaPremul_8u_AP4R, ippiAlphaPremul_16u_AP4R
1792// ippiAlphaPremul_8u_AP4IR, ippiAlphaPremul_16u_AP4IR
1793// Pre-multiplies pixel values of an image by its alpha values.
1794
1795// ippiAlphaPremulC_8u_AC4R, ippiAlphaPremulC_16u_AC4R
1796// ippiAlphaPremulC_8u_AC4IR, ippiAlphaPremulC_16u_AC4IR
1797// ippiAlphaPremulC_8u_AP4R, ippiAlphaPremulC_16u_AP4R
1798// ippiAlphaPremulC_8u_AP4IR, ippiAlphaPremulC_16u_AP4IR
1799// ippiAlphaPremulC_8u_C4R, ippiAlphaPremulC_16u_C4R
1800// ippiAlphaPremulC_8u_C4IR, ippiAlphaPremulC_16u_C4IR
1801// ippiAlphaPremulC_8u_C3R, ippiAlphaPremulC_16u_C3R
1802// ippiAlphaPremulC_8u_C3IR, ippiAlphaPremulC_16u_C3IR
1803// ippiAlphaPremulC_8u_C1R, ippiAlphaPremulC_16u_C1R
1804// ippiAlphaPremulC_8u_C1IR, ippiAlphaPremulC_16u_C1IR
1805// Pre-multiplies pixel values of an image by constant alpha values.
1806//
1807// ippiAlphaComp_8u_AC4R, ippiAlphaComp_16u_AC4R
1808// ippiAlphaComp_8u_AC1R, ippiAlphaComp_16u_AC1R
1809// Combines two images using alpha values of both images
1810//
1811// ippiAlphaCompC_8u_AC4R, ippiAlphaCompC_16u_AC4R
1812// ippiAlphaCompC_8u_AP4R, ippiAlphaCompC_16u_AP4R
1813// ippiAlphaCompC_8u_C4R, ippiAlphaCompC_16u_C4R
1814// ippiAlphaCompC_8u_C3R, ippiAlphaCompC_16u_C3R
1815// ippiAlphaCompC_8u_C1R, ippiAlphaCompC_16u_C1R
1816// Combines two images using constant alpha values
1817//
1818// Types of compositing operation (alphaType)
1819// OVER ippAlphaOver ippAlphaOverPremul
1820// IN ippAlphaIn ippAlphaInPremul
1821// OUT ippAlphaOut ippAlphaOutPremul
1822// ATOP ippAlphaATop ippAlphaATopPremul
1823// XOR ippAlphaXor ippAlphaXorPremul
1824// PLUS ippAlphaPlus ippAlphaPlusPremul
1825//
1826// Type result pixel result pixel (Premul) result alpha
1827// OVER aA*A+(1-aA)*aB*B A+(1-aA)*B aA+(1-aA)*aB
1828// IN aA*A*aB A*aB aA*aB
1829// OUT aA*A*(1-aB) A*(1-aB) aA*(1-aB)
1830// ATOP aA*A*aB+(1-aA)*aB*B A*aB+(1-aA)*B aA*aB+(1-aA)*aB
1831// XOR aA*A*(1-aB)+(1-aA)*aB*B A*(1-aB)+(1-aA)*B aA*(1-aB)+(1-aA)*aB
1832// PLUS aA*A+aB*B A+B aA+aB
1833// Here 1 corresponds significance VAL_MAX, multiplication is performed
1834// with scaling
1835// X * Y => (X * Y) / VAL_MAX
1836// and VAL_MAX is the maximum presentable pixel value:
1837// VAL_MAX == IPP_MAX_8U for 8u
1838// VAL_MAX == IPP_MAX_16U for 16u
1839*/
1840
1841/* /////////////////////////////////////////////////////////////////////////////
1842// Name: ippiAlphaPremul_8u_AC4R, ippiAlphaPremul_16u_AC4R
1843// ippiAlphaPremul_8u_AC4IR, ippiAlphaPremul_16u_AC4IR
1844// ippiAlphaPremul_8u_AP4R, ippiAlphaPremul_16u_AP4R
1845// ippiAlphaPremul_8u_AP4IR, ippiAlphaPremul_16u_AP4IR
1846//
1847// Purpose: Pre-multiplies pixel values of an image by its alpha values
1848// for 4-channel images
1849// For channels 1-3
1850// dst_pixel = (src_pixel * src_alpha) / VAL_MAX
1851// For alpha-channel (channel 4)
1852// dst_alpha = src_alpha
1853// Parameters:
1854// pSrc Pointer to the source image for pixel-order data,
1855// array of pointers to separate source color planes for planar data
1856// srcStep Step through the source image
1857// pDst Pointer to the destination image for pixel-order data,
1858// array of pointers to separate destination color planes for planar data
1859// dstStep Step through the destination image
1860// pSrcDst Pointer to the source/destination image, or array of pointers
1861// to separate source/destination color planes for in-place functions
1862// srcDstStep Step through the source/destination image for in-place functions
1863// roiSize Size of the source and destination ROI
1864// Returns:
1865// ippStsNoErr No errors
1866// ippStsNullPtrErr pSrc == NULL, or pDst == NULL, or pSrcDst == NULL
1867// ippStsSizeErr The roiSize has a field with negative or zero value
1868*/
1869
1870IPPAPI (IppStatus, ippiAlphaPremul_8u_AC4R,
1871 ( const Ipp8u* pSrc, int srcStep,
1872 Ipp8u* pDst, int dstStep,
1873 IppiSize roiSize ))
1874
1875
1876/* ////////////////////////////////////////////////////////////////////////////
1877// Names: ippiLUTPalette
1878// Purpose: intensity transformation of image using the palette lookup table pTable
1879// Parameters:
1880// pSrc pointer to the source image
1881// srcStep line offset in input data in bytes
1882// alphaValue constant alpha channel
1883// pDst pointer to the destination image
1884// dstStep line offset in output data in bytes
1885// roiSize size of source ROI in pixels
1886// pTable pointer to palette table of size 2^nBitSize or
1887// array of pointers to each channel
1888// nBitSize number of valid bits in the source image
1889// (range [1,8] for 8u source images and range [1,16] for 16u source images)
1890// Returns:
1891// ippStsNoErr no errors
1892// ippStsNullPtrErr pSrc == NULL or pDst == NULL or pTable == NULL
1893// ippStsSizeErr width or height of ROI is less or equal zero
1894// ippStsOutOfRangeErr nBitSize is out of range
1895// Notes:
1896*/
1897IPPAPI(IppStatus, ippiLUTPalette_8u32u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp32u* pDst, int dstStep,
1898 IppiSize roiSize, const Ipp32u* pTable, int nBitSize))
1899IPPAPI(IppStatus, ippiLUTPalette_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
1900 IppiSize roiSize, const Ipp8u* pTable, int nBitSize))
1901
1902
1903/* /////////////////////////////////////////////////////////////////////////////
1904// Name: ippiCountInRange
1905//
1906// Purpose: Computes the number of pixels with intensity values within the given range
1907//
1908// Returns: IppStatus
1909// ippStsNoErr No errors
1910// ippStsNullPtrErr pSrc == NULL
1911// ippStsStepErr srcStep is less than or equal to zero
1912// ippStsSizeErr roiSize has a field with zero or negative value
1913// ippStsRangeErr lowerBound is greater than upperBound
1914//
1915// Parameters:
1916// pSrc Pointer to the source buffer
1917// roiSize Size of the source ROI
1918// srcStep Step through the source image buffer
1919// counts Number of pixels within the given intensity range
1920// lowerBound Lower limit of the range
1921// upperBound Upper limit of the range
1922*/
1923
1924IPPAPI(IppStatus, ippiCountInRange_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize,
1925 int* counts, Ipp8u lowerBound, Ipp8u upperBound))
1926IPPAPI(IppStatus, ippiCountInRange_32f_C1R, (const Ipp32f* pSrc, int srcStep, IppiSize roiSize,
1927 int* counts, Ipp32f lowerBound, Ipp32f upperBound))
1928
1929
1930/* ////////////////////////////////////////////////////////////////////////////////////
1931// Name: ippiAdd_32f_C1IR, ippiAdd_32f_C3IR, ippiAdd_32f_C4IR, ippiAdd_32f_AC4IR,
1932// ippiSub_32f_C1IR, ippiSub_32f_C3IR, ippiSub_32f_C4IR, ippiSub_32f_AC4IR,
1933// ippiMul_32f_C1IR, ippiMul_32f_C3IR, ippiMul_32f_C4IR, ippiMul_32f_AC4IR
1934//
1935// Purpose: Adds, subtracts, or multiplies pixel values of two source images
1936// and places the results in the first image.
1937//
1938// Returns:
1939// ippStsNoErr OK
1940// ippStsNullPtrErr One of the pointers is NULL
1941// ippStsSizeErr Width or height of images is less than or equal to zero
1942//
1943// Parameters:
1944// pSrc Pointer to the second source image
1945// srcStep Step through the second source image
1946// pSrcDst Pointer to the first source/destination image
1947// srcDstStep Step through the first source/destination image
1948// roiSize Size of the ROI
1949*/
1950
1951IPPAPI(IppStatus, ippiAdd_32f_C1IR, (const Ipp32f* pSrc, int srcStep, Ipp32f* pSrcDst,
1952 int srcDstStep, IppiSize roiSize))
1953
1954
1955
1956/* //////////////////////////////////////////////////////////////////////////////////////////////
1957// Name: ippiAddC_8u_C1IRSfs, ippiAddC_8u_C3IRSfs, ippiAddC_8u_C4IRSfs, ippiAddC_8u_AC4IRSfs,
1958// ippiAddC_16s_C1IRSfs, ippiAddC_16s_C3IRSfs, ippiAddC_16s_C4IRSfs, ippiAddC_16s_AC4IRSfs,
1959// ippiAddC_16u_C1IRSfs, ippiAddC_16u_C3IRSfs, ippiAddC_16u_C4IRSfs, ippiAddC_16u_AC4IRSfs,
1960// ippiSubC_8u_C1IRSfs, ippiSubC_8u_C3IRSfs, ippiSubC_8u_C4IRSfs, ippiSubC_8u_AC4IRSfs,
1961// ippiSubC_16s_C1IRSfs, ippiSubC_16s_C3IRSfs, ippiSubC_16s_C4IRSfs, ippiSubC_16s_AC4IRSfs,
1962// ippiSubC_16u_C1IRSfs, ippiSubC_16u_C3IRSfs, ippiSubC_16u_C4IRSfs, ippiSubC_16u_AC4IRSfs,
1963// ippiMulC_8u_C1IRSfs, ippiMulC_8u_C3IRSfs, ippiMulC_8u_C4IRSfs, ippiMulC_8u_AC4IRSfs,
1964// ippiMulC_16s_C1IRSfs, ippiMulC_16s_C3IRSfs, ippiMulC_16s_C4IRSfs, ippiMulC_16s_AC4IRSfs
1965// ippiMulC_16u_C1IRSfs, ippiMulC_16u_C3IRSfs, ippiMulC_16u_C4IRSfs, ippiMulC_16u_AC4IRSfs
1966//
1967// Purpose: Adds, subtracts, or multiplies pixel values of an image and a constant
1968// and places the scaled results in the same image.
1969//
1970// Returns:
1971// ippStsNoErr OK
1972// ippStsNullPtrErr Pointer is NULL
1973// ippStsSizeErr Width or height of an image is less than or equal to zero
1974//
1975// Parameters:
1976// value Constant value (constant vector for multi-channel images)
1977// pSrcDst Pointer to the image
1978// srcDstStep Step through the image
1979// roiSize Size of the ROI
1980// scaleFactor Scale factor
1981*/
1982
1983IPPAPI(IppStatus, ippiAddC_16s_C1IRSfs, (Ipp16s value, Ipp16s* pSrcDst, int srcDstStep,
1984 IppiSize roiSize, int scaleFactor))
1985
1986IPPAPI(IppStatus, ippiAddC_32f_C1IR, (Ipp32f value, Ipp32f* pSrcDst, int srcDstStep,
1987 IppiSize roiSize))
1988
1989IPPAPI(IppStatus, ippiAddC_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f value, Ipp32f* pDst,
1990 int dstStep, IppiSize roiSize))
1991
1992IPPAPI(IppStatus, ippiMulC_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f value, Ipp32f* pDst,
1993 int dstStep, IppiSize roiSize))
1994
1995
1996/* ///////////////////////////////////////////////////////////////////////////
1997// Filters with Fixed Kernel
1998/////////////////////////////////////////////////////////////////////////// */
1999/* ////////////////////////////////////////////////////////////////////////////
2000// Kernels:
2001//
2002// 1 1 1
2003// PrewittHoriz 0 0 0
2004// -1 -1 -1
2005//
2006//
2007// -1 0 1
2008// PrewittVert -1 0 1
2009// -1 0 1
2010//
2011//
2012// 1 2 1
2013// SobelHoriz 0 0 0
2014// -1 -2 -1
2015//
2016//
2017// -1 0 1
2018// SobelVert -2 0 2
2019// -1 0 1
2020//
2021//
2022// 0 0 0
2023// RobetsDown 0 1 0
2024// 0 0 -1
2025//
2026//
2027// 0 0 0
2028// RobertsUp 0 1 0
2029// -1 0 0
2030//
2031//
2032// -1 -1 1
2033// Sharpen -1 16 1 X 1/8
2034// -1 -1 1
2035//
2036//
2037// 3 0 -3
2038// ScharrVert 10 0 -10
2039// 3 0 -3
2040//
2041//
2042// 3 10 3
2043// ScharrHoriz 0 0 0
2044// -3 -10 -3
2045//
2046//
2047// -1 -1 1
2048// Laplace (3x3) -1 8 1
2049// -1 -1 1
2050//
2051//
2052// 1 2 1
2053// Gauss (3x3) 2 4 2 X 1/16
2054// 1 2 1
2055//
2056//
2057// 1 1 1
2058// Lowpass (3x3) 1 1 1 X 1/9
2059// 1 1 1
2060//
2061//
2062// -1 -1 -1
2063// Hipass (3x3 ) -1 8 -1
2064// -1 -1 -1
2065//
2066//
2067// -1 0 1
2068// SobelVert (3x3) -2 0 2
2069// -1 0 1
2070//
2071//
2072// 1 2 1
2073// SobelHoriz (3x3) 0 0 0
2074// -1 -2 -1
2075//
2076//
2077// 1 -2 1
2078// SobelVertSecond (3x3) 2 -4 2
2079// 1 -2 1
2080//
2081//
2082// 1 2 1
2083// SobelHorizSecond (3x3) -2 -4 -2
2084// 1 2 1
2085//
2086//
2087// -1 0 1
2088// SobelCross (3x3) 0 0 0
2089// 1 0 -1
2090//
2091//
2092// -1 -3 -4 -3 -1
2093// -3 0 6 0 -3
2094// Laplace (5x5) -4 6 20 6 -4
2095// -3 0 6 0 -3
2096// -1 -3 -4 -3 -1
2097//
2098// 2 7 12 7 2
2099// 7 31 52 31 7
2100// Gauss (5x5) 12 52 127 52 12 X 1/571
2101// 7 31 52 31 7
2102// 2 7 12 7 2
2103//
2104// 1 1 1 1 1
2105// 1 1 1 1 1
2106// Lowpass (5x5) 1 1 1 1 1 X 1/25
2107// 1 1 1 1 1
2108// 1 1 1 1 1
2109//
2110//
2111// -1 -1 -1 -1 -1
2112// -1 -1 -1 -1 -1
2113// Hipass (5x5) -1 -1 24 -1 -1
2114// -1 -1 -1 -1 -1
2115// -1 -1 -1 -1 -1
2116//
2117// -1 -2 0 2 1
2118// -4 -8 0 8 4
2119// SobelVert (5x5) -6 -12 0 12 6
2120// -4 -8 0 8 4
2121// -1 -2 0 2 1
2122//
2123// 1 4 6 4 1
2124// 2 8 12 8 2
2125// SobelHoriz (5x5) 0 0 0 0 0
2126// -2 -8 -12 -8 -4
2127// -1 -4 -6 -4 -1
2128//
2129// 1 0 -2 0 1
2130// 4 0 -8 0 4
2131// SobelVertSecond (5x5) 6 0 -12 0 6
2132// 4 0 -8 0 4
2133// 1 0 -2 0 1
2134//
2135// 1 4 6 4 1
2136// 0 0 0 0 0
2137// SobelHorizSecond (5x5) -2 -8 -12 -8 -2
2138// 0 0 0 0 0
2139// 1 4 6 4 1
2140//
2141// -1 -2 0 2 1
2142// -2 -4 0 4 2
2143// SobelCross (5x5) 0 0 0 0 0
2144// 2 4 0 -4 -2
2145// 1 2 0 -2 -1
2146//
2147*/
2148
2149/* /////////////////////////////////////////////////////////////////////////////
2150// Name: ippiFilterSobelHorizBorderGetBufferSize
2151// ippiFilterSobelVertBorderGetBufferSize
2152// ippiFilterScharrHorizMaskBorderGetBufferSize
2153// ippiFilterScharrVertMaskBorderGetBufferSize
2154// ippiFilterPrewittHorizBorderGetBufferSize
2155// ippiFilterPrewittVertBorderGetBufferSize
2156// ippiFilterRobertsDownBorderGetBufferSize
2157// ippiFilterRobertsUpBorderGetBufferSize
2158// ippiFilterSobelHorizSecondBorderGetBufferSize
2159// ippiFilterSobelVertSecondBorderGetBufferSize
2160// ippiFilterSobelNegVertBorderGetBufferSize
2161//
2162// Purpose: Computes the size of the external buffer for fixed filter with border
2163//
2164// Parameters:
2165// roiSize Size of destination ROI in pixels.
2166// mask Predefined mask of IppiMaskSize type.
2167// srcDataType Data type of the source image.
2168// dstDataType Data type of the destination image.
2169// numChannels Number of channels in the images.
2170// pBufferSize Pointer to the size (in bytes) of the external work buffer.
2171//
2172// Return Values:
2173// ippStsNoErr Indicates no error.
2174// ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
2175// ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
2176// ippStsMaskSizeErr Indicates an error condition if mask has a wrong value.
2177// ippStsDataTypeErr Indicates an error when srcDataType or dstDataType has an illegal value.
2178// ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
2179*/
2180IPPAPI(IppStatus, ippiFilterSobelHorizBorderGetBufferSize,(IppiSize dstRoiSize, IppiMaskSize mask,
2181 IppDataType srcDataType, IppDataType dstDataType, int numChannels, int* pBufferSize))
2182IPPAPI(IppStatus, ippiFilterSobelVertBorderGetBufferSize,(IppiSize dstRoiSize, IppiMaskSize mask,
2183 IppDataType srcDataType, IppDataType dstDataType, int numChannels, int* pBufferSize))
2184IPPAPI(IppStatus, ippiFilterScharrHorizMaskBorderGetBufferSize,(IppiSize dstRoiSize, IppiMaskSize mask,
2185 IppDataType srcDataType, IppDataType dstDataType, int numChannels, int* pBufferSize))
2186IPPAPI(IppStatus, ippiFilterScharrVertMaskBorderGetBufferSize,(IppiSize dstRoiSize, IppiMaskSize mask,
2187 IppDataType srcDataType, IppDataType dstDataType, int numChannels, int* pBufferSize))
2188IPPAPI(IppStatus, ippiFilterSobelHorizSecondBorderGetBufferSize,(IppiSize dstRoiSize, IppiMaskSize mask,
2189 IppDataType srcDataType, IppDataType dstDataType, int numChannels, int* pBufferSize))
2190IPPAPI(IppStatus, ippiFilterSobelVertSecondBorderGetBufferSize,(IppiSize dstRoiSize, IppiMaskSize mask,
2191 IppDataType srcDataType, IppDataType dstDataType, int numChannels, int* pBufferSize))
2192IPPAPI(IppStatus, ippiFilterSobelNegVertBorderGetBufferSize,(IppiSize dstRoiSize, IppiMaskSize mask,
2193 IppDataType srcDataType, IppDataType dstDataType, int numChannels, int* pBufferSize))
2194
2195
2196/* /////////////////////////////////////////////////////////////////////////////
2197// Name: ippiFilterSobelVertBorder_8u16s_C1R
2198// ippiFilterSobelHorizBorder_8u16s_C1R
2199// ippiFilterScharrVertMaskBorder_8u16s_C1R
2200// ippiFilterScharrHorizMaskBorder_8u16s_C1R
2201// ippiFilterPrewittVertBorder_8u16s_C1R
2202// ippiFilterPrewittHorizBorder_8u16s_C1R
2203// ippiFilterRobertsDownBorder_8u16s_C1R
2204// ippiFilterRobertsUpBorder_8u16s_C1R
2205// ippiFilterSobelVertSecondBorder_8u16s_C1R
2206// ippiFilterSobelHorizSecondBorder_8u16s_C1R
2207// ippiFilterSobelNegVertBorder_8u16s_C1R
2208// ippiFilterSobelVertBorder_16s_C1R
2209// ippiFilterSobelHorizBorder_16s_C1R
2210// ippiFilterScharrVertMaskBorder_16s_C1R
2211// ippiFilterScharrHorizMaskBorder_16s_C1R
2212// ippiFilterPrewittVertBorder_16s_C1R
2213// ippiFilterPrewittHorizBorder_16s_C1R
2214// ippiFilterRobertsDownBorder_16s_C1R
2215// ippiFilterRobertsUpBorder_16s_C1R
2216// ippiFilterSobelVertBorder_32f_C1R
2217// ippiFilterSobelHorizBorder_32f_C1R
2218// ippiFilterScharrVertMaskBorder_32f_C1R
2219// ippiFilterScharrHorizMaskBorder_32f_C1R
2220// ippiFilterPrewittVertBorder_32f_C1R
2221// ippiFilterPrewittHorizBorder_32f_C1R
2222// ippiFilterRobertsDownBorder_32f_C1R
2223// ippiFilterRobertsUpBorder_32f_C1R
2224// ippiFilterSobelVertSecondBorder_32f_C1R
2225// ippiFilterSobelHorizSecondBorder_32f_C1R
2226// ippiFilterSobelNegVertBorder_32f_C1R
2227// ippiFilterLaplaceBorder_8u_C1R
2228// ippiFilterLaplaceBorder_8u_C3R
2229// ippiFilterLaplaceBorder_8u_C4R
2230// ippiFilterLaplaceBorder_8u_AC4R
2231// ippiFilterLaplaceBorder_16s_C1R
2232// ippiFilterLaplaceBorder_16s_C3R
2233// ippiFilterLaplaceBorder_16s_C4R
2234// ippiFilterLaplaceBorder_16s_AC4R
2235// ippiFilterLaplaceBorder_32f_C1R
2236// ippiFilterLaplaceBorder_32f_C3R
2237// ippiFilterLaplaceBorder_32f_C4R
2238// ippiFilterLaplaceBorder_32f_AC4R
2239// ippiFilterHipassBorder_8u_C1R
2240// ippiFilterHipassBorder_8u_C3R
2241// ippiFilterHipassBorder_8u_C4R
2242// ippiFilterHipassBorder_8u_AC4R
2243// ippiFilterHipassBorder_16s_C1R
2244// ippiFilterHipassBorder_16s_C3R
2245// ippiFilterHipassBorder_16s_C4R
2246// ippiFilterHipassBorder_16s_AC4R
2247// ippiFilterHipassBorder_32f_C1R
2248// ippiFilterHipassBorder_32f_C3R
2249// ippiFilterHipassBorder_32f_C4R
2250// ippiFilterHipassBorder_32f_AC4R
2251// ippiFilterSharpenBorder_8u_C1R
2252// ippiFilterSharpenBorder_8u_C3R
2253// ippiFilterSharpenBorder_8u_C4R
2254// ippiFilterSharpenBorder_8u_AC4R
2255// ippiFilterSharpenBorder_16s_C1R
2256// ippiFilterSharpenBorder_16s_C3R
2257// ippiFilterSharpenBorder_16s_C4R
2258// ippiFilterSharpenBorder_16s_AC4R
2259// ippiFilterSharpenBorder_32f_C1R
2260// ippiFilterSharpenBorder_32f_C3R
2261// ippiFilterSharpenBorder_32f_C4R
2262// ippiFilterSharpenBorder_32f_AC4R
2263
2264//
2265// Purpose: Perform linear filtering of an image using one of
2266// predefined convolution kernels.
2267//
2268// Parameters:
2269// pSrc Pointer to the source image ROI.
2270// srcStep Distance in bytes between starting points of consecutive lines in the sorce image.
2271// pDst Pointer to the destination image ROI.
2272// dstStep Distance in bytes between starting points of consecutive lines in the destination image.
2273// dstRoiSize Size of destination ROI in pixels.
2274// mask Predefined mask of IppiMaskSize type.
2275// borderType Type of border.
2276// borderValue Constant value to assign to pixels of the constant border. This parameter is applicable
2277// only to the ippBorderConst border type.
2278// pBorderValue The pointer to constant values to assign to pixels of the constant border. This parameter is applicable
2279// only to the ippBorderConst border type.
2280// pBuffer Pointer to the work buffer.
2281//
2282// Return Values:
2283// ippStsNoErr Indicates no error.
2284// ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
2285// ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
2286// ippStsNotEvenStepErr Indicated an error when one of the step values is not divisible by 4
2287// for floating-point images, or by 2 for short-integer images.
2288// ippStsBorderErr Indicates an error when borderType has illegal value.
2289*/
2290IPPAPI(IppStatus, ippiFilterSobelVertBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
2291 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2292 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
2293IPPAPI(IppStatus, ippiFilterSobelHorizBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
2294 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2295 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
2296IPPAPI(IppStatus, ippiFilterScharrVertMaskBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
2297 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2298 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
2299IPPAPI(IppStatus, ippiFilterScharrHorizMaskBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
2300 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2301 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
2302IPPAPI(IppStatus, ippiFilterSobelVertSecondBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
2303 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2304 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
2305IPPAPI(IppStatus, ippiFilterSobelHorizSecondBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
2306 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2307 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
2308IPPAPI(IppStatus, ippiFilterSobelNegVertBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
2309 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2310 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
2311
2312IPPAPI(IppStatus, ippiFilterSobelVertBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
2313 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2314 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
2315IPPAPI(IppStatus, ippiFilterSobelHorizBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
2316 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2317 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
2318IPPAPI(IppStatus, ippiFilterScharrVertMaskBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
2319 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2320 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
2321IPPAPI(IppStatus, ippiFilterScharrHorizMaskBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
2322 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2323 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
2324IPPAPI(IppStatus, ippiFilterSobelVertSecondBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
2325 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2326 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
2327IPPAPI(IppStatus, ippiFilterSobelHorizSecondBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
2328 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2329 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
2330IPPAPI(IppStatus, ippiFilterSobelNegVertBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
2331 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2332 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
2333
2334IPPAPI(IppStatus, ippiFilterSobelVertBorder_16s_C1R, (const Ipp16s* pSrc, int srcStep,
2335 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2336 IppiBorderType borderType, Ipp16s borderValue, Ipp8u* pBuffer))
2337IPPAPI(IppStatus, ippiFilterSobelHorizBorder_16s_C1R, (const Ipp16s* pSrc, int srcStep,
2338 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2339 IppiBorderType borderType, Ipp16s borderValue, Ipp8u* pBuffer))
2340IPPAPI(IppStatus, ippiFilterScharrVertMaskBorder_16s_C1R, (const Ipp16s* pSrc, int srcStep,
2341 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2342 IppiBorderType borderType, Ipp16s borderValue, Ipp8u* pBuffer))
2343IPPAPI(IppStatus, ippiFilterScharrHorizMaskBorder_16s_C1R, (const Ipp16s* pSrc, int srcStep,
2344 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiMaskSize mask,
2345 IppiBorderType borderType, Ipp16s borderValue, Ipp8u* pBuffer))
2346
2347
2348/* /////////////////////////////////////////////////////////////////////////////
2349// Statistic functions
2350///////////////////////////////////////////////////////////////////////////// */
2351
2352/* /////////////////////////////////////////////////////////////////////////////
2353// Name: ippiMomentGetStateSize_64s
2354// ippiMomentGetStateSize_64f
2355//
2356// Purpose: Computes the size of the external buffer for the state
2357// structure ippiMomentsState_64s in bytes
2358//
2359// Returns:
2360// ippStsNoErr OK
2361// ippStsNullPtrErr pSize==NULL
2362// Parameters:
2363// hint Option to specify the computation algorithm
2364// pSize Pointer to the value of the buffer size
2365// of the structure ippiMomentState_64s.
2366*/
2367IPPAPI(IppStatus, ippiMomentGetStateSize_64f, (IppHintAlgorithm hint, int * pSize))
2368
2369
2370/* ////////////////////////////////////////////////////////////////////////////////////
2371// Name: ippiMomentInit64s
2372// ippiMomentInit64f
2373//
2374// Purpose: Initializes ippiMomentState_64s structure (without memory allocation)
2375//
2376// Returns:
2377// ippStsNoErr No errors
2378//
2379// Parameters:
2380// pState Pointer to the MomentState structure
2381// hint Option to specify the computation algorithm
2382*/
2383IPPAPI (IppStatus, ippiMomentInit_64f, (IppiMomentState_64f* pState, IppHintAlgorithm hint))
2384
2385
2386/* /////////////////////////////////////////////////////////////////////////////
2387// Name: ippiMoments
2388//
2389// Purpose: Computes statistical moments of an image
2390//
2391// Returns:
2392// ippStsContextMatchErr pState->idCtx != idCtxMoment
2393// ippStsNullPtrErr (pSrc == NULL) or (pState == NULL)
2394// ippStsStepErr pSrcStep <0
2395// ippStsSizeErr (roiSize.width <1) or (roiSize.height <1)
2396// ippStsNoErr No errors
2397//
2398// Parameters:
2399// pSrc Pointer to the source image
2400// srcStep Step in bytes through the source image
2401// roiSize Size of the source ROI
2402// pState Pointer to the MomentState structure
2403//
2404// Notes:
2405// These functions compute moments of order 0 to 3 only
2406//
2407*/
2408IPPAPI(IppStatus,ippiMoments64f_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize, IppiMomentState_64f* pCtx))
2409IPPAPI(IppStatus,ippiMoments64f_8u_C3R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize, IppiMomentState_64f* pCtx))
2410IPPAPI(IppStatus,ippiMoments64f_8u_AC4R,(const Ipp8u* pSrc, int srcStep, IppiSize roiSize, IppiMomentState_64f* pCtx))
2411
2412IPPAPI(IppStatus,ippiMoments64f_32f_C1R, (const Ipp32f* pSrc, int srcStep, IppiSize roiSize, IppiMomentState_64f* pCtx))
2413IPPAPI(IppStatus,ippiMoments64f_32f_C3R, (const Ipp32f* pSrc, int srcStep, IppiSize roiSize, IppiMomentState_64f* pCtx))
2414IPPAPI(IppStatus,ippiMoments64f_32f_AC4R,(const Ipp32f* pSrc, int srcStep, IppiSize roiSize, IppiMomentState_64f* pCtx))
2415
2416IPPAPI(IppStatus,ippiMoments64f_16u_C1R, (const Ipp16u* pSrc, int srcStep, IppiSize roiSize, IppiMomentState_64f* pCtx))
2417IPPAPI(IppStatus,ippiMoments64f_16u_C3R, (const Ipp16u* pSrc, int srcStep, IppiSize roiSize, IppiMomentState_64f* pCtx))
2418IPPAPI(IppStatus,ippiMoments64f_16u_AC4R,(const Ipp16u* pSrc, int srcStep, IppiSize roiSize, IppiMomentState_64f* pCtx))
2419
2420
2421/* /////////////////////////////////////////////////////////////////////////////
2422// Name: ippiGetSpatialMoment()
2423// ippiGetCentralMoment()
2424//
2425// Purpose: Retrieves the value of the image spatial/central moment.
2426//
2427// Returns:
2428// ippStsNullPtrErr (pState == NULL) or (pValue == NULL)
2429// ippStsContextMatchErr pState->idCtx != idCtxMoment
2430// ippStsSizeErr (mOrd+nOrd) >3 or
2431// (nChannel<0) or (nChannel>=pState->nChannelInUse)
2432// ippStsNoErr No errors
2433//
2434// Parameters:
2435// pState Pointer to the MomentState structure
2436// mOrd m- Order (X direction)
2437// nOrd n- Order (Y direction)
2438// nChannel Channel number
2439// roiOffset Offset of the ROI origin (ippiGetSpatialMoment ONLY!)
2440// pValue Pointer to the retrieved moment value
2441// scaleFactor Factor to scale the moment value (for integer data)
2442//
2443// NOTE:
2444// ippiGetSpatialMoment uses Absolute Coordinates (left-top image has 0,0).
2445//
2446*/
2447IPPAPI(IppStatus,ippiGetSpatialMoment_64f,(const IppiMomentState_64f* pState,
2448 int mOrd, int nOrd, int nChannel,
2449 IppiPoint roiOffset, Ipp64f* pValue))
2450IPPAPI(IppStatus,ippiGetCentralMoment_64f,(const IppiMomentState_64f* pState,
2451 int mOrd, int nOrd, int nChannel,
2452 Ipp64f* pValue))
2453
2454
2455/* /////////////////////////////////////////////////////////////////////////////
2456// Name: ippiGetNormalizedSpatialMoment()
2457// ippiGetNormalizedCentralMoment()
2458//
2459// Purpose: Retrieves the normalized value of the image spatial/central moment.
2460//
2461// Returns:
2462// ippStsNullPtrErr (pState == NULL) or (pValue == NULL)
2463// ippStsContextMatchErr pState->idCtx != idCtxMoment
2464// ippStsSizeErr (mOrd+nOrd) >3 or
2465// (nChannel<0) or (nChannel>=pState->nChannelInUse)
2466// ippStsMoment00ZeroErr mm[0][0] < IPP_EPS52
2467// ippStsNoErr No errors
2468//
2469// Parameters:
2470// pState Pointer to the MomentState structure
2471// mOrd m- Order (X direction)
2472// nOrd n- Order (Y direction)
2473// nChannel Channel number
2474// roiOffset Offset of the ROI origin (ippiGetSpatialMoment ONLY!)
2475// pValue Pointer to the normalized moment value
2476// scaleFactor Factor to scale the moment value (for integer data)
2477//
2478*/
2479IPPAPI(IppStatus,ippiGetNormalizedSpatialMoment_64f,(const IppiMomentState_64f* pState,
2480 int mOrd, int nOrd, int nChannel,
2481 IppiPoint roiOffset, Ipp64f* pValue))
2482IPPAPI(IppStatus,ippiGetNormalizedCentralMoment_64f,(const IppiMomentState_64f* pState,
2483 int mOrd, int nOrd, int nChannel,
2484 Ipp64f* pValue))
2485
2486
2487/* /////////////////////////////////////////////////////////////////////////////
2488// Name: ippiGetHuMoments()
2489//
2490// Purpose: Retrieves image Hu moment invariants.
2491//
2492// Returns:
2493// ippStsNullPtrErr (pState == NULL) or (pHu == NULL)
2494// ippStsContextMatchErr pState->idCtx != idCtxMoment
2495// ippStsSizeErr (nChannel<0) or (nChannel>=pState->nChannelInUse)
2496// ippStsMoment00ZeroErr mm[0][0] < IPP_EPS52
2497// ippStsNoErr No errors
2498//
2499// Parameters:
2500// pState Pointer to the MomentState structure
2501// nChannel Channel number
2502// pHm Pointer to the array of the Hu moment invariants
2503// scaleFactor Factor to scale the moment value (for integer data)
2504//
2505// Notes:
2506// We consider Hu moments up to the 7-th order only
2507*/
2508IPPAPI(IppStatus,ippiGetHuMoments_64f,(const IppiMomentState_64f* pState,
2509 int nChannel, IppiHuMoment_64f pHm))
2510
2511
2512/* /////////////////////////////////////////////////////////////////////////////
2513//
2514// Name: ippiTranspose
2515//
2516// Purpose: Transposing an image
2517//
2518// Returns: IppStatus
2519// ippStsNoErr No errors
2520// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
2521// ippStsSizeErr roiSize has a field with zero or negative value,
2522// and roiSize.width != roiSize.height (in-place flavors)
2523//
2524// Parameters:
2525// pSrc Pointer to the source image
2526// srcStep Step through the source image
2527// pDst Pointer to the destination image
2528// dstStep Step through the destination image
2529// pSrcDst Pointer to the source/destination image (in-place flavors)
2530// srcDstStep Step through the source/destination image (in-place flavors)
2531// roiSize Size of the ROI
2532//
2533// Notes: Parameters roiSize.width and roiSize.height are defined for the source image.
2534//
2535*/
2536
2537IPPAPI ( IppStatus, ippiTranspose_8u_C1R,
2538 ( const Ipp8u* pSrc, int srcStep,
2539 Ipp8u* pDst, int dstStep,
2540 IppiSize roiSize ))
2541IPPAPI ( IppStatus, ippiTranspose_8u_C3R,
2542 ( const Ipp8u* pSrc, int srcStep,
2543 Ipp8u* pDst, int dstStep,
2544 IppiSize roiSize ))
2545IPPAPI ( IppStatus, ippiTranspose_8u_C4R,
2546 ( const Ipp8u* pSrc, int srcStep,
2547 Ipp8u* pDst, int dstStep,
2548 IppiSize roiSize ))
2549IPPAPI ( IppStatus, ippiTranspose_8u_C1IR,
2550 ( Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize ))
2551IPPAPI ( IppStatus, ippiTranspose_8u_C3IR,
2552 ( Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize ))
2553IPPAPI ( IppStatus, ippiTranspose_8u_C4IR,
2554 ( Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize ))
2555IPPAPI ( IppStatus, ippiTranspose_16u_C1R,
2556 ( const Ipp16u* pSrc, int srcStep,
2557 Ipp16u* pDst, int dstStep,
2558 IppiSize roiSize ))
2559IPPAPI ( IppStatus, ippiTranspose_16u_C3R,
2560 ( const Ipp16u* pSrc, int srcStep,
2561 Ipp16u* pDst, int dstStep,
2562 IppiSize roiSize ))
2563IPPAPI ( IppStatus, ippiTranspose_16u_C4R,
2564 ( const Ipp16u* pSrc, int srcStep,
2565 Ipp16u* pDst, int dstStep,
2566 IppiSize roiSize ))
2567IPPAPI ( IppStatus, ippiTranspose_16u_C1IR,
2568 ( Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize ))
2569IPPAPI ( IppStatus, ippiTranspose_16u_C3IR,
2570 ( Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize ))
2571IPPAPI ( IppStatus, ippiTranspose_16u_C4IR,
2572 ( Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize ))
2573IPPAPI ( IppStatus, ippiTranspose_32s_C1R,
2574 ( const Ipp32s* pSrc, int srcStep,
2575 Ipp32s* pDst, int dstStep,
2576 IppiSize roiSize ))
2577IPPAPI ( IppStatus, ippiTranspose_32s_C3R,
2578 ( const Ipp32s* pSrc, int srcStep,
2579 Ipp32s* pDst, int dstStep,
2580 IppiSize roiSize ))
2581IPPAPI ( IppStatus, ippiTranspose_32s_C4R,
2582 ( const Ipp32s* pSrc, int srcStep,
2583 Ipp32s* pDst, int dstStep,
2584 IppiSize roiSize ))
2585IPPAPI ( IppStatus, ippiTranspose_32s_C1IR,
2586 ( Ipp32s* pSrcDst, int srcDstStep, IppiSize roiSize ))
2587IPPAPI ( IppStatus, ippiTranspose_32s_C3IR,
2588 ( Ipp32s* pSrcDst, int srcDstStep, IppiSize roiSize ))
2589IPPAPI ( IppStatus, ippiTranspose_32s_C4IR,
2590 ( Ipp32s* pSrcDst, int srcDstStep, IppiSize roiSize ))
2591
2592IPPAPI ( IppStatus, ippiTranspose_16s_C1R,
2593 ( const Ipp16s* pSrc, int srcStep,
2594 Ipp16s* pDst, int dstStep,
2595 IppiSize roiSize ))
2596IPPAPI ( IppStatus, ippiTranspose_16s_C3R,
2597 ( const Ipp16s* pSrc, int srcStep,
2598 Ipp16s* pDst, int dstStep,
2599 IppiSize roiSize ))
2600IPPAPI ( IppStatus, ippiTranspose_16s_C4R,
2601 ( const Ipp16s* pSrc, int srcStep,
2602 Ipp16s* pDst, int dstStep,
2603 IppiSize roiSize ))
2604IPPAPI ( IppStatus, ippiTranspose_16s_C1IR,
2605 ( Ipp16s* pSrcDst, int srcDstStep, IppiSize roiSize ))
2606IPPAPI ( IppStatus, ippiTranspose_16s_C3IR,
2607 ( Ipp16s* pSrcDst, int srcDstStep, IppiSize roiSize ))
2608IPPAPI ( IppStatus, ippiTranspose_16s_C4IR,
2609 ( Ipp16s* pSrcDst, int srcDstStep, IppiSize roiSize ))
2610
2611
2612IPPAPI ( IppStatus, ippiTranspose_32f_C1R,
2613 ( const Ipp32f* pSrc, int srcStep,
2614 Ipp32f* pDst, int dstStep,
2615 IppiSize roiSize ))
2616IPPAPI ( IppStatus, ippiTranspose_32f_C3R,
2617 ( const Ipp32f* pSrc, int srcStep,
2618 Ipp32f* pDst, int dstStep,
2619 IppiSize roiSize ))
2620IPPAPI ( IppStatus, ippiTranspose_32f_C4R,
2621 ( const Ipp32f* pSrc, int srcStep,
2622 Ipp32f* pDst, int dstStep,
2623 IppiSize roiSize ))
2624IPPAPI ( IppStatus, ippiTranspose_32f_C1IR,
2625 ( Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize ))
2626IPPAPI ( IppStatus, ippiTranspose_32f_C3IR,
2627 ( Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize ))
2628IPPAPI ( IppStatus, ippiTranspose_32f_C4IR,
2629 ( Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize ))
2630
2631
2632/* ////////////////////////////////////////////////////////////////////////////
2633// Name: ippiConvert
2634//
2635// Purpose: Converts pixel values of an image from one bit depth to another
2636//
2637// Returns:
2638// ippStsNullPtrErr One of the pointers is NULL
2639// ippStsSizeErr roiSize has a field with zero or negative value
2640// ippStsStepErr srcStep or dstStep has zero or negative value
2641// ippStsNoErr OK
2642//
2643// Parameters:
2644// pSrc Pointer to the source image
2645// srcStep Step through the source image
2646// pDst Pointer to the destination image
2647// dstStep Step in bytes through the destination image
2648// roiSize Size of the ROI
2649// roundMode Rounding mode, ippRndZero or ippRndNear
2650*/
2651IPPAPI ( IppStatus, ippiConvert_8u8s_C1RSfs, (const Ipp8u* pSrc, int srcStep, Ipp8s* pDst, int dstStep, IppiSize roi,IppRoundMode rndMode, int scaleFactor))
2652IPPAPI ( IppStatus, ippiConvert_8u16u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize ))
2653IPPAPI ( IppStatus, ippiConvert_8u16s_C1R, (const Ipp8u* pSrc, int srcStep, Ipp16s* pDst, int dstStep, IppiSize roiSize ))
2654IPPAPI ( IppStatus, ippiConvert_8u32s_C1R, (const Ipp8u* pSrc, int srcStep, Ipp32s* pDst, int dstStep, IppiSize roiSize ))
2655IPPAPI ( IppStatus, ippiConvert_8u32f_C1R, (const Ipp8u* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize ))
2656
2657IPPAPI ( IppStatus, ippiConvert_8s8u_C1Rs, (const Ipp8s* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roi))
2658IPPAPI ( IppStatus, ippiConvert_8s16s_C1R, (const Ipp8s* pSrc, int srcStep, Ipp16s* pDst, int dstStep, IppiSize roi))
2659IPPAPI ( IppStatus, ippiConvert_8s16u_C1Rs, (const Ipp8s* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roi))
2660IPPAPI ( IppStatus, ippiConvert_8s32s_C1R, (const Ipp8s* pSrc, int srcStep, Ipp32s* pDst, int dstStep, IppiSize roiSize ))
2661IPPAPI ( IppStatus, ippiConvert_8s32f_C1R, (const Ipp8s* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize ))
2662
2663IPPAPI ( IppStatus, ippiConvert_16u8u_C1R, ( const Ipp16u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
2664IPPAPI ( IppStatus, ippiConvert_16u8s_C1RSfs, (const Ipp16u* pSrc, int srcStep, Ipp8s* pDst, int dstStep, IppiSize roi,IppRoundMode rndMode, int scaleFactor))
2665IPPAPI ( IppStatus, ippiConvert_16u16s_C1RSfs, (const Ipp16u* pSrc, int srcStep, Ipp16s* pDst, int dstStep, IppiSize roi,IppRoundMode rndMode, int scaleFactor))
2666IPPAPI ( IppStatus, ippiConvert_16u32s_C1R, (const Ipp16u* pSrc, int srcStep, Ipp32s* pDst, int dstStep, IppiSize roiSize ))
2667IPPAPI ( IppStatus, ippiConvert_16u32f_C1R, (const Ipp16u* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize ))
2668
2669IPPAPI ( IppStatus, ippiConvert_16s8s_C1RSfs, (const Ipp16s* pSrc, int srcStep, Ipp8s* pDst, int dstStep, IppiSize roi,IppRoundMode rndMode, int scaleFactor))
2670IPPAPI ( IppStatus, ippiConvert_16s8u_C1R, ( const Ipp16s* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
2671IPPAPI ( IppStatus, ippiConvert_16s16u_C1Rs, (const Ipp16s* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roi))
2672IPPAPI ( IppStatus, ippiConvert_16s32s_C1R, (const Ipp16s* pSrc, int srcStep, Ipp32s* pDst, int dstStep, IppiSize roiSize ))
2673IPPAPI ( IppStatus, ippiConvert_16s32f_C1R, (const Ipp16s* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize ))
2674
2675IPPAPI ( IppStatus, ippiConvert_32s8u_C1R, ( const Ipp32s* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
2676IPPAPI ( IppStatus, ippiConvert_32s8s_C1R, ( const Ipp32s* pSrc, int srcStep, Ipp8s* pDst, int dstStep, IppiSize roiSize ))
2677IPPAPI ( IppStatus, ippiConvert_32s16u_C1RSfs, (const Ipp32s* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roi,IppRoundMode rndMode, int scaleFactor))
2678IPPAPI ( IppStatus, ippiConvert_32s16s_C1RSfs, (const Ipp32s* pSrc, int srcStep, Ipp16s* pDst, int dstStep, IppiSize roi,IppRoundMode rndMode, int scaleFactor))
2679IPPAPI ( IppStatus, ippiConvert_32s32f_C1R, (const Ipp32s* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roi))
2680
2681IPPAPI ( IppStatus, ippiConvert_32f8u_C1R, ( const Ipp32f* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize, IppRoundMode roundMode ))
2682IPPAPI ( IppStatus, ippiConvert_32f8u_C1RSfs, (const Ipp32f* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roi, IppRoundMode round, int scaleFactor))
2683IPPAPI ( IppStatus, ippiConvert_32f8s_C1R, ( const Ipp32f* pSrc, int srcStep, Ipp8s* pDst, int dstStep, IppiSize roiSize, IppRoundMode roundMode ))
2684IPPAPI ( IppStatus, ippiConvert_32f8s_C1RSfs, (const Ipp32f* pSrc, int srcStep, Ipp8s* pDst, int dstStep, IppiSize roi, IppRoundMode round, int scaleFactor))
2685IPPAPI ( IppStatus, ippiConvert_32f16u_C1R, ( const Ipp32f* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize, IppRoundMode roundMode ))
2686IPPAPI ( IppStatus, ippiConvert_32f16u_C1RSfs, (const Ipp32f* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roi, IppRoundMode round, int scaleFactor))
2687IPPAPI ( IppStatus, ippiConvert_32f16s_C1R, ( const Ipp32f* pSrc, int srcStep, Ipp16s* pDst, int dstStep, IppiSize roiSize, IppRoundMode roundMode ))
2688IPPAPI ( IppStatus, ippiConvert_32f32s_C1RSfs, (const Ipp32f* pSrc, int srcStep, Ipp32s* pDst, int dstStep, IppiSize roi, IppRoundMode round, int scaleFactor))
2689
2690
2691/* /////////////////////////////////////////////////////////////////////////////
2692//
2693// Name: ippiMirror
2694//
2695// Purpose: Mirrors an image about a horizontal
2696// or vertical axis, or both
2697//
2698// Context:
2699//
2700// Returns: IppStatus
2701// ippStsNoErr No errors
2702// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
2703// ippStsSizeErr, roiSize has a field with zero or negative value
2704// ippStsMirrorFlipErr (flip != ippAxsHorizontal) &&
2705// (flip != ippAxsVertical) &&
2706// (flip != ippAxsBoth)
2707//
2708// Parameters:
2709// pSrc Pointer to the source image
2710// srcStep Step through the source image
2711// pDst Pointer to the destination image
2712// dstStep Step through the destination image
2713// pSrcDst Pointer to the source/destination image (in-place flavors)
2714// srcDstStep Step through the source/destination image (in-place flavors)
2715// roiSize Size of the ROI
2716// flip Specifies the axis to mirror the image about:
2717// ippAxsHorizontal horizontal axis,
2718// ippAxsVertical vertical axis,
2719// ippAxsBoth both horizontal and vertical axes
2720//
2721// Notes:
2722//
2723*/
2724
2725IPPAPI(IppStatus, ippiMirror_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
2726 IppiSize roiSize, IppiAxis flip))
2727IPPAPI(IppStatus, ippiMirror_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
2728 IppiSize roiSize, IppiAxis flip))
2729IPPAPI(IppStatus, ippiMirror_8u_C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
2730 IppiSize roiSize, IppiAxis flip))
2731IPPAPI(IppStatus, ippiMirror_8u_C1IR, (Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2732IPPAPI(IppStatus, ippiMirror_8u_C3IR, (Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2733IPPAPI(IppStatus, ippiMirror_8u_C4IR, (Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2734
2735IPPAPI(IppStatus, ippiMirror_16u_C1R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
2736 IppiSize roiSize, IppiAxis flip))
2737IPPAPI(IppStatus, ippiMirror_16u_C3R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
2738 IppiSize roiSize, IppiAxis flip))
2739IPPAPI(IppStatus, ippiMirror_16u_C4R, (const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
2740 IppiSize roiSize, IppiAxis flip))
2741IPPAPI(IppStatus, ippiMirror_16u_C1IR, (Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2742IPPAPI(IppStatus, ippiMirror_16u_C3IR, (Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2743IPPAPI (IppStatus, ippiMirror_16u_C4IR, (Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2744
2745IPPAPI(IppStatus, ippiMirror_32s_C1R, (const Ipp32s* pSrc, int srcStep, Ipp32s* pDst, int dstStep,
2746 IppiSize roiSize, IppiAxis flip))
2747IPPAPI(IppStatus, ippiMirror_32s_C3R, (const Ipp32s* pSrc, int srcStep, Ipp32s* pDst, int dstStep,
2748 IppiSize roiSize, IppiAxis flip))
2749IPPAPI(IppStatus, ippiMirror_32s_C4R, (const Ipp32s* pSrc, int srcStep, Ipp32s* pDst, int dstStep,
2750 IppiSize roiSize, IppiAxis flip ) )
2751
2752IPPAPI(IppStatus, ippiMirror_32s_C1IR, (Ipp32s* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2753IPPAPI(IppStatus, ippiMirror_32s_C3IR, (Ipp32s* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2754IPPAPI(IppStatus, ippiMirror_32s_C4IR, (Ipp32s* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2755
2756IPPAPI(IppStatus, ippiMirror_16s_C1R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
2757 IppiSize roiSize, IppiAxis flip))
2758IPPAPI(IppStatus, ippiMirror_16s_C3R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
2759 IppiSize roiSize, IppiAxis flip))
2760IPPAPI(IppStatus, ippiMirror_16s_C4R, (const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
2761 IppiSize roiSize, IppiAxis flip))
2762IPPAPI(IppStatus, ippiMirror_16s_C1IR, (Ipp16s* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2763IPPAPI(IppStatus, ippiMirror_16s_C3IR, (Ipp16s* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2764IPPAPI (IppStatus, ippiMirror_16s_C4IR, (Ipp16s* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2765
2766IPPAPI(IppStatus, ippiMirror_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
2767 IppiSize roiSize, IppiAxis flip))
2768IPPAPI(IppStatus, ippiMirror_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
2769 IppiSize roiSize, IppiAxis flip))
2770IPPAPI(IppStatus, ippiMirror_32f_C4R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
2771 IppiSize roiSize, IppiAxis flip ) )
2772IPPAPI(IppStatus, ippiMirror_32f_C1IR, (Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2773IPPAPI(IppStatus, ippiMirror_32f_C3IR, (Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2774IPPAPI(IppStatus, ippiMirror_32f_C4IR, (Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip))
2775
2776
2777
2778/* ///////////////////////////////////////////////////////////////////////////////////////
2779// Arithmetic Functions
2780///////////////////////////////////////////////////////////////////////////// */
2781/* ///////////////////////////////////////////////////////////////////////////////////////
2782// Name: ippiAdd_8u_C1RSfs, ippiAdd_8u_C3RSfs, ippiAdd_8u_C4RSfs, ippiAdd_8u_AC4RSfs,
2783// ippiAdd_16s_C1RSfs, ippiAdd_16s_C3RSfs, ippiAdd_16s_C4RSfs, ippiAdd_16s_AC4RSfs,
2784// ippiAdd_16u_C1RSfs, ippiAdd_16u_C3RSfs, ippiAdd_16u_C4RSfs, ippiAdd_16u_AC4RSfs,
2785// ippiSub_8u_C1RSfs, ippiSub_8u_C3RSfs, ippiSub_8u_C4RSfs, ippiSub_8u_AC4RSfs,
2786// ippiSub_16s_C1RSfs, ippiSub_16s_C3RSfs, ippiSub_16s_C4RSfs, ippiSub_16s_AC4RSfs,
2787// ippiSub_16u_C1RSfs, ippiSub_16u_C3RSfs, ippiSub_16u_C4RSfs, ippiSub_16u_AC4RSfs,
2788// ippiMul_8u_C1RSfs, ippiMul_8u_C3RSfs, ippiMul_8u_C4RSfs, ippiMul_8u_AC4RSfs,
2789// ippiMul_16s_C1RSfs, ippiMul_16s_C3RSfs, ippiMul_16s_C4RSfs, ippiMul_16s_AC4RSfs
2790// ippiMul_16u_C1RSfs, ippiMul_16u_C3RSfs, ippiMul_16u_C4RSfs, ippiMul_16u_AC4RSfs
2791//
2792// Purpose: Adds, subtracts, or multiplies pixel values of two
2793// source images and places the scaled result in the destination image.
2794//
2795// Returns:
2796// ippStsNoErr OK
2797// ippStsNullPtrErr One of the pointers is NULL
2798// ippStsSizeErr Width or height of images is less than or equal to zero
2799//
2800// Parameters:
2801// pSrc1, pSrc2 Pointers to the source images
2802// src1Step, src2Step Steps through the source images
2803// pDst Pointer to the destination image
2804// dstStep Step through the destination image
2805// roiSize Size of the ROI
2806// scaleFactor Scale factor
2807*/
2808
2809IPPAPI(IppStatus, ippiAdd_8u_C1RSfs, (const Ipp8u* pSrc1, int src1Step, const Ipp8u* pSrc2,
2810 int src2Step, Ipp8u* pDst, int dstStep, IppiSize roiSize,
2811 int scaleFactor))
2812
2813IPPAPI(IppStatus, ippiAdd_16u_C1RSfs, (const Ipp16u* pSrc1, int src1Step, const Ipp16u* pSrc2,
2814 int src2Step, Ipp16u* pDst, int dstStep, IppiSize roiSize,
2815 int scaleFactor))
2816
2817IPPAPI(IppStatus, ippiAdd_16s_C1RSfs, (const Ipp16s* pSrc1, int src1Step, const Ipp16s* pSrc2,
2818 int src2Step, Ipp16s* pDst, int dstStep, IppiSize roiSize,
2819 int scaleFactor))
2820
2821IPPAPI(IppStatus, ippiSub_8u_C1RSfs, (const Ipp8u* pSrc1, int src1Step, const Ipp8u* pSrc2,
2822 int src2Step, Ipp8u* pDst, int dstStep, IppiSize roiSize,
2823 int scaleFactor))
2824
2825IPPAPI(IppStatus, ippiSub_16u_C1RSfs, (const Ipp16u* pSrc1, int src1Step, const Ipp16u* pSrc2,
2826 int src2Step, Ipp16u* pDst, int dstStep, IppiSize roiSize,
2827 int scaleFactor))
2828
2829IPPAPI(IppStatus, ippiSub_16s_C1RSfs, (const Ipp16s* pSrc1, int src1Step, const Ipp16s* pSrc2,
2830 int src2Step, Ipp16s* pDst, int dstStep, IppiSize roiSize,
2831 int scaleFactor))
2832
2833IPPAPI(IppStatus, ippiMul_16s_C1RSfs, (const Ipp16s* pSrc1, int src1Step, const Ipp16s* pSrc2,
2834 int src2Step, Ipp16s* pDst, int dstStep, IppiSize roiSize,
2835 int scaleFactor))
2836
2837IPPAPI(IppStatus, ippiMul_16u_C1RSfs, (const Ipp16u* pSrc1, int src1Step, const Ipp16u* pSrc2,
2838 int src2Step, Ipp16u* pDst, int dstStep, IppiSize roiSize,
2839 int scaleFactor))
2840
2841IPPAPI(IppStatus, ippiMul_8u_C1RSfs, (const Ipp8u* pSrc1, int src1Step, const Ipp8u* pSrc2,
2842 int src2Step, Ipp8u* pDst, int dstStep, IppiSize roiSize,
2843 int scaleFactor))
2844
2845
2846/* ////////////////////////////////////////////////////////////////////////////
2847// Name: ippiAdd_32f_C1R, ippiAdd_32f_C3R, ippiAdd_32f_C4R, ippiAdd_32f_AC4R,
2848// ippiSub_32f_C1R, ippiSub_32f_C3R, ippiSub_32f_C4R, ippiSub_32f_AC4R,
2849// ippiMul_32f_C1R, ippiMul_32f_C3R, ippiMul_32f_C4R, ippiMul_32f_AC4R
2850//
2851// Purpose: Adds, subtracts, or multiplies pixel values of two
2852// source images and places the results in a destination image.
2853//
2854// Returns:
2855// ippStsNoErr OK
2856// ippStsNullPtrErr One of the pointers is NULL
2857// ippStsSizeErr Width or height of images is less than or equal to zero
2858//
2859// Parameters:
2860// pSrc1, pSrc2 Pointers to the source images
2861// src1Step, src2Step Steps through the source images
2862// pDst Pointer to the destination image
2863// dstStep Step through the destination image
2864// roiSize Size of the ROI
2865*/
2866
2867IPPAPI(IppStatus, ippiAdd_32f_C1R, (const Ipp32f* pSrc1, int src1Step, const Ipp32f* pSrc2,
2868 int src2Step, Ipp32f* pDst, int dstStep, IppiSize roiSize))
2869
2870IPPAPI(IppStatus, ippiSub_32f_C1R, (const Ipp32f* pSrc1, int src1Step, const Ipp32f* pSrc2,
2871 int src2Step, Ipp32f* pDst, int dstStep, IppiSize roiSize))
2872
2873IPPAPI(IppStatus, ippiMul_32f_C1R, (const Ipp32f* pSrc1, int src1Step, const Ipp32f* pSrc2,
2874 int src2Step, Ipp32f* pDst, int dstStep, IppiSize roiSize))
2875
2876
2877/* /////////////////////////////////////////////////////////////////////////////////////////////////
2878// Logical Operations and Shift Functions
2879///////////////////////////////////////////////////////////////////////////////////////////////// */
2880/*
2881// Names: ippiAnd, ippiAndC, ippiOr, ippiOrC, ippiXor, ippiXorC, ippiNot,
2882// Purpose: Performs corresponding bitwise logical operation between pixels of two image
2883// (AndC/OrC/XorC - between pixel of the source image and a constant)
2884//
2885// Names: ippiLShiftC, ippiRShiftC
2886// Purpose: Shifts bits in each pixel value to the left and right
2887// Parameters:
2888// value 1) The constant value to be ANDed/ORed/XORed with each pixel of the source,
2889// constant vector for multi-channel images;
2890// 2) The number of bits to shift, constant vector for multi-channel images.
2891// pSrc Pointer to the source image
2892// srcStep Step through the source image
2893// pSrcDst Pointer to the source/destination image (in-place flavors)
2894// srcDstStep Step through the source/destination image (in-place flavors)
2895// pSrc1 Pointer to first source image
2896// src1Step Step through first source image
2897// pSrc2 Pointer to second source image
2898// src2Step Step through second source image
2899// pDst Pointer to the destination image
2900// dstStep Step in destination image
2901// roiSize Size of the ROI
2902//
2903// Returns:
2904// ippStsNullPtrErr One of the pointers is NULL
2905// ippStsStepErr One of the step values is less than or equal to zero
2906// ippStsSizeErr roiSize has a field with zero or negative value
2907// ippStsShiftErr Shift's value is less than zero
2908// ippStsNoErr No errors
2909*/
2910
2911IPPAPI(IppStatus, ippiAnd_8u_C1R, (const Ipp8u* pSrc1, int src1Step, const Ipp8u* pSrc2, int src2Step, Ipp8u* pDst, int dstStep, IppiSize roiSize))
2912
2913IPPAPI(IppStatus, ippiOr_8u_C1R, (const Ipp8u* pSrc1, int src1Step, const Ipp8u* pSrc2, int src2Step, Ipp8u* pDst, int dstStep, IppiSize roiSize))
2914
2915IPPAPI(IppStatus, ippiXor_8u_C1R, (const Ipp8u* pSrc1, int src1Step, const Ipp8u* pSrc2, int src2Step, Ipp8u* pDst, int dstStep, IppiSize roiSize))
2916
2917IPPAPI(IppStatus, ippiNot_8u_C1R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
2918
2919
2920/* /////////////////////////////////////////////////////////////////////////////////////////////////
2921// Compare Operations
2922///////////////////////////////////////////////////////////////////////////////////////////////// */
2923/* /////////////////////////////////////////////////////////////////////////////
2924// Name: ippiCompare
2925// ippiCompareC
2926// Purpose: Compares pixel values of two images, or pixel values of an image to a constant
2927// value using the following compare conditions: <, <=, ==, >, >= ;
2928// Names: ippiCompareEqualEps
2929// ippiCompareEqualEpsC
2930// Purpose: Compares 32f images for being equal, or equal to a given value within given tolerance
2931// Context:
2932//
2933// Returns: IppStatus
2934// ippStsNoErr No errors
2935// ippStsNullPtrErr One of the pointers is NULL
2936// ippStsStepErr One of the step values is less than or equal to zero
2937// ippStsSizeErr roiSize has a field with zero or negative value
2938// ippStsEpsValErr eps is negative
2939//
2940// Parameters:
2941// pSrc1 Pointer to the first source image;
2942// src1Step Step through the first source image;
2943// pSrc2 Pointer to the second source image data;
2944// src2Step Step through the second source image;
2945// pDst Pointer to destination image data;
2946// dstStep Step in destination image;
2947// roiSize Size of the ROI;
2948// ippCmpOp Compare operation to be used
2949// value Value (array of values for multi-channel image) to compare
2950// each pixel to
2951// eps The tolerance value
2952//
2953// Notes:
2954*/
2955
2956IPPAPI (IppStatus, ippiCompare_8u_C1R, ( const Ipp8u* pSrc1, int src1Step,
2957 const Ipp8u* pSrc2, int src2Step,
2958 Ipp8u* pDst, int dstStep,
2959 IppiSize roiSize, IppCmpOp ippCmpOp))
2960
2961IPPAPI (IppStatus, ippiCompare_16u_C1R, ( const Ipp16u* pSrc1, int src1Step,
2962 const Ipp16u* pSrc2, int src2Step,
2963 Ipp8u* pDst, int dstStep,
2964 IppiSize roiSize, IppCmpOp ippCmpOp))
2965
2966IPPAPI (IppStatus, ippiCompare_16s_C1R, ( const Ipp16s* pSrc1, int src1Step,
2967 const Ipp16s* pSrc2, int src2Step,
2968 Ipp8u* pDst, int dstStep,
2969 IppiSize roiSize, IppCmpOp ippCmpOp))
2970
2971IPPAPI (IppStatus, ippiCompare_32f_C1R, ( const Ipp32f* pSrc1, int src1Step,
2972 const Ipp32f* pSrc2, int src2Step,
2973 Ipp8u* pDst, int dstStep,
2974 IppiSize roiSize, IppCmpOp ippCmpOp))
2975
2976
2977/* /////////////////////////////////////////////////////////////////////////////
2978// Dot product of two images
2979///////////////////////////////////////////////////////////////////////////// */
2980/* /////////////////////////////////////////////////////////////////////////////
2981// Name: ippiDotProd
2982// Purpose: Computes the dot product of two images
2983// Context:
2984// Returns: IppStatus
2985// ippStsNoErr OK
2986// ippStsNullPtrErr One of the pointers is NULL
2987// ippStsStepErr One of the step values is equal to zero
2988// Parameters:
2989// pSrc1 Pointer to the first source image.
2990// src1Step Step in bytes through the first source image
2991// pSrc2 Pointer to the second source image.
2992// src2Step Step in bytes through the source image
2993// roiSize Size of the source image ROI.
2994// pDp Pointer to the result (one-channel data) or array (multi-channel data) containing computed dot products of channel values of pixels in the source images.
2995// hint Option to select the algorithmic implementation of the function
2996// Notes:
2997*/
2998
2999IPPAPI(IppStatus, ippiDotProd_8u64f_C1R,(const Ipp8u* pSrc1, int src1Step, const Ipp8u* pSrc2, int src2Step, IppiSize roiSize, Ipp64f *pDp))
3000
3001IPPAPI(IppStatus, ippiDotProd_16u64f_C1R,(const Ipp16u* pSrc1, int src1Step, const Ipp16u* pSrc2, int src2Step, IppiSize roiSize, Ipp64f *pDp))
3002
3003IPPAPI(IppStatus, ippiDotProd_16s64f_C1R,(const Ipp16s* pSrc1, int src1Step, const Ipp16s* pSrc2, int src2Step, IppiSize roiSize, Ipp64f *pDp))
3004
3005IPPAPI(IppStatus, ippiDotProd_32s64f_C1R,(const Ipp32s* pSrc1, int src1Step, const Ipp32s* pSrc2, int src2Step, IppiSize roiSize, Ipp64f *pDp))
3006
3007IPPAPI(IppStatus, ippiDotProd_32f64f_C1R,(const Ipp32f* pSrc1, int src1Step, const Ipp32f* pSrc2, int src2Step, IppiSize roiSize, Ipp64f *pDp, IppHintAlgorithm hint))
3008
3009/* /////////////////////////////////////////////////////////////////////////////
3010// Name: ippiSum
3011// Purpose: computes the sum of image pixel values
3012// Context:
3013// Returns: IppStatus
3014// ippStsNoErr OK
3015// ippStsNullPtrErr One of the pointers is NULL
3016// ippStsSizeErr roiSize has a field with zero or negative value
3017// Parameters:
3018// pSrc Pointer to the source image.
3019// srcStep Step in bytes through the source image
3020// roiSize Size of the source image ROI.
3021// pSum Pointer to the result (one-channel data)
3022// sum Array containing the results (multi-channel data)
3023// hint Option to select the algorithmic implementation of the function
3024// Notes:
3025*/
3026
3027IPPAPI(IppStatus, ippiSum_8u_C1R, (const Ipp8u* pSrc, int srcStep,
3028 IppiSize roiSize, Ipp64f* pSum))
3029
3030IPPAPI(IppStatus, ippiSum_8u_C3R, (const Ipp8u* pSrc, int srcStep,
3031 IppiSize roiSize, Ipp64f sum[3]))
3032
3033IPPAPI(IppStatus, ippiSum_8u_C4R, (const Ipp8u* pSrc, int srcStep,
3034 IppiSize roiSize, Ipp64f sum[4]))
3035
3036
3037IPPAPI(IppStatus, ippiSum_16u_C1R, (const Ipp16u* pSrc, int srcStep,
3038 IppiSize roiSize, Ipp64f* pSum))
3039
3040IPPAPI(IppStatus, ippiSum_16u_C3R, (const Ipp16u* pSrc, int srcStep,
3041 IppiSize roiSize, Ipp64f sum[3]))
3042
3043IPPAPI(IppStatus, ippiSum_16u_C4R, (const Ipp16u* pSrc, int srcStep,
3044 IppiSize roiSize, Ipp64f sum[4]))
3045
3046
3047IPPAPI(IppStatus, ippiSum_16s_C1R, (const Ipp16s* pSrc, int srcStep,
3048 IppiSize roiSize, Ipp64f* pSum))
3049
3050IPPAPI(IppStatus, ippiSum_16s_C3R, (const Ipp16s* pSrc, int srcStep,
3051 IppiSize roiSize, Ipp64f sum[3]))
3052
3053IPPAPI(IppStatus, ippiSum_16s_C4R, (const Ipp16s* pSrc, int srcStep,
3054 IppiSize roiSize, Ipp64f sum[4]))
3055
3056
3057IPPAPI(IppStatus, ippiSum_32f_C1R, (const Ipp32f* pSrc, int srcStep,
3058 IppiSize roiSize, Ipp64f* pSum, IppHintAlgorithm hint))
3059
3060IPPAPI(IppStatus, ippiSum_32f_C3R, (const Ipp32f* pSrc, int srcStep,
3061 IppiSize roiSize, Ipp64f sum[3], IppHintAlgorithm hint))
3062
3063IPPAPI(IppStatus, ippiSum_32f_C4R, (const Ipp32f* pSrc, int srcStep,
3064 IppiSize roiSize, Ipp64f sum[4], IppHintAlgorithm hint))
3065
3066
3067/* ////////////////////////////////////////////////////////////////////////////
3068// Names: ippiSqr_8u_C1RSfs
3069// ippiSqr_8u_C3RSfs
3070// ippiSqr_8u_AC4RSfs
3071// ippiSqr_8u_C4RSfs
3072// ippiSqr_16u_C1RSfs
3073// ippiSqr_16u_C3RSfs
3074// ippiSqr_16u_AC4RSfs
3075// ippiSqr_16u_C4RSfs
3076// ippiSqr_16s_C1RSfs
3077// ippiSqr_16s_C3RSfs
3078// ippiSqr_16s_AC4RSfs
3079// ippiSqr_16s_C4RSfs
3080// ippiSqr_32f_C1R
3081// ippiSqr_32f_C3R
3082// ippiSqr_32f_AC4R
3083// ippiSqr_32f_C4R
3084//
3085// ippiSqr_8u_C1IRSfs
3086// ippiSqr_8u_C3IRSfs
3087// ippiSqr_8u_AC4IRSfs
3088// ippiSqr_8u_C4IRSfs
3089// ippiSqr_16u_C1IRSfs
3090// ippiSqr_16u_C3IRSfs
3091// ippiSqr_16u_AC4IRSfs
3092// ippiSqr_16u_C4IRSfs
3093// ippiSqr_16s_C1IRSfs
3094// ippiSqr_16s_C3IRSfs
3095// ippiSqr_16s_AC4IRSfs
3096// ippiSqr_16s_C4IRSfs
3097// ippiSqr_32f_C1IR
3098// ippiSqr_32f_C3IR
3099// ippiSqr_32f_AC4IR
3100// ippiSqr_32f_C4IR
3101//
3102// Purpose: squares pixel values of an image and
3103// places results in the destination image;
3104// for in-place flavors - in the same image
3105// Returns:
3106// ippStsNoErr OK
3107// ippStsNullPtrErr One of the pointers is NULL
3108// ippStsSizeErr The roiSize has a field with negative or zero value
3109//
3110// Parameters:
3111// pSrc pointer to the source image
3112// srcStep step through the source image
3113// pDst pointer to the destination image
3114// dstStep step through the destination image
3115// pSrcDst pointer to the source/destination image (for in-place function)
3116// srcDstStep step through the source/destination image (for in-place function)
3117// roiSize size of the ROI
3118// scaleFactor scale factor
3119*/
3120
3121IPPAPI(IppStatus,ippiSqr_32f_C1R, (const Ipp32f* pSrc, int srcStep,
3122 Ipp32f* pDst, int dstStep, IppiSize roiSize))
3123
3124
3125/* /////////////////////////////////////////////////////////////////////////////
3126// Name: ippiMean
3127// Purpose: computes the mean of image pixel values
3128// Context:
3129// Returns: IppStatus
3130// ippStsNoErr OK
3131// ippStsNullPtrErr One of the pointers is NULL
3132// ippStsSizeErr roiSize has a field with zero or negative value.
3133// Parameters:
3134// pSrc Pointer to the source image.
3135// srcStep Step in bytes through the source image
3136// roiSize Size of the source ROI.
3137// pMean Pointer to the result (one-channel data)
3138// mean Array containing the results (multi-channel data)
3139// hint Option to select the algorithmic implementation of the function
3140// Notes:
3141*/
3142
3143IPPAPI(IppStatus, ippiMean_8u_C1R, (const Ipp8u* pSrc, int srcStep,
3144 IppiSize roiSize, Ipp64f* pMean))
3145
3146IPPAPI(IppStatus, ippiMean_8u_C3R, (const Ipp8u* pSrc, int srcStep,
3147 IppiSize roiSize, Ipp64f mean[3]))
3148
3149IPPAPI(IppStatus, ippiMean_8u_C4R, (const Ipp8u* pSrc, int srcStep,
3150 IppiSize roiSize, Ipp64f mean[4]))
3151
3152IPPAPI(IppStatus, ippiMean_16s_C1R, (const Ipp16s* pSrc, int srcStep,
3153 IppiSize roiSize, Ipp64f* pMean))
3154
3155IPPAPI(IppStatus, ippiMean_16s_C3R, (const Ipp16s* pSrc, int srcStep,
3156 IppiSize roiSize, Ipp64f mean[3]))
3157
3158IPPAPI(IppStatus, ippiMean_16s_C4R, (const Ipp16s* pSrc, int srcStep,
3159 IppiSize roiSize, Ipp64f mean[4]))
3160
3161IPPAPI(IppStatus, ippiMean_16u_C1R, (const Ipp16u* pSrc, int srcStep,
3162 IppiSize roiSize, Ipp64f* pMean))
3163
3164IPPAPI(IppStatus, ippiMean_16u_C3R, (const Ipp16u* pSrc, int srcStep,
3165 IppiSize roiSize, Ipp64f mean[3]))
3166
3167IPPAPI(IppStatus, ippiMean_16u_C4R, (const Ipp16u* pSrc, int srcStep,
3168 IppiSize roiSize, Ipp64f mean[4]))
3169
3170IPPAPI(IppStatus, ippiMean_32f_C1R, (const Ipp32f* pSrc, int srcStep,
3171 IppiSize roiSize, Ipp64f* pMean, IppHintAlgorithm hint))
3172
3173IPPAPI(IppStatus, ippiMean_32f_C3R, (const Ipp32f* pSrc, int srcStep,
3174 IppiSize roiSize, Ipp64f mean[3], IppHintAlgorithm hint))
3175
3176IPPAPI(IppStatus, ippiMean_32f_C4R, (const Ipp32f* pSrc, int srcStep,
3177 IppiSize roiSize, Ipp64f mean[4], IppHintAlgorithm hint))
3178
3179
3180/* /////////////////////////////////////////////////////////////////////////////
3181// Name: ippiNorm_Inf
3182// Purpose: computes the C-norm of pixel values of the image: n = MAX |src1|
3183// Context:
3184// Returns: IppStatus
3185// ippStsNoErr OK
3186// ippStsNullPtrErr One of the pointers is NULL
3187// ippStsSizeErr roiSize has a field with zero or negative value
3188// Parameters:
3189// pSrc Pointer to the source image.
3190// srcStep Step through the source image
3191// roiSize Size of the source ROI.
3192// pValue Pointer to the computed norm (one-channel data)
3193// value Array of the computed norms for each channel (multi-channel data)
3194// Notes:
3195*/
3196
3197IPPAPI(IppStatus, ippiNorm_Inf_8u_C1R, (const Ipp8u* pSrc, int srcStep,
3198 IppiSize roiSize, Ipp64f* pValue))
3199
3200IPPAPI(IppStatus, ippiNorm_Inf_8u_C3R, (const Ipp8u* pSrc, int srcStep,
3201 IppiSize roiSize, Ipp64f value[3]))
3202
3203IPPAPI(IppStatus, ippiNorm_Inf_8u_C4R, (const Ipp8u* pSrc, int srcStep,
3204 IppiSize roiSize, Ipp64f value[4]))
3205
3206IPPAPI(IppStatus, ippiNorm_Inf_16s_C1R, (const Ipp16s* pSrc, int srcStep,
3207 IppiSize roiSize, Ipp64f* pValue))
3208
3209IPPAPI(IppStatus, ippiNorm_Inf_16s_C3R, (const Ipp16s* pSrc, int srcStep,
3210 IppiSize roiSize, Ipp64f value[3]))
3211
3212IPPAPI(IppStatus, ippiNorm_Inf_16s_C4R, (const Ipp16s* pSrc, int srcStep,
3213 IppiSize roiSize, Ipp64f value[4]))
3214
3215IPPAPI(IppStatus, ippiNorm_Inf_16u_C1R, (const Ipp16u* pSrc, int srcStep,
3216 IppiSize roiSize, Ipp64f* pValue))
3217
3218IPPAPI(IppStatus, ippiNorm_Inf_16u_C3R, (const Ipp16u* pSrc, int srcStep,
3219 IppiSize roiSize, Ipp64f value[3]))
3220
3221IPPAPI(IppStatus, ippiNorm_Inf_16u_C4R, (const Ipp16u* pSrc, int srcStep,
3222 IppiSize roiSize, Ipp64f value[4]))
3223
3224IPPAPI(IppStatus, ippiNorm_Inf_32f_C1R, (const Ipp32f* pSrc, int srcStep,
3225 IppiSize roiSize, Ipp64f* pValue))
3226
3227IPPAPI(IppStatus, ippiNorm_Inf_32f_C3R, (const Ipp32f* pSrc, int srcStep,
3228 IppiSize roiSize, Ipp64f value[3]))
3229
3230IPPAPI(IppStatus, ippiNorm_Inf_32f_C4R, (const Ipp32f* pSrc, int srcStep,
3231 IppiSize roiSize, Ipp64f value[4]))
3232
3233/* /////////////////////////////////////////////////////////////////////////////
3234// Name: ippiNorm_L1
3235// Purpose: computes the L1-norm of pixel values of the image: n = SUM |src1|
3236// Context:
3237// Returns: IppStatus
3238// ippStsNoErr OK
3239// ippStsNullPtrErr One of the pointers is NULL
3240// ippStsSizeErr roiSize has a field with zero or negative value
3241// Parameters:
3242// pSrc Pointer to the source image.
3243// srcStep Step through the source image
3244// roiSize Size of the source ROI.
3245// pValue Pointer to the computed norm (one-channel data)
3246// value Array of the computed norms for each channel (multi-channel data)
3247// hint Option to specify the computation algorithm
3248// Notes:
3249*/
3250
3251IPPAPI(IppStatus, ippiNorm_L1_8u_C1R, (const Ipp8u* pSrc, int srcStep,
3252 IppiSize roiSize, Ipp64f* pValue))
3253
3254IPPAPI(IppStatus, ippiNorm_L1_8u_C3R, (const Ipp8u* pSrc, int srcStep,
3255 IppiSize roiSize, Ipp64f value[3]))
3256
3257IPPAPI(IppStatus, ippiNorm_L1_8u_C4R, (const Ipp8u* pSrc, int srcStep,
3258 IppiSize roiSize, Ipp64f value[4]))
3259
3260IPPAPI(IppStatus, ippiNorm_L1_16s_C1R, (const Ipp16s* pSrc, int srcStep,
3261 IppiSize roiSize, Ipp64f* pValue))
3262
3263IPPAPI(IppStatus, ippiNorm_L1_16s_C3R, (const Ipp16s* pSrc, int srcStep,
3264 IppiSize roiSize, Ipp64f value[3]))
3265
3266IPPAPI(IppStatus, ippiNorm_L1_16s_C4R, (const Ipp16s* pSrc, int srcStep,
3267 IppiSize roiSize, Ipp64f value[4]))
3268
3269IPPAPI(IppStatus, ippiNorm_L1_16u_C1R, (const Ipp16u* pSrc, int srcStep,
3270 IppiSize roiSize, Ipp64f* pValue))
3271
3272IPPAPI(IppStatus, ippiNorm_L1_16u_C3R, (const Ipp16u* pSrc, int srcStep,
3273 IppiSize roiSize, Ipp64f value[3]))
3274
3275IPPAPI(IppStatus, ippiNorm_L1_16u_C4R, (const Ipp16u* pSrc, int srcStep,
3276 IppiSize roiSize, Ipp64f value[4]))
3277
3278IPPAPI(IppStatus, ippiNorm_L1_32f_C1R, (const Ipp32f* pSrc, int srcStep,
3279 IppiSize roiSize, Ipp64f* pValue, IppHintAlgorithm hint))
3280
3281IPPAPI(IppStatus, ippiNorm_L1_32f_C3R, (const Ipp32f* pSrc, int srcStep,
3282 IppiSize roiSize, Ipp64f value[3], IppHintAlgorithm hint))
3283
3284IPPAPI(IppStatus, ippiNorm_L1_32f_C4R, (const Ipp32f* pSrc, int srcStep,
3285 IppiSize roiSize, Ipp64f value[4], IppHintAlgorithm hint))
3286
3287/* /////////////////////////////////////////////////////////////////////////////
3288// Name: ippiNorm_L2
3289// Purpose: computes the L2-norm of pixel values of the image: n = SQRT(SUM |src1|^2)
3290// Context:
3291// Returns: IppStatus
3292// ippStsNoErr OK
3293// ippStsNullPtrErr One of the pointers is NULL
3294// ippStsSizeErr roiSize has a field with zero or negative value
3295// Parameters:
3296// pSrc Pointer to the source image.
3297// srcStep Step through the source image
3298// roiSize Size of the source ROI.
3299// pValue Pointer to the computed norm (one-channel data)
3300// value Array of the computed norms for each channel (multi-channel data)
3301// hint Option to specify the computation algorithm
3302// Notes:
3303// simple mul is better than table for P6 family
3304*/
3305
3306IPPAPI(IppStatus, ippiNorm_L2_8u_C1R, (const Ipp8u* pSrc, int srcStep,
3307 IppiSize roiSize, Ipp64f* pValue))
3308
3309IPPAPI(IppStatus, ippiNorm_L2_8u_C3R, (const Ipp8u* pSrc, int srcStep,
3310 IppiSize roiSize, Ipp64f value[3]))
3311
3312IPPAPI(IppStatus, ippiNorm_L2_8u_C4R, (const Ipp8u* pSrc, int srcStep,
3313 IppiSize roiSize, Ipp64f value[4]))
3314
3315IPPAPI(IppStatus, ippiNorm_L2_16s_C1R, (const Ipp16s* pSrc, int srcStep,
3316 IppiSize roiSize, Ipp64f* pValue))
3317
3318IPPAPI(IppStatus, ippiNorm_L2_16s_C3R, (const Ipp16s* pSrc, int srcStep,
3319 IppiSize roiSize, Ipp64f value[3]))
3320
3321IPPAPI(IppStatus, ippiNorm_L2_16s_C4R, (const Ipp16s* pSrc, int srcStep,
3322 IppiSize roiSize, Ipp64f value[4]))
3323
3324IPPAPI(IppStatus, ippiNorm_L2_16u_C1R, (const Ipp16u* pSrc, int srcStep,
3325 IppiSize roiSize, Ipp64f* pValue))
3326
3327IPPAPI(IppStatus, ippiNorm_L2_16u_C3R, (const Ipp16u* pSrc, int srcStep,
3328 IppiSize roiSize, Ipp64f value[3]))
3329
3330IPPAPI(IppStatus, ippiNorm_L2_16u_C4R, (const Ipp16u* pSrc, int srcStep,
3331 IppiSize roiSize, Ipp64f value[4]))
3332
3333IPPAPI(IppStatus, ippiNorm_L2_32f_C1R, (const Ipp32f* pSrc, int srcStep,
3334 IppiSize roiSize, Ipp64f* pValue, IppHintAlgorithm hint))
3335
3336IPPAPI(IppStatus, ippiNorm_L2_32f_C3R, (const Ipp32f* pSrc, int srcStep,
3337 IppiSize roiSize, Ipp64f value[3], IppHintAlgorithm hint))
3338
3339IPPAPI(IppStatus, ippiNorm_L2_32f_C4R, (const Ipp32f* pSrc, int srcStep,
3340 IppiSize roiSize, Ipp64f value[4], IppHintAlgorithm hint))
3341
3342
3343
3344/* //////////////////////////////////////////////////////////////////////////////////////////
3345// Name: ippiNormRel_Inf
3346// Purpose: computes the relative error for the C-norm of pixel values of two images:
3347// n = MAX |src1 - src2| / MAX |src2|
3348// Context:
3349// Returns: IppStatus
3350// ippStsNoErr OK
3351// ippStsNullPtrErr One of the pointers is NULL
3352// ippStsSizeErr roiSize has a field with zero or negative value
3353// ippStsDivByZero MAX |src2| == 0
3354// Parameters:
3355// pSrc1, pSrc2 Pointers to the source images.
3356// src1Step, src2Step Steps in bytes through the source images
3357// roiSize Size of the source ROI.
3358// pValue Pointer to the computed norm (one-channel data)
3359// value Array of the computed norms for each channel (multi-channel data)
3360// Notes:
3361*/
3362
3363IPPAPI(IppStatus, ippiNormRel_Inf_8u_C1R, (const Ipp8u* pSrc1, int src1Step,
3364 const Ipp8u* pSrc2, int src2Step,
3365 IppiSize roiSize, Ipp64f* pValue))
3366
3367IPPAPI(IppStatus, ippiNormRel_Inf_16u_C1R, (const Ipp16u* pSrc1, int src1Step,
3368 const Ipp16u* pSrc2, int src2Step,
3369 IppiSize roiSize, Ipp64f* pValue))
3370
3371IPPAPI(IppStatus, ippiNormRel_Inf_16s_C1R, (const Ipp16s* pSrc1, int src1Step,
3372 const Ipp16s* pSrc2, int src2Step,
3373 IppiSize roiSize, Ipp64f* pValue))
3374
3375IPPAPI(IppStatus, ippiNormRel_Inf_32f_C1R, (const Ipp32f* pSrc1, int src1Step,
3376 const Ipp32f* pSrc2, int src2Step,
3377 IppiSize roiSize, Ipp64f* pValue))
3378
3379
3380/* /////////////////////////////////////////////////////////////////////////////////////////
3381// Name: ippiNormRel_L1
3382// Purpose: computes the relative error for the 1-norm of pixel values of two images:
3383// n = SUM |src1 - src2| / SUM |src2|
3384// Context:
3385// Returns: IppStatus
3386// ippStsNoErr OK
3387// ippStsNullPtrErr One of the pointers is NULL
3388// ippStsSizeErr roiSize has a field with zero or negative value
3389// ippStsDivByZero SUM |src2| == 0
3390// Parameters:
3391// pSrc1, pSrc2 Pointers to the source images.
3392// src1Step, src2Step Steps in bytes through the source images
3393// roiSize Size of the source ROI.
3394// pValue Pointer to the computed norm (one-channel data)
3395// value Array of the computed norms for each channel (multi-channel data)
3396// hint Option to specify the computation algorithm
3397// Notes:
3398*/
3399
3400IPPAPI(IppStatus, ippiNormRel_L1_8u_C1R, (const Ipp8u* pSrc1, int src1Step,
3401 const Ipp8u* pSrc2, int src2Step,
3402 IppiSize roiSize, Ipp64f* pValue))
3403
3404IPPAPI(IppStatus, ippiNormRel_L1_16s_C1R, (const Ipp16s* pSrc1, int src1Step,
3405 const Ipp16s* pSrc2, int src2Step,
3406 IppiSize roiSize, Ipp64f* pValue))
3407
3408IPPAPI(IppStatus, ippiNormRel_L1_16u_C1R, (const Ipp16u* pSrc1, int src1Step,
3409 const Ipp16u* pSrc2, int src2Step,
3410 IppiSize roiSize, Ipp64f* pValue))
3411
3412IPPAPI(IppStatus, ippiNormRel_L1_32f_C1R, (const Ipp32f* pSrc1, int src1Step,
3413 const Ipp32f* pSrc2, int src2Step,
3414 IppiSize roiSize, Ipp64f* pValue, IppHintAlgorithm hint))
3415
3416
3417
3418/* //////////////////////////////////////////////////////////////////////////////////////////
3419// Name: ippiNormRel_L2
3420// Purpose: computes the relative error for the L2-norm of pixel values of two images:
3421// n = SQRT(SUM |src1 - src2|^2 / SUM |src2|^2)
3422// Context:
3423// Returns: IppStatus
3424// ippStsNoErr OK
3425// ippStsNullPtrErr One of the pointers is NULL
3426// ippStsSizeErr roiSize has a field with zero or negative value
3427// ippStsDivByZero SUM |src2|^2 == 0
3428// Parameters:
3429// pSrc1, pSrc2 Pointers to the source images.
3430// src1Step, src2Step Steps in bytes through the source images
3431// roiSize Size of the source ROI.
3432// pValue Pointer to the computed norm (one-channel data)
3433// value Array of the computed norms for each channel (multi-channel data)
3434// hint Option to specify the computation algorithm
3435// Notes:
3436*/
3437
3438IPPAPI(IppStatus, ippiNormRel_L2_8u_C1R, (const Ipp8u* pSrc1, int src1Step,
3439 const Ipp8u* pSrc2, int src2Step,
3440 IppiSize roiSize, Ipp64f* pValue))
3441
3442IPPAPI(IppStatus, ippiNormRel_L2_16s_C1R, (const Ipp16s* pSrc1, int src1Step,
3443 const Ipp16s* pSrc2, int src2Step,
3444 IppiSize roiSize, Ipp64f* pValue))
3445
3446IPPAPI(IppStatus, ippiNormRel_L2_16u_C1R, (const Ipp16u* pSrc1, int src1Step,
3447 const Ipp16u* pSrc2, int src2Step,
3448 IppiSize roiSize, Ipp64f* pValue))
3449
3450IPPAPI(IppStatus, ippiNormRel_L2_32f_C1R, (const Ipp32f* pSrc1, int src1Step,
3451 const Ipp32f* pSrc2, int src2Step,
3452 IppiSize roiSize, Ipp64f* pValue, IppHintAlgorithm hint))
3453
3454
3455/* /////////////////////////////////////////////////////////////////////////////
3456// Name: ippiNormDiff_Inf
3457// Purpose: computes the C-norm of pixel values of two images: n = MAX |src1 - src2|
3458// Context:
3459// Returns: IppStatus
3460// ippStsNoErr OK
3461// ippStsNullPtrErr One of the pointers is NULL
3462// ippStsSizeErr roiSize has a field with zero or negative value
3463// Parameters:
3464// pSrc1, pSrc2 Pointers to the source images.
3465// src1Step, src2Step Steps in bytes through the source images
3466// roiSize Size of the source ROI.
3467// pValue Pointer to the computed norm (one-channel data)
3468// value Array of the computed norms for each channel (multi-channel data)
3469// Notes:
3470*/
3471
3472IPPAPI(IppStatus, ippiNormDiff_Inf_8u_C1R, (const Ipp8u* pSrc1, int src1Step,
3473 const Ipp8u* pSrc2, int src2Step,
3474 IppiSize roiSize, Ipp64f* pValue))
3475
3476IPPAPI(IppStatus, ippiNormDiff_Inf_8u_C3R, (const Ipp8u* pSrc1, int src1Step,
3477 const Ipp8u* pSrc2, int src2Step,
3478 IppiSize roiSize, Ipp64f value[3]))
3479
3480IPPAPI(IppStatus, ippiNormDiff_Inf_8u_C4R, (const Ipp8u* pSrc1, int src1Step,
3481 const Ipp8u* pSrc2, int src2Step,
3482 IppiSize roiSize, Ipp64f value[4]))
3483
3484IPPAPI(IppStatus, ippiNormDiff_Inf_16s_C1R, (const Ipp16s* pSrc1, int src1Step,
3485 const Ipp16s* pSrc2, int src2Step,
3486 IppiSize roiSize, Ipp64f* pValue))
3487
3488IPPAPI(IppStatus, ippiNormDiff_Inf_16s_C3R, (const Ipp16s* pSrc1, int src1Step,
3489 const Ipp16s* pSrc2, int src2Step,
3490 IppiSize roiSize, Ipp64f value[3]))
3491
3492IPPAPI(IppStatus, ippiNormDiff_Inf_16s_C4R, (const Ipp16s* pSrc1, int src1Step,
3493 const Ipp16s* pSrc2, int src2Step,
3494 IppiSize roiSize, Ipp64f value[4]))
3495
3496IPPAPI(IppStatus, ippiNormDiff_Inf_16u_C1R, (const Ipp16u* pSrc1, int src1Step,
3497 const Ipp16u* pSrc2, int src2Step,
3498 IppiSize roiSize, Ipp64f* pValue))
3499
3500IPPAPI(IppStatus, ippiNormDiff_Inf_16u_C3R, (const Ipp16u* pSrc1, int src1Step,
3501 const Ipp16u* pSrc2, int src2Step,
3502 IppiSize roiSize, Ipp64f value[3]))
3503
3504IPPAPI(IppStatus, ippiNormDiff_Inf_16u_C4R, (const Ipp16u* pSrc1, int src1Step,
3505 const Ipp16u* pSrc2, int src2Step,
3506 IppiSize roiSize, Ipp64f value[4]))
3507
3508IPPAPI(IppStatus, ippiNormDiff_Inf_32f_C1R, (const Ipp32f* pSrc1, int src1Step,
3509 const Ipp32f* pSrc2, int src2Step,
3510 IppiSize roiSize, Ipp64f* pValue))
3511
3512IPPAPI(IppStatus, ippiNormDiff_Inf_32f_C3R, (const Ipp32f* pSrc1, int src1Step,
3513 const Ipp32f* pSrc2, int src2Step,
3514 IppiSize roiSize, Ipp64f value[3]))
3515
3516IPPAPI(IppStatus, ippiNormDiff_Inf_32f_C4R, (const Ipp32f* pSrc1, int src1Step,
3517 const Ipp32f* pSrc2, int src2Step,
3518 IppiSize roiSize, Ipp64f value[4]))
3519
3520/* /////////////////////////////////////////////////////////////////////////////
3521// Name: ippiNormDiff_L1
3522// Purpose: computes the L1-norm of pixel values of two images: n = SUM |src1 - src2|
3523// Context:
3524// Returns: IppStatus
3525// ippStsNoErr OK
3526// ippStsNullPtrErr One of the pointers is NULL
3527// ippStsSizeErr roiSize has a field with zero or negative value
3528// Parameters:
3529// pSrc1, pSrc2 Pointers to the source images.
3530// src1Step, src2Step Steps in bytes through the source images
3531// roiSize Size of the source ROI.
3532// pValue Pointer to the computed norm (one-channel data)
3533// value Array of the computed norms for each channel (multi-channel data)
3534// hint Option to specify the computation algorithm
3535// Notes:
3536*/
3537
3538IPPAPI(IppStatus, ippiNormDiff_L1_8u_C1R, (const Ipp8u* pSrc1, int src1Step,
3539 const Ipp8u* pSrc2, int src2Step,
3540 IppiSize roiSize, Ipp64f* pValue))
3541
3542IPPAPI(IppStatus, ippiNormDiff_L1_8u_C3R, (const Ipp8u* pSrc1, int src1Step,
3543 const Ipp8u* pSrc2, int src2Step,
3544 IppiSize roiSize, Ipp64f value[3]))
3545
3546IPPAPI(IppStatus, ippiNormDiff_L1_8u_C4R, (const Ipp8u* pSrc1, int src1Step,
3547 const Ipp8u* pSrc2, int src2Step,
3548 IppiSize roiSize, Ipp64f value[4]))
3549
3550IPPAPI(IppStatus, ippiNormDiff_L1_16s_C1R, (const Ipp16s* pSrc1, int src1Step,
3551 const Ipp16s* pSrc2, int src2Step,
3552 IppiSize roiSize, Ipp64f* pValue))
3553
3554IPPAPI(IppStatus, ippiNormDiff_L1_16s_C3R, (const Ipp16s* pSrc1, int src1Step,
3555 const Ipp16s* pSrc2, int src2Step,
3556 IppiSize roiSize, Ipp64f value[3]))
3557
3558IPPAPI(IppStatus, ippiNormDiff_L1_16s_C4R, (const Ipp16s* pSrc1, int src1Step,
3559 const Ipp16s* pSrc2, int src2Step,
3560 IppiSize roiSize, Ipp64f value[4]))
3561
3562IPPAPI(IppStatus, ippiNormDiff_L1_16u_C1R, (const Ipp16u* pSrc1, int src1Step,
3563 const Ipp16u* pSrc2, int src2Step,
3564 IppiSize roiSize, Ipp64f* pValue))
3565
3566IPPAPI(IppStatus, ippiNormDiff_L1_16u_C3R, (const Ipp16u* pSrc1, int src1Step,
3567 const Ipp16u* pSrc2, int src2Step,
3568 IppiSize roiSize, Ipp64f value[3]))
3569
3570IPPAPI(IppStatus, ippiNormDiff_L1_16u_C4R, (const Ipp16u* pSrc1, int src1Step,
3571 const Ipp16u* pSrc2, int src2Step,
3572 IppiSize roiSize, Ipp64f value[4]))
3573
3574IPPAPI(IppStatus, ippiNormDiff_L1_32f_C1R, (const Ipp32f* pSrc1, int src1Step,
3575 const Ipp32f* pSrc2, int src2Step,
3576 IppiSize roiSize, Ipp64f* pValue, IppHintAlgorithm hint))
3577
3578IPPAPI(IppStatus, ippiNormDiff_L1_32f_C3R, (const Ipp32f* pSrc1, int src1Step,
3579 const Ipp32f* pSrc2, int src2Step,
3580 IppiSize roiSize, Ipp64f value[3], IppHintAlgorithm hint))
3581
3582IPPAPI(IppStatus, ippiNormDiff_L1_32f_C4R, (const Ipp32f* pSrc1, int src1Step,
3583 const Ipp32f* pSrc2, int src2Step,
3584 IppiSize roiSize, Ipp64f value[4], IppHintAlgorithm hint))
3585
3586/* /////////////////////////////////////////////////////////////////////////////////
3587// Name: ippiNormDiff_L2
3588// Purpose: computes the L2-norm of pixel values of two images:
3589// n = SQRT(SUM |src1 - src2|^2)
3590// Context:
3591// Returns: IppStatus
3592// ippStsNoErr OK
3593// ippStsNullPtrErr One of the pointers is NULL
3594// ippStsSizeErr roiSize has a field with zero or negative value
3595// Parameters:
3596// pSrc1, pSrc2 Pointers to the source images.
3597// src1Step, src2Step Steps in bytes through the source images
3598// roiSize Size of the source ROI.
3599// pValue Pointer to the computed norm (one-channel data)
3600// value Array of the computed norms for each channel (multi-channel data)
3601// hint Option to specify the computation algorithm
3602// Notes:
3603*/
3604
3605IPPAPI(IppStatus, ippiNormDiff_L2_8u_C1R, (const Ipp8u* pSrc1, int src1Step,
3606 const Ipp8u* pSrc2, int src2Step,
3607 IppiSize roiSize, Ipp64f* pValue))
3608
3609IPPAPI(IppStatus, ippiNormDiff_L2_8u_C3R, (const Ipp8u* pSrc1, int src1Step,
3610 const Ipp8u* pSrc2, int src2Step,
3611 IppiSize roiSize, Ipp64f value[3]))
3612
3613IPPAPI(IppStatus, ippiNormDiff_L2_8u_C4R, (const Ipp8u* pSrc1, int src1Step,
3614 const Ipp8u* pSrc2, int src2Step,
3615 IppiSize roiSize, Ipp64f value[4]))
3616
3617IPPAPI(IppStatus, ippiNormDiff_L2_16s_C1R, (const Ipp16s* pSrc1, int src1Step,
3618 const Ipp16s* pSrc2, int src2Step,
3619 IppiSize roiSize, Ipp64f* pValue))
3620
3621IPPAPI(IppStatus, ippiNormDiff_L2_16s_C3R, (const Ipp16s* pSrc1, int src1Step,
3622 const Ipp16s* pSrc2, int src2Step,
3623 IppiSize roiSize, Ipp64f value[3]))
3624
3625IPPAPI(IppStatus, ippiNormDiff_L2_16s_C4R, (const Ipp16s* pSrc1, int src1Step,
3626 const Ipp16s* pSrc2, int src2Step,
3627 IppiSize roiSize, Ipp64f value[4]))
3628
3629IPPAPI(IppStatus, ippiNormDiff_L2_16u_C1R, (const Ipp16u* pSrc1, int src1Step,
3630 const Ipp16u* pSrc2, int src2Step,
3631 IppiSize roiSize, Ipp64f* pValue))
3632
3633IPPAPI(IppStatus, ippiNormDiff_L2_16u_C3R, (const Ipp16u* pSrc1, int src1Step,
3634 const Ipp16u* pSrc2, int src2Step,
3635 IppiSize roiSize, Ipp64f value[3]))
3636
3637IPPAPI(IppStatus, ippiNormDiff_L2_16u_C4R, (const Ipp16u* pSrc1, int src1Step,
3638 const Ipp16u* pSrc2, int src2Step,
3639 IppiSize roiSize, Ipp64f value[4]))
3640
3641IPPAPI(IppStatus, ippiNormDiff_L2_32f_C1R, (const Ipp32f* pSrc1, int src1Step,
3642 const Ipp32f* pSrc2, int src2Step,
3643 IppiSize roiSize, Ipp64f* pValue, IppHintAlgorithm hint))
3644
3645IPPAPI(IppStatus, ippiNormDiff_L2_32f_C3R, (const Ipp32f* pSrc1, int src1Step,
3646 const Ipp32f* pSrc2, int src2Step,
3647 IppiSize roiSize, Ipp64f value[3], IppHintAlgorithm hint))
3648
3649IPPAPI(IppStatus, ippiNormDiff_L2_32f_C4R, (const Ipp32f* pSrc1, int src1Step,
3650 const Ipp32f* pSrc2, int src2Step,
3651 IppiSize roiSize, Ipp64f value[4], IppHintAlgorithm hint))
3652
3653
3654/* ////////////////////////////////////////////////////////////////////////////
3655// Name: ippiSwapChannels
3656//
3657// Purpose: Changes the order of channels of the image
3658// The function performs operation for each pixel:
3659// pDst[0] = pSrc[ dstOrder[0] ]
3660// pDst[1] = pSrc[ dstOrder[1] ]
3661// pDst[2] = pSrc[ dstOrder[2] ]
3662// pDst[3] = pSrc[ dstOrder[3] ]
3663//
3664// Returns:
3665// ippStsNullPtrErr One of the pointers is NULL
3666// ippStsSizeErr roiSize has a field with zero or negative value
3667// ippStsStepErr One of the step values is less than or equal to zero
3668// ippStsChannelOrderErr dstOrder is out of the range,
3669// it should be: dstOrder[3] = { 0..2, 0..2, 0..2 } for C3R, AC4R image
3670// and dstOrder[4] = { 0..3, 0..3, 0..3 } for C4R image
3671// ippStsNoErr OK
3672//
3673// Parameters:
3674// pSrc Pointer to the source image
3675// srcStep Step in bytes through the source image
3676// pDst Pointer to the destination image
3677// dstStep Step in bytes through the destination image
3678// pSrcDst Pointer to the source/destination image (in-place flavors)
3679// srcDstStep Step through the source/destination image (in-place flavors)
3680// roiSize Size of the ROI
3681// dstOrder The order of channels in the destination image
3682*/
3683IPPAPI ( IppStatus, ippiSwapChannels_8u_C3R,
3684 ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
3685 IppiSize roiSize, const int dstOrder[3] ))
3686IPPAPI ( IppStatus, ippiSwapChannels_8u_C4R,
3687 ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
3688 IppiSize roiSize, const int dstOrder[4] ))
3689IPPAPI ( IppStatus, ippiSwapChannels_16u_C3R,
3690 ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
3691 IppiSize roiSize, const int dstOrder[3] ))
3692IPPAPI ( IppStatus, ippiSwapChannels_16u_C4R,
3693 ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
3694 IppiSize roiSize, const int dstOrder[4] ))
3695IPPAPI ( IppStatus, ippiSwapChannels_32f_C3R,
3696 ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
3697 IppiSize roiSize, const int dstOrder[3] ))
3698IPPAPI ( IppStatus, ippiSwapChannels_32f_C4R,
3699 ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
3700 IppiSize roiSize, const int dstOrder[4] ))
3701
3702IPPAPI ( IppStatus, ippiSwapChannels_8u_C3IR,
3703 ( Ipp8u* pSrcDst, int srcDstStep,
3704 IppiSize roiSize, const int dstOrder[3] ))
3705
3706IPPAPI ( IppStatus, ippiSwapChannels_8u_C4IR,
3707 ( Ipp8u* pSrcDst, int srcDstStep,
3708 IppiSize roiSize, const int dstOrder[4] ))
3709
3710/* ////////////////////////////////////////////////////////////////////////////
3711// Name: ippiSwapChannels C3C4R,C4C3R
3712//
3713// Purpose: Changes the order of channels of the image
3714// The function performs operation for each pixel:
3715// a) C3C4R.
3716// if(dstOrder[i] < 3) dst[i] = src[dstOrder[i]];
3717// if(dstOrder[i] == 3) dst[i] = val;
3718// if(dstOrder[i] > 3) dst[i] does not change;
3719// i = 0,1,2,3
3720// b) C4C3R.
3721// dst[0] = src [dstOrder[0]];
3722// dst[1] = src [dstOrder[1]];
3723// dst[2] = src [dstOrder[2]];
3724//
3725// Returns:
3726// ippStsNullPtrErr One of the pointers is NULL
3727// ippStsSizeErr roiSize has a field with zero or negative value
3728// ippStsChannelOrderErr dstOrder is out of the range, it should be:
3729// a) C3C4R.
3730// dstOrder[i] => 0, i = 0,1,2,3.
3731// b) C4C3R.
3732// 0 <= dstOrder[i] <= 3, i = 0,1,2.
3733// ippStsNoErr OK
3734//
3735// Parameters:
3736// pSrc Pointer to the source image
3737// srcStep Step in bytes through the source image
3738// pDst Pointer to the destination image
3739// dstStep Step in bytes through the destination image
3740// roiSize Size of the ROI
3741// dstOrder The order of channels in the destination image
3742// val Constant value for C3C4R
3743*/
3744IPPAPI ( IppStatus, ippiSwapChannels_8u_C3C4R,
3745 ( const Ipp8u* pSrc, int srcStep,
3746 Ipp8u* pDst, int dstStep, IppiSize roiSize,
3747 const int dstOrder[4], Ipp8u val ))
3748IPPAPI ( IppStatus, ippiSwapChannels_8u_C4C3R,
3749 ( const Ipp8u* pSrc, int srcStep,
3750 Ipp8u* pDst, int dstStep, IppiSize roiSize,
3751 const int dstOrder[3] ))
3752IPPAPI ( IppStatus, ippiSwapChannels_16s_C3C4R,
3753 ( const Ipp16s* pSrc, int srcStep,
3754 Ipp16s* pDst, int dstStep, IppiSize roiSize,
3755 const int dstOrder[4], Ipp16s val ))
3756IPPAPI ( IppStatus, ippiSwapChannels_16u_C3C4R,
3757 ( const Ipp16u* pSrc, int srcStep,
3758 Ipp16u* pDst, int dstStep, IppiSize roiSize,
3759 const int dstOrder[4], Ipp16u val ))
3760IPPAPI ( IppStatus, ippiSwapChannels_16u_C4C3R,
3761 ( const Ipp16u* pSrc, int srcStep,
3762 Ipp16u* pDst, int dstStep, IppiSize roiSize,
3763 const int dstOrder[3] ))
3764IPPAPI ( IppStatus, ippiSwapChannels_32s_C3C4R,
3765 ( const Ipp32s* pSrc, int srcStep,
3766 Ipp32s* pDst, int dstStep, IppiSize roiSize,
3767 const int dstOrder[4], Ipp32s val ))
3768IPPAPI ( IppStatus, ippiSwapChannels_32f_C3C4R,
3769 ( const Ipp32f* pSrc, int srcStep,
3770 Ipp32f* pDst, int dstStep, IppiSize roiSize,
3771 const int dstOrder[4], Ipp32f val ))
3772IPPAPI ( IppStatus, ippiSwapChannels_32f_C4C3R,
3773 ( const Ipp32f* pSrc, int srcStep,
3774 Ipp32f* pDst, int dstStep, IppiSize roiSize,
3775 const int dstOrder[3] ))
3776
3777/* ////////////////////////////////////////////////////////////////////////////
3778// Name: ippiCopy
3779//
3780// Purpose: copy pixel values from the source image to the destination image
3781//
3782//
3783// Returns:
3784// ippStsNullPtrErr One of the pointers is NULL
3785// ippStsSizeErr roiSize has a field with zero or negative value
3786// ippStsNoErr OK
3787//
3788// Parameters:
3789// pSrc Pointer to the source image buffer
3790// srcStep Step in bytes through the source image buffer
3791// pDst Pointer to the destination image buffer
3792// dstStep Step in bytes through the destination image buffer
3793// roiSize Size of the ROI
3794// pMask Pointer to the mask image buffer
3795// maskStep Step in bytes through the mask image buffer
3796*/
3797
3798IPPAPI( IppStatus, ippiCopy_8u_C3C1R,
3799 ( const Ipp8u* pSrc, int srcStep,
3800 Ipp8u* pDst, int dstStep, IppiSize roiSize ))
3801IPPAPI( IppStatus, ippiCopy_8u_C1C3R,
3802 ( const Ipp8u* pSrc, int srcStep,
3803 Ipp8u* pDst, int dstStep, IppiSize roiSize ))
3804IPPAPI( IppStatus, ippiCopy_8u_C4C1R,
3805 ( const Ipp8u* pSrc, int srcStep,
3806 Ipp8u* pDst, int dstStep, IppiSize roiSize ))
3807IPPAPI( IppStatus, ippiCopy_8u_C1C4R,
3808 ( const Ipp8u* pSrc, int srcStep,
3809 Ipp8u* pDst, int dstStep, IppiSize roiSize ))
3810IPPAPI( IppStatus, ippiCopy_8u_C3CR,
3811 ( const Ipp8u* pSrc, int srcStep,
3812 Ipp8u* pDst, int dstStep, IppiSize roiSize ))
3813IPPAPI( IppStatus, ippiCopy_8u_C4CR,
3814 ( const Ipp8u* pSrc, int srcStep,
3815 Ipp8u* pDst, int dstStep, IppiSize roiSize ))
3816IPPAPI( IppStatus, ippiCopy_8u_AC4C3R,
3817 ( const Ipp8u* pSrc, int srcStep,
3818 Ipp8u* pDst, int dstStep, IppiSize roiSize ))
3819IPPAPI( IppStatus, ippiCopy_8u_C3AC4R,
3820 ( const Ipp8u* pSrc, int srcStep,
3821 Ipp8u* pDst, int dstStep, IppiSize roiSize ))
3822
3823IPPAPI ( IppStatus, ippiCopy_8u_C1MR,
3824 ( const Ipp8u* pSrc, int srcStep,
3825 Ipp8u* pDst, int dstStep,IppiSize roiSize,
3826 const Ipp8u* pMask, int maskStep ))
3827IPPAPI ( IppStatus, ippiCopy_8u_C3MR,
3828 ( const Ipp8u* pSrc, int srcStep,
3829 Ipp8u* pDst, int dstStep,IppiSize roiSize,
3830 const Ipp8u* pMask, int maskStep ))
3831IPPAPI ( IppStatus, ippiCopy_8u_C4MR,
3832 ( const Ipp8u* pSrc, int srcStep,
3833 Ipp8u* pDst, int dstStep,IppiSize roiSize,
3834 const Ipp8u* pMask, int maskStep ))
3835
3836IPPAPI( IppStatus, ippiCopy_16s_C3C1R,
3837 ( const Ipp16s* pSrc, int srcStep,
3838 Ipp16s* pDst, int dstStep, IppiSize roiSize ))
3839IPPAPI( IppStatus, ippiCopy_16s_C1C3R,
3840 ( const Ipp16s* pSrc, int srcStep,
3841 Ipp16s* pDst, int dstStep, IppiSize roiSize ))
3842IPPAPI( IppStatus, ippiCopy_16s_C4C1R,
3843 ( const Ipp16s* pSrc, int srcStep,
3844 Ipp16s* pDst, int dstStep, IppiSize roiSize ))
3845IPPAPI( IppStatus, ippiCopy_16s_C1C4R,
3846 ( const Ipp16s* pSrc, int srcStep,
3847 Ipp16s* pDst, int dstStep, IppiSize roiSize ))
3848IPPAPI( IppStatus, ippiCopy_16s_C3CR,
3849 ( const Ipp16s* pSrc, int srcStep,
3850 Ipp16s* pDst, int dstStep, IppiSize roiSize ))
3851IPPAPI( IppStatus, ippiCopy_16s_C4CR,
3852 ( const Ipp16s* pSrc, int srcStep,
3853 Ipp16s* pDst, int dstStep, IppiSize roiSize ))
3854
3855IPPAPI ( IppStatus, ippiCopy_16s_C1R,
3856 ( const Ipp16s* pSrc, int srcStep,
3857 Ipp16s* pDst, int dstStep,IppiSize roiSize ))
3858
3859IPPAPI ( IppStatus, ippiCopy_16s_C1MR,
3860 ( const Ipp16s* pSrc, int srcStep,
3861 Ipp16s* pDst, int dstStep,IppiSize roiSize,
3862 const Ipp8u* pMask, int maskStep ))
3863IPPAPI ( IppStatus, ippiCopy_16s_C3MR,
3864 ( const Ipp16s* pSrc, int srcStep,
3865 Ipp16s* pDst, int dstStep,IppiSize roiSize,
3866 const Ipp8u* pMask, int maskStep ))
3867IPPAPI ( IppStatus, ippiCopy_16s_C4MR,
3868 ( const Ipp16s* pSrc, int srcStep,
3869 Ipp16s* pDst, int dstStep,IppiSize roiSize,
3870 const Ipp8u* pMask, int maskStep ))
3871
3872IPPAPI( IppStatus, ippiCopy_32f_C3C1R,
3873 ( const Ipp32f* pSrc, int srcStep,
3874 Ipp32f* pDst, int dstStep, IppiSize roiSize ))
3875IPPAPI( IppStatus, ippiCopy_32f_C1C3R,
3876 ( const Ipp32f* pSrc, int srcStep,
3877 Ipp32f* pDst, int dstStep, IppiSize roiSize ))
3878IPPAPI( IppStatus, ippiCopy_32f_C4C1R,
3879 ( const Ipp32f* pSrc, int srcStep,
3880 Ipp32f* pDst, int dstStep, IppiSize roiSize ))
3881IPPAPI( IppStatus, ippiCopy_32f_C1C4R,
3882 ( const Ipp32f* pSrc, int srcStep,
3883 Ipp32f* pDst, int dstStep, IppiSize roiSize ))
3884IPPAPI( IppStatus, ippiCopy_32f_C3CR,
3885 ( const Ipp32f* pSrc, int srcStep,
3886 Ipp32f* pDst, int dstStep, IppiSize roiSize ))
3887IPPAPI( IppStatus, ippiCopy_32f_C4CR,
3888 ( const Ipp32f* pSrc, int srcStep,
3889 Ipp32f* pDst, int dstStep, IppiSize roiSize ))
3890IPPAPI( IppStatus, ippiCopy_32f_AC4C3R,
3891 ( const Ipp32f* pSrc, int srcStep,
3892 Ipp32f* pDst, int dstStep, IppiSize roiSize ))
3893IPPAPI( IppStatus, ippiCopy_32f_C3AC4R,
3894 ( const Ipp32f* pSrc, int srcStep,
3895 Ipp32f* pDst, int dstStep, IppiSize roiSize ))
3896
3897IPPAPI ( IppStatus, ippiCopy_32f_C1R,
3898 ( const Ipp32f* pSrc, int srcStep,
3899 Ipp32f* pDst, int dstStep,IppiSize roiSize ))
3900
3901IPPAPI ( IppStatus, ippiCopy_32f_C1MR,
3902 ( const Ipp32f* pSrc, int srcStep,
3903 Ipp32f* pDst, int dstStep,IppiSize roiSize,
3904 const Ipp8u* pMask, int maskStep ))
3905IPPAPI ( IppStatus, ippiCopy_32f_C3MR,
3906 ( const Ipp32f* pSrc, int srcStep,
3907 Ipp32f* pDst, int dstStep,IppiSize roiSize,
3908 const Ipp8u* pMask, int maskStep ))
3909IPPAPI ( IppStatus, ippiCopy_32f_C4MR,
3910 ( const Ipp32f* pSrc, int srcStep,
3911 Ipp32f* pDst, int dstStep,IppiSize roiSize,
3912 const Ipp8u* pMask, int maskStep ))
3913
3914IPPAPI ( IppStatus, ippiCopy_8u_C3P3R, ( const Ipp8u* pSrc, int srcStep,
3915 Ipp8u* const pDst[3], int dstStep, IppiSize roiSize ))
3916IPPAPI ( IppStatus, ippiCopy_8u_P3C3R, (const Ipp8u* const pSrc[3],
3917 int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
3918IPPAPI ( IppStatus, ippiCopy_8u_C4P4R, ( const Ipp8u* pSrc, int srcStep,
3919 Ipp8u* const pDst[4], int dstStep, IppiSize roiSize ))
3920IPPAPI ( IppStatus, ippiCopy_8u_P4C4R, (const Ipp8u* const pSrc[4],
3921 int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
3922IPPAPI ( IppStatus, ippiCopy_16s_C3P3R, ( const Ipp16s* pSrc, int srcStep,
3923 Ipp16s* const pDst[3], int dstStep, IppiSize roiSize ))
3924IPPAPI ( IppStatus, ippiCopy_16s_P3C3R, (const Ipp16s* const pSrc[3],
3925 int srcStep, Ipp16s* pDst, int dstStep, IppiSize roiSize ))
3926IPPAPI ( IppStatus, ippiCopy_16s_C4P4R, ( const Ipp16s* pSrc, int srcStep,
3927 Ipp16s* const pDst[4], int dstStep, IppiSize roiSize ))
3928IPPAPI ( IppStatus, ippiCopy_16s_P4C4R, (const Ipp16s* const pSrc[4],
3929 int srcStep, Ipp16s* pDst, int dstStep, IppiSize roiSize ))
3930IPPAPI ( IppStatus, ippiCopy_32f_C3P3R, ( const Ipp32f* pSrc, int srcStep,
3931 Ipp32f* const pDst[3], int dstStep, IppiSize roiSize ))
3932IPPAPI ( IppStatus, ippiCopy_32f_P3C3R, (const Ipp32f* const pSrc[3],
3933 int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize ))
3934IPPAPI ( IppStatus, ippiCopy_32f_C4P4R, ( const Ipp32f* pSrc, int srcStep,
3935 Ipp32f* const pDst[4], int dstStep, IppiSize roiSize ))
3936IPPAPI ( IppStatus, ippiCopy_32f_P4C4R, (const Ipp32f* const pSrc[4],
3937 int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize ))
3938
3939IPPAPI( IppStatus, ippiCopy_32s_C3C1R,
3940 ( const Ipp32s* pSrc, int srcStep,
3941 Ipp32s* pDst, int dstStep, IppiSize roiSize ))
3942IPPAPI( IppStatus, ippiCopy_32s_C1C3R,
3943 ( const Ipp32s* pSrc, int srcStep,
3944 Ipp32s* pDst, int dstStep, IppiSize roiSize ))
3945IPPAPI( IppStatus, ippiCopy_32s_C4C1R,
3946 ( const Ipp32s* pSrc, int srcStep,
3947 Ipp32s* pDst, int dstStep, IppiSize roiSize ))
3948IPPAPI( IppStatus, ippiCopy_32s_C1C4R,
3949 ( const Ipp32s* pSrc, int srcStep,
3950 Ipp32s* pDst, int dstStep, IppiSize roiSize ))
3951IPPAPI( IppStatus, ippiCopy_32s_C3CR,
3952 ( const Ipp32s* pSrc, int srcStep,
3953 Ipp32s* pDst, int dstStep, IppiSize roiSize ))
3954IPPAPI( IppStatus, ippiCopy_32s_C4CR,
3955 ( const Ipp32s* pSrc, int srcStep,
3956 Ipp32s* pDst, int dstStep, IppiSize roiSize ))
3957
3958IPPAPI ( IppStatus, ippiCopy_32s_C1R,
3959 ( const Ipp32s* pSrc, int srcStep,
3960 Ipp32s* pDst, int dstStep,IppiSize roiSize ))
3961
3962IPPAPI ( IppStatus, ippiCopy_32s_C1MR,
3963 ( const Ipp32s* pSrc, int srcStep,
3964 Ipp32s* pDst, int dstStep,IppiSize roiSize,
3965 const Ipp8u* pMask, int maskStep ))
3966IPPAPI ( IppStatus, ippiCopy_32s_C3MR,
3967 ( const Ipp32s* pSrc, int srcStep,
3968 Ipp32s* pDst, int dstStep,IppiSize roiSize,
3969 const Ipp8u* pMask, int maskStep ))
3970IPPAPI ( IppStatus, ippiCopy_32s_C4MR,
3971 ( const Ipp32s* pSrc, int srcStep,
3972 Ipp32s* pDst, int dstStep,IppiSize roiSize,
3973 const Ipp8u* pMask, int maskStep ))
3974
3975IPPAPI ( IppStatus, ippiCopy_32s_C3P3R, ( const Ipp32s* pSrc, int srcStep,
3976 Ipp32s* const pDst[3], int dstStep, IppiSize roiSize ))
3977IPPAPI ( IppStatus, ippiCopy_32s_P3C3R, (const Ipp32s* const pSrc[3],
3978 int srcStep, Ipp32s* pDst, int dstStep, IppiSize roiSize ))
3979IPPAPI ( IppStatus, ippiCopy_32s_C4P4R, ( const Ipp32s* pSrc, int srcStep,
3980 Ipp32s* const pDst[4], int dstStep, IppiSize roiSize ))
3981IPPAPI ( IppStatus, ippiCopy_32s_P4C4R, (const Ipp32s* const pSrc[4],
3982 int srcStep, Ipp32s* pDst, int dstStep, IppiSize roiSize ))
3983
3984IPPAPI( IppStatus, ippiCopy_16u_C3C1R,
3985 ( const Ipp16u* pSrc, int srcStep,
3986 Ipp16u* pDst, int dstStep, IppiSize roiSize ))
3987IPPAPI( IppStatus, ippiCopy_16u_C1C3R,
3988 ( const Ipp16u* pSrc, int srcStep,
3989 Ipp16u* pDst, int dstStep, IppiSize roiSize ))
3990IPPAPI( IppStatus, ippiCopy_16u_C4C1R,
3991 ( const Ipp16u* pSrc, int srcStep,
3992 Ipp16u* pDst, int dstStep, IppiSize roiSize ))
3993IPPAPI( IppStatus, ippiCopy_16u_C1C4R,
3994 ( const Ipp16u* pSrc, int srcStep,
3995 Ipp16u* pDst, int dstStep, IppiSize roiSize ))
3996IPPAPI( IppStatus, ippiCopy_16u_C3CR,
3997 ( const Ipp16u* pSrc, int srcStep,
3998 Ipp16u* pDst, int dstStep, IppiSize roiSize ))
3999IPPAPI( IppStatus, ippiCopy_16u_C4CR,
4000 ( const Ipp16u* pSrc, int srcStep,
4001 Ipp16u* pDst, int dstStep, IppiSize roiSize ))
4002IPPAPI( IppStatus, ippiCopy_16u_AC4C3R,
4003 ( const Ipp16u* pSrc, int srcStep,
4004 Ipp16u* pDst, int dstStep, IppiSize roiSize ))
4005IPPAPI( IppStatus, ippiCopy_16u_C3AC4R,
4006 ( const Ipp16u* pSrc, int srcStep,
4007 Ipp16u* pDst, int dstStep, IppiSize roiSize ))
4008
4009IPPAPI ( IppStatus, ippiCopy_16u_C1MR,
4010 ( const Ipp16u* pSrc, int srcStep,
4011 Ipp16u* pDst, int dstStep,IppiSize roiSize,
4012 const Ipp8u* pMask, int maskStep ))
4013IPPAPI ( IppStatus, ippiCopy_16u_C3MR,
4014 ( const Ipp16u* pSrc, int srcStep,
4015 Ipp16u* pDst, int dstStep,IppiSize roiSize,
4016 const Ipp8u* pMask, int maskStep ))
4017IPPAPI ( IppStatus, ippiCopy_16u_C4MR,
4018 ( const Ipp16u* pSrc, int srcStep,
4019 Ipp16u* pDst, int dstStep,IppiSize roiSize,
4020 const Ipp8u* pMask, int maskStep ))
4021
4022IPPAPI ( IppStatus, ippiCopy_16u_C3P3R, ( const Ipp16u* pSrc, int srcStep,
4023 Ipp16u* const pDst[3], int dstStep, IppiSize roiSize ))
4024IPPAPI ( IppStatus, ippiCopy_16u_P3C3R, (const Ipp16u* const pSrc[3],
4025 int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize ))
4026IPPAPI ( IppStatus, ippiCopy_16u_C4P4R, ( const Ipp16u* pSrc, int srcStep,
4027 Ipp16u* const pDst[4], int dstStep, IppiSize roiSize ))
4028IPPAPI ( IppStatus, ippiCopy_16u_P4C4R, (const Ipp16u* const pSrc[4],
4029 int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize ))
4030
4031
4032/* /////////////////////////////////////////////////////////////////////////////
4033// Name: ippiSet
4034//
4035// Purpose: Sets pixels in the image buffer to a constant value
4036//
4037// Returns:
4038// ippStsNullPtrErr One of pointers is NULL
4039// ippStsSizeErr roiSize has a field with negative or zero value
4040// ippStsNoErr OK
4041//
4042// Parameters:
4043// value Constant value assigned to each pixel in the image buffer
4044// pDst Pointer to the destination image buffer
4045// dstStep Step in bytes through the destination image buffer
4046// roiSize Size of the ROI
4047// pMask Pointer to the mask image buffer
4048// maskStep Step in bytes through the mask image buffer
4049*/
4050
4051IPPAPI ( IppStatus, ippiSet_8u_C1R,
4052 ( Ipp8u value, Ipp8u* pDst, int dstStep,
4053 IppiSize roiSize ))
4054IPPAPI ( IppStatus, ippiSet_8u_C3CR,
4055 ( Ipp8u value, Ipp8u* pDst, int dstStep,
4056 IppiSize roiSize ))
4057IPPAPI ( IppStatus, ippiSet_8u_C4CR,
4058 ( Ipp8u value, Ipp8u* pDst, int dstStep,
4059 IppiSize roiSize ))
4060IPPAPI ( IppStatus, ippiSet_8u_C3R,
4061 ( const Ipp8u value[3], Ipp8u* pDst, int dstStep,
4062 IppiSize roiSize ))
4063IPPAPI ( IppStatus, ippiSet_8u_C4R,
4064 ( const Ipp8u value[4], Ipp8u* pDst, int dstStep,
4065 IppiSize roiSize ))
4066
4067IPPAPI ( IppStatus, ippiSet_8u_C1MR,
4068 ( Ipp8u value, Ipp8u* pDst, int dstStep,
4069 IppiSize roiSize,
4070 const Ipp8u* pMask, int maskStep ))
4071IPPAPI ( IppStatus, ippiSet_8u_C3MR,
4072 ( const Ipp8u value[3], Ipp8u* pDst, int dstStep,
4073 IppiSize roiSize,
4074 const Ipp8u* pMask, int maskStep ))
4075IPPAPI ( IppStatus, ippiSet_8u_C4MR,
4076 ( const Ipp8u value[4], Ipp8u* pDst, int dstStep,
4077 IppiSize roiSize,
4078 const Ipp8u* pMask, int maskStep ))
4079
4080IPPAPI ( IppStatus, ippiSet_16s_C1R,
4081 ( Ipp16s value, Ipp16s* pDst, int dstStep,
4082 IppiSize roiSize ))
4083IPPAPI ( IppStatus, ippiSet_16s_C3CR,
4084 ( Ipp16s value, Ipp16s* pDst, int dstStep,
4085 IppiSize roiSize ))
4086IPPAPI ( IppStatus, ippiSet_16s_C4CR,
4087 ( Ipp16s value, Ipp16s* pDst, int dstStep,
4088 IppiSize roiSize ))
4089IPPAPI ( IppStatus, ippiSet_16s_C3R,
4090 ( const Ipp16s value[3], Ipp16s* pDst, int dstStep,
4091 IppiSize roiSize ))
4092IPPAPI ( IppStatus, ippiSet_16s_C4R,
4093 ( const Ipp16s value[4], Ipp16s* pDst, int dstStep,
4094 IppiSize roiSize ))
4095
4096IPPAPI ( IppStatus, ippiSet_16s_C1MR,
4097 ( Ipp16s value, Ipp16s* pDst, int dstStep,
4098 IppiSize roiSize,
4099 const Ipp8u* pMask, int maskStep ))
4100IPPAPI ( IppStatus, ippiSet_16s_C3MR,
4101 ( const Ipp16s value[3], Ipp16s* pDst, int dstStep,
4102 IppiSize roiSize,
4103 const Ipp8u* pMask, int maskStep ))
4104IPPAPI ( IppStatus, ippiSet_16s_C4MR,
4105 ( const Ipp16s value[4], Ipp16s* pDst, int dstStep,
4106 IppiSize roiSize,
4107 const Ipp8u* pMask, int maskStep ))
4108
4109IPPAPI ( IppStatus, ippiSet_32f_C1R,
4110 ( Ipp32f value, Ipp32f* pDst, int dstStep,
4111 IppiSize roiSize ))
4112IPPAPI ( IppStatus, ippiSet_32f_C3CR,
4113 ( Ipp32f value, Ipp32f* pDst, int dstStep,
4114 IppiSize roiSize ))
4115IPPAPI ( IppStatus, ippiSet_32f_C4CR,
4116 ( Ipp32f value, Ipp32f* pDst, int dstStep,
4117 IppiSize roiSize ))
4118IPPAPI ( IppStatus, ippiSet_32f_C3R,
4119 ( const Ipp32f value[3], Ipp32f* pDst, int dstStep,
4120 IppiSize roiSize ))
4121IPPAPI ( IppStatus, ippiSet_32f_C4R,
4122 ( const Ipp32f value[4], Ipp32f* pDst, int dstStep,
4123 IppiSize roiSize ))
4124
4125IPPAPI ( IppStatus, ippiSet_32f_C1MR,
4126 ( Ipp32f value, Ipp32f* pDst, int dstStep,
4127 IppiSize roiSize,
4128 const Ipp8u* pMask, int maskStep ))
4129IPPAPI ( IppStatus, ippiSet_32f_C3MR,
4130 ( const Ipp32f value[3], Ipp32f* pDst, int dstStep,
4131 IppiSize roiSize,
4132 const Ipp8u* pMask, int maskStep ))
4133IPPAPI ( IppStatus, ippiSet_32f_C4MR,
4134 ( const Ipp32f value[4], Ipp32f* pDst, int dstStep,
4135 IppiSize roiSize,
4136 const Ipp8u* pMask, int maskStep ))
4137
4138IPPAPI ( IppStatus, ippiSet_32s_C1R,
4139 ( Ipp32s value, Ipp32s* pDst, int dstStep,
4140 IppiSize roiSize ))
4141IPPAPI ( IppStatus, ippiSet_32s_C3CR,
4142 ( Ipp32s value, Ipp32s* pDst, int dstStep,
4143 IppiSize roiSize ))
4144IPPAPI ( IppStatus, ippiSet_32s_C4CR,
4145 ( Ipp32s value, Ipp32s* pDst, int dstStep,
4146 IppiSize roiSize ))
4147IPPAPI ( IppStatus, ippiSet_32s_C3R,
4148 ( const Ipp32s value[3], Ipp32s* pDst, int dstStep,
4149 IppiSize roiSize ))
4150IPPAPI ( IppStatus, ippiSet_32s_C4R,
4151 ( const Ipp32s value[4], Ipp32s* pDst, int dstStep,
4152 IppiSize roiSize ))
4153
4154IPPAPI ( IppStatus, ippiSet_32s_C1MR,
4155 ( Ipp32s value, Ipp32s* pDst, int dstStep,
4156 IppiSize roiSize,
4157 const Ipp8u* pMask, int maskStep ))
4158IPPAPI ( IppStatus, ippiSet_32s_C3MR,
4159 ( const Ipp32s value[3], Ipp32s* pDst, int dstStep,
4160 IppiSize roiSize,
4161 const Ipp8u* pMask, int maskStep ))
4162IPPAPI ( IppStatus, ippiSet_32s_C4MR,
4163 ( const Ipp32s value[4], Ipp32s* pDst, int dstStep,
4164 IppiSize roiSize,
4165 const Ipp8u* pMask, int maskStep ))
4166
4167IPPAPI ( IppStatus, ippiSet_16u_C1R,
4168 ( Ipp16u value, Ipp16u* pDst, int dstStep,
4169 IppiSize roiSize ))
4170IPPAPI ( IppStatus, ippiSet_16u_C3CR,
4171 ( Ipp16u value, Ipp16u* pDst, int dstStep,
4172 IppiSize roiSize ))
4173IPPAPI ( IppStatus, ippiSet_16u_C4CR,
4174 ( Ipp16u value, Ipp16u* pDst, int dstStep,
4175 IppiSize roiSize ))
4176IPPAPI ( IppStatus, ippiSet_16u_C3R,
4177 ( const Ipp16u value[3], Ipp16u* pDst, int dstStep,
4178 IppiSize roiSize ))
4179IPPAPI ( IppStatus, ippiSet_16u_C4R,
4180 ( const Ipp16u value[4], Ipp16u* pDst, int dstStep,
4181 IppiSize roiSize ))
4182
4183IPPAPI ( IppStatus, ippiSet_16u_C1MR,
4184 ( Ipp16u value, Ipp16u* pDst, int dstStep,
4185 IppiSize roiSize,
4186 const Ipp8u* pMask, int maskStep ))
4187IPPAPI ( IppStatus, ippiSet_16u_C3MR,
4188 ( const Ipp16u value[3], Ipp16u* pDst, int dstStep,
4189 IppiSize roiSize,
4190 const Ipp8u* pMask, int maskStep ))
4191IPPAPI ( IppStatus, ippiSet_16u_C4MR,
4192 ( const Ipp16u value[4], Ipp16u* pDst, int dstStep,
4193 IppiSize roiSize,
4194 const Ipp8u* pMask, int maskStep ))
4195
4196
4197/* //////////////////////////////////////////////////////////////////////////////////////
4198// Image Proximity Measures
4199////////////////////////////////////////////////////////////////////////////////////// */
4200
4201/* /////////////////////////////////////////////////////////////////////////////
4202// Names: ippiCrossCorrNormGetBufferSize
4203//
4204// Purpose: Computes the size (in bytes) of the work buffer for the ippiCrossCorrNorm functions.
4205//
4206// Parameters:
4207// srcRoiSize - Size of the source ROI in pixels.
4208// tplRoiSize - Size of the template ROI in pixels.
4209// algType - Bit-field mask for the algorithm type definition. Possible values are the results of composition of the IppAlgType, IppiROIShape, and IppiNormOp values.
4210// Usage example: algType=(ippiROIFull|ippAlgFFT|ippiNormalized); - full-shaped cross-correlation will be calculated
4211// using 2D FFT and normalization applied to result image.
4212// pBufferSize - Pointer to the size of the work buffer (in bytes).
4213// Return:
4214// ippStsNoErr - OK.
4215// ippStsSizeErr - Error when:
4216// srcRoiSize or tplRoiSize is negative, or equal to zero.
4217// The value of srcRoiSize is less than the corresponding value of the tplRoiSize.
4218// ippStsAlgTypeErr - Error when :
4219// The result of the bitwise AND operation between the algType and ippAlgMask differs from the ippAlgAuto, ippAlgDirect, or ippAlgFFT values.
4220// The result of the bitwise AND operation between the algType and ippiROIMask differs from the ippiROIFull, ippiROISame, or ippiROIValid values.
4221// The result of the bitwise AND operation between the algType and ippiNormMask differs from the ippiNormNone, ippiNormalized, or ippiNormCoefficients values.
4222// ippStsNullPtrErr - Error when the pBufferSize is NULL.
4223*/
4224IPPAPI( IppStatus, ippiCrossCorrNormGetBufferSize, ( IppiSize srcRoiSize, IppiSize tplRoiSize, IppEnum algType, int* pBufferSize ))
4225
4226
4227/* ////////////////////////////////////////////////////////////////////////////
4228// Names: ippiCrossCorrNorm_32f_C1R
4229// ippiCrossCorrNorm_16u32f_C1R
4230// ippiCrossCorrNorm_8u32f_C1R
4231// ippiCrossCorrNorm_8u_C1RSfs
4232// Purpose: Computes normalized cross-correlation between an image and a template.
4233// The result image size depends on operation shape selected in algType mask as follows :
4234// (Wa+Wb-1)*(Ha+Hb-1) for ippiROIFull mask,
4235// (Wa)*(Ha) for ippiROISame mask,
4236// (Wa-Wb+1)*(Ha-Hb+1) for ippiROIValid mask,
4237// where Wa*Ha and Wb*Hb are the sizes of the image and template correspondingly.
4238// Support of normalization operations (set in the algType mask) is set by selecting the following masks:
4239// ippiNormNone - the cross-correlation without normalization.
4240// ippiNormalized - the normalized cross-correlation.
4241// ippiNormLevel - the normalized correlation coefficients.
4242// If the IppAlgMask value in algType is equal to ippAlgAuto, the optimal algorithm is selected automatically.
4243// For big data size, the function uses 2D FFT algorithm.
4244// Parameters:
4245// pSrc - Pointer to the source image ROI.
4246// srcStep - Distance, in bytes, between the starting points of consecutive lines in the source image.
4247// srcRoiSize - Size of the source ROI in pixels.
4248// pTpl - Pointer to the template image.
4249// tplStep - Distance, in bytes, between the starting points of consecutive lines in the template image.
4250// tplRoiSize - Size of the template ROI in pixels.
4251// pDst - Pointer to the destination image ROI.
4252// dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
4253// scaleFactor - Scale factor.
4254// algType - Bit-field mask for the algorithm type definition. Possible values are the results of composition of the IppAlgType, IppiROIShape, and IppiNormOp values.
4255// Usage example: algType=(ippiROIFull|ippAlgFFT|ippiNormNone); - full-shaped cross-correlation will be calculated using 2D FFT without result normalization.
4256// pBuffer - Pointer to the work buffer.
4257// Returns:
4258// ippStsNoErr OK.
4259// ippStsNullPtrErr Error when any of the specified pointers is NULL.
4260// ippStsStepErr Error when the value of srcStep, tplStep, or dstStep is negative, or equal to zero.
4261// ippStsSizeErr Error when :
4262// srcRoiSize or tplRoiSize is negative, or equal to zero.
4263// The value of srcRoiSize is less than the corresponding value of tplRoiSize.
4264// ippStsAlgTypeErr Error when :
4265// The result of the bitwise AND operation between the algType and ippAlgMask differs from the ippAlgAuto, ippAlgDirect, or ippAlgFFT values.
4266// The result of the bitwise AND operation between the algType and ippiROIMask differs from the ippiROIFull, ippiROISame, or ippiROIValid values.
4267// The result of the bitwise AND operation between the algType and ippiNormMask differs from the ippiNormNone, ippiNormalized, or ippiNormCoefficients values.
4268*/
4269
4270IPPAPI( IppStatus, ippiCrossCorrNorm_32f_C1R, ( const Ipp32f* pSrc, int srcStep, IppiSize srcRoiSize, const Ipp32f* pTpl, int tplStep, IppiSize tplRoiSize,
4271 Ipp32f* pDst, int dstStep, IppEnum algType, Ipp8u* pBuffer ))
4272
4273IPPAPI( IppStatus, ippiCrossCorrNorm_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep, IppiSize srcRoiSize, const Ipp8u* pTpl, int tplStep, IppiSize tplRoiSize,
4274 Ipp32f* pDst, int dstStep, IppEnum algType, Ipp8u* pBuffer ))
4275
4276
4277
4278/* /////////////////////////////////////////////////////////////////////////////
4279// Definitions for DCT Functions
4280///////////////////////////////////////////////////////////////////////////// */
4281
4282/* /////////////////////////////////////////////////////////////////////////////
4283// DCT Context Functions
4284///////////////////////////////////////////////////////////////////////////// */
4285/* /////////////////////////////////////////////////////////////////////////////
4286// Name: ippiDCTFwdInit, ippiDCTInvInit
4287// Purpose: Initializes the forward/inverse DCT context structure
4288// Parameters:
4289// pDCTSpec Pointer to the DCT context structure
4290// roiSize Size of the ROI
4291// pMemInit Pointer to the temporary work buffer
4292// Returns:
4293// ippStsNoErr No errors
4294// ippStsNullPtrErr pDCTSpec == NULL
4295// ippStsSizeErr roiSize has a field with zero or negative value
4296*/
4297
4298IPPAPI (IppStatus, ippiDCTFwdInit_32f,
4299 ( IppiDCTFwdSpec_32f* pDCTSpec,
4300 IppiSize roiSize, Ipp8u* pMemInit ))
4301IPPAPI (IppStatus, ippiDCTInvInit_32f,
4302 ( IppiDCTInvSpec_32f* pDCTSpec,
4303 IppiSize roiSize, Ipp8u* pMemInit ))
4304
4305/* /////////////////////////////////////////////////////////////////////////////
4306// DCT Buffer Size
4307///////////////////////////////////////////////////////////////////////////// */
4308/* /////////////////////////////////////////////////////////////////////////////
4309// Name: ippiDCTFwdGetSize, ippiDCTInvGetSize
4310// Purpose: Computes the size of the forward/inverse DCT context structure and the size
4311// of the required work buffer (in bytes)
4312// Parameters:
4313// roiSize Size of the ROI
4314// pSizeSpec Pointer to the size value of DCT context structure
4315// pSizeInit Pointer to the size value of the buffer for DCT initialization function
4316// pSizeBuf Pointer to the size value of the DCT external work buffer
4317// Returns:
4318// ippStsNoErr No errors
4319// ippStsNullPtrErr One of the specified pointers is NULL
4320// ippStsSizeErr roiSize has a field with zero or negative value
4321*/
4322
4323IPPAPI (IppStatus, ippiDCTFwdGetSize_32f,
4324 ( IppiSize roiSize,
4325 int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
4326IPPAPI (IppStatus, ippiDCTInvGetSize_32f,
4327 ( IppiSize roiSize,
4328 int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
4329
4330/* /////////////////////////////////////////////////////////////////////////////
4331// DCT Transforms
4332///////////////////////////////////////////////////////////////////////////// */
4333/* /////////////////////////////////////////////////////////////////////////////
4334// Name: ippiDCTFwd, ippiDCTInv
4335// Purpose: Performs forward or inverse DCT of an image
4336// Parameters:
4337// pDCTSpec Pointer to the DCT context structure
4338// pSrc Pointer to the source image
4339// srcStep Step through the source image
4340// pDst Pointer to the destination image
4341// dstStep Step through the destination image
4342// pBuffer Pointer to the work buffer
4343// Returns:
4344// ippStsNoErr No errors
4345// ippStsNullPtrErr One of the specified pointers with the exception of
4346 pBuffer is NULL
4347// ippStsStepErr srcStep or dstStep value is zero or negative
4348// ippStsContextMatchErr Invalid context structure
4349// ippStsMemAllocErr Memory allocation error
4350*/
4351
4352IPPAPI (IppStatus, ippiDCTFwd_32f_C1R,
4353 ( const Ipp32f* pSrc, int srcStep,
4354 Ipp32f* pDst, int dstStep,
4355 const IppiDCTFwdSpec_32f* pDCTSpec,
4356 Ipp8u* pBuffer ))
4357
4358IPPAPI (IppStatus, ippiDCTInv_32f_C1R,
4359 ( const Ipp32f* pSrc, int srcStep,
4360 Ipp32f* pDst, int dstStep,
4361 const IppiDCTInvSpec_32f* pDCTSpec,
4362 Ipp8u* pBuffer ))
4363
4364/* /////////////////////////////////////////////////////////////////////////////
4365// DFT Transforms
4366///////////////////////////////////////////////////////////////////////////// */
4367/* /////////////////////////////////////////////////////////////////////////////
4368// Name: ippiDFTFwd, ippiDFTInv
4369// Purpose: Performs forward or inverse DFT of an image
4370// Parameters:
4371// pDFTSpec Pointer to the DFT context structure
4372// pSrc Pointer to source image
4373// srcStep Step through the source image
4374// pDst Pointer to the destination image
4375// dstStep Step through the destination image
4376// pSrcDst Pointer to the source/destination image (in-place)
4377// srcDstStep Step through the source/destination image (in-place)
4378// pBuffer Pointer to the external work buffer
4379// Returns:
4380// ippStsNoErr No errors
4381// ippStsNullPtrErr One of the specified pointers with the exception of
4382 pBuffer is NULL
4383// ippStsStepErr srcStep or dstStep value is zero or negative
4384// ippStsContextMatchErr Invalid context structure
4385// ippStsMemAllocErr Memory allocation error
4386*/
4387
4388IPPAPI (IppStatus, ippiDFTFwd_CToC_32fc_C1R,
4389 ( const Ipp32fc* pSrc, int srcStep,
4390 Ipp32fc* pDst, int dstStep,
4391 const IppiDFTSpec_C_32fc* pDFTSpec,
4392 Ipp8u* pBuffer ))
4393
4394
4395IPPAPI (IppStatus, ippiDFTFwd_RToPack_32f_C1R,
4396 ( const Ipp32f* pSrc, int srcStep,
4397 Ipp32f* pDst, int dstStep,
4398 const IppiDFTSpec_R_32f* pDFTSpec,
4399 Ipp8u* pBuffer ))
4400
4401
4402IPPAPI (IppStatus, ippiDFTInv_CToC_32fc_C1R,
4403 ( const Ipp32fc* pSrc, int srcStep,
4404 Ipp32fc* pDst, int dstStep,
4405 const IppiDFTSpec_C_32fc* pDFTSpec,
4406 Ipp8u* pBuffer ))
4407
4408IPPAPI (IppStatus, ippiDFTInv_PackToR_32f_C1R,
4409 ( const Ipp32f* pSrc, int srcStep,
4410 Ipp32f* pDst, int dstStep,
4411 const IppiDFTSpec_R_32f* pDFTSpec,
4412 Ipp8u* pBuffer ))
4413
4414
4415/* /////////////////////////////////////////////////////////////////////////////
4416// Name: ippiDFTGetSize
4417// Purpose: Computes the size of the DFT context structure and the size
4418 of the required work buffer (in bytes)
4419// Parameters:
4420// roiSize Size of the ROI
4421// flag Flag to choose the results normalization factors
4422// hint Option to select the algorithmic implementation of the transform
4423// function
4424// pSizeSpec Pointer to the size value of DFT specification structure
4425// pSizeInit Pointer to the size value of the buffer for DFT initialization function
4426// pSizeBuf Pointer to the size value of the DFT external work buffer
4427// Return:
4428// ippStsNoErr No errors
4429// ippStsNullPtrErr One of the specified pointers is NULL
4430// ippStsFftOrderErr Invalid roiSize
4431// ippStsSizeErr roiSize has a field with zero or negative value
4432// ippStsFFTFlagErr Incorrect normalization flag value
4433*/
4434
4435IPPAPI (IppStatus, ippiDFTGetSize_C_32fc,
4436 ( IppiSize roiSize, int flag, IppHintAlgorithm hint,
4437 int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
4438IPPAPI (IppStatus, ippiDFTGetSize_R_32f,
4439 ( IppiSize roiSize, int flag, IppHintAlgorithm hint,
4440 int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
4441
4442
4443/* /////////////////////////////////////////////////////////////////////////////
4444// DFT Context Functions
4445///////////////////////////////////////////////////////////////////////////// */
4446/* /////////////////////////////////////////////////////////////////////////////
4447// Name: ippiDFTInit
4448// Purpose: Initializes the DFT context structure
4449// Parameters:
4450// roiSize Size of the ROI
4451// flag Flag to choose the results normalization factors
4452// hint Option to select the algorithmic implementation of the transform
4453// function
4454// pDFTSpec Double pointer to the DFT context structure
4455// pMemInit Pointer to initialization buffer
4456// Returns:
4457// ippStsNoErr No errors
4458// ippStsNullPtrErr One of the specified pointers is NULL
4459// ippStsFftOrderErr Invalid roiSize
4460// ippStsSizeErr roiSize has a field with zero or negative value
4461// ippStsFFTFlagErr Incorrect normalization flag value
4462*/
4463
4464IPPAPI (IppStatus, ippiDFTInit_C_32fc,
4465 ( IppiSize roiSize, int flag, IppHintAlgorithm hint,
4466 IppiDFTSpec_C_32fc* pDFTSpec, Ipp8u* pMemInit ))
4467IPPAPI (IppStatus, ippiDFTInit_R_32f,
4468 ( IppiSize roiSize, int flag, IppHintAlgorithm hint,
4469 IppiDFTSpec_R_32f* pDFTSpec, Ipp8u* pMemInit ))
4470
4471
4472/* ///////////////////////////////////////////////////////////////////////////////////////
4473// Name: ippiAddC_32f_C1IR, ippiAddC_32f_C3IR, ippiAddC_32f_C4IR, ippiAddC_32f_AC4IR,
4474// ippiSubC_32f_C1IR, ippiSubC_32f_C3IR, ippiSubC_32f_C4IR, ippiSubC_32f_AC4IR,
4475// ippiMulC_32f_C1IR, ippiMulC_32f_C3IR, ippiMulC_32f_C4IR, ippiMulC_32f_AC4IR
4476//
4477// Purpose: Adds, subtracts, or multiplies pixel values of an image
4478// and a constant, and places the results in the same image.
4479//
4480// Returns:
4481// ippStsNoErr OK
4482// ippStsNullPtrErr Pointer is NULL
4483// ippStsSizeErr Width or height of an image is less than or equal to zero
4484//
4485// Parameters:
4486// value The constant value for the specified operation
4487// pSrcDst Pointer to the image
4488// srcDstStep Step through the image
4489// roiSize Size of the ROI
4490*/
4491
4492IPPAPI(IppStatus, ippiMulC_32f_C1IR, (Ipp32f value, Ipp32f* pSrcDst, int srcDstStep,
4493 IppiSize roiSize))
4494
4495
4496/* //////////////////////////////////////////////////////////////////////////////////////////////
4497// Name: ippiAddC_8u_C1IRSfs, ippiAddC_8u_C3IRSfs, ippiAddC_8u_C4IRSfs, ippiAddC_8u_AC4IRSfs,
4498// ippiAddC_16s_C1IRSfs, ippiAddC_16s_C3IRSfs, ippiAddC_16s_C4IRSfs, ippiAddC_16s_AC4IRSfs,
4499// ippiAddC_16u_C1IRSfs, ippiAddC_16u_C3IRSfs, ippiAddC_16u_C4IRSfs, ippiAddC_16u_AC4IRSfs,
4500// ippiSubC_8u_C1IRSfs, ippiSubC_8u_C3IRSfs, ippiSubC_8u_C4IRSfs, ippiSubC_8u_AC4IRSfs,
4501// ippiSubC_16s_C1IRSfs, ippiSubC_16s_C3IRSfs, ippiSubC_16s_C4IRSfs, ippiSubC_16s_AC4IRSfs,
4502// ippiSubC_16u_C1IRSfs, ippiSubC_16u_C3IRSfs, ippiSubC_16u_C4IRSfs, ippiSubC_16u_AC4IRSfs,
4503// ippiMulC_8u_C1IRSfs, ippiMulC_8u_C3IRSfs, ippiMulC_8u_C4IRSfs, ippiMulC_8u_AC4IRSfs,
4504// ippiMulC_16s_C1IRSfs, ippiMulC_16s_C3IRSfs, ippiMulC_16s_C4IRSfs, ippiMulC_16s_AC4IRSfs
4505// ippiMulC_16u_C1IRSfs, ippiMulC_16u_C3IRSfs, ippiMulC_16u_C4IRSfs, ippiMulC_16u_AC4IRSfs
4506//
4507// Purpose: Adds, subtracts, or multiplies pixel values of an image and a constant
4508// and places the scaled results in the same image.
4509//
4510// Returns:
4511// ippStsNoErr OK
4512// ippStsNullPtrErr Pointer is NULL
4513// ippStsSizeErr Width or height of an image is less than or equal to zero
4514//
4515// Parameters:
4516// value Constant value (constant vector for multi-channel images)
4517// pSrcDst Pointer to the image
4518// srcDstStep Step through the image
4519// roiSize Size of the ROI
4520// scaleFactor Scale factor
4521*/
4522
4523IPPAPI(IppStatus, ippiMulC_16s_C1IRSfs, (Ipp16s value, Ipp16s* pSrcDst, int srcDstStep,
4524 IppiSize roiSize, int scaleFactor))
4525
4526
4527/* /////////////////////////////////////////////////////////////////////////////
4528// Names: ippiSqrDistanceNormGetBufferSize
4529//
4530// Purpose: Computes the size of the work buffer for the ippiSqrDistanceNorm functions.
4531//
4532// Parameters:
4533// srcRoiSize - Size of the source ROI, in pixels.
4534// tplRoiSize - Size of the template ROI, in pixels.
4535// algType - Bit-field mask for the algorithm type definition. Possible values are the results of composition of the IppAlgType, IppiROIShape, and IppiNormOp values.
4536// Usage example: algType=(ippiROIFull|ippAlgFFT|ippiNormalized); - result image will be calculated for full-shaped ROI
4537// using 2D FFT and normalization applied.
4538// pBufferSize - Pointer where to store the calculated buffer size (in bytes)
4539// Return:
4540// ippStsNoErr - Ok.
4541// ippStsSizeErr - Error when :
4542// srcRoiSize or tplRoiSize is negative, or equal to zero.
4543// The value of srcRoiSize is less than the corresponding value of tplRoiSize.
4544// ippStsAlgTypeErr - Error when :
4545// The result of the bitwise AND operation between the algType and ippAlgMask differs from the ippAlgAuto, ippAlgDirect, or ippAlgFFT values.
4546// The result of the bitwise AND operation between the algType and ippiROIMask differs from the ippiROIFull, ippiROISame, or ippiROIValid values.
4547// The result of the bitwise AND operation between the algType and ippiNormMask differs from the ippiNormNone or ippiNormalized values.
4548// ippStsNullPtrErr - Error when the pBufferSize is NULL.
4549*/
4550
4551IPPAPI( IppStatus, ippiSqrDistanceNormGetBufferSize, ( IppiSize srcRoiSize, IppiSize tplRoiSize, IppEnum algType, int* pBufferSize ))
4552
4553
4554/* ////////////////////////////////////////////////////////////////////////////
4555// Names: ippiSqrDistanceNorm_32f_C1R
4556// ippiSqrDistanceNorm_16u32f_C1R
4557// ippiSqrDistanceNorm_8u32f_C1R
4558// ippiSqrDistanceNorm_8u_C1RSfs
4559// Purpose: Computes Euclidean distance between an image and a template.
4560// The result image size depends on operation shape selected in algType mask as follows :
4561// (Wa+Wb-1)*(Ha+Hb-1) for ippiROIFull mask,
4562// (Wa)*(Ha) for ippiROISame mask,
4563// (Wa-Wb+1)*(Ha-Hb+1) for ippiROIValid mask,
4564// where Wa*Ha and Wb*Hb are the sizes of the image and template , respectively.
4565// Support of normalization operations (set the algType mask) :
4566// ippiNormNone - the squared Euclidean distances.
4567// ippiNormalized - the normalized squared Euclidean distances.
4568// If the IppAlgMask value in algType is equal to ippAlgAuto, the optimal algorithm is selected
4569// automatically. For big data size, the function uses 2D FFT algorithm.
4570// Parameters:
4571// pSrc - Pointer to the source image ROI.
4572// srcStep - Distance, in bytes, between the starting points of consecutive lines in the source image.
4573// srcRoiSize - Size of the source ROI, in pixels.
4574// pTpl - Pointer to the template image.
4575// tplStep - Distance, in bytes, between the starting points of consecutive lines in the template image.
4576// tplRoiSize - Size of the template ROI, in pixels.
4577// pDst - Pointer to the destination image ROI.
4578// dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
4579// scaleFactor - Scale factor.
4580// algType - Bit-field mask for the algorithm type definition. Possible values are the results of composition of the IppAlgType, IppiROIShape, and IppiNormOp values.
4581// Usage example: algType=(ippiROIFull|ippiNormNone|ippAlgFFT); - result will be calculated for full-shaped ROI using 2D FFT without normalization.
4582// pBuffer - Pointer to the buffer for internal calculation.
4583// Returns:
4584// ippStsNoErr OK.
4585// ippStsNullPtrErr Error when any of the specified pointers is NULL.
4586// ippStsStepErr Error when the value of srcStep, tplStep, or dstStep is negative, or equal to zero.
4587// ippStsSizeErr Error when :
4588// srcRoiSize or tplRoiSize is negative, or equal to zero.
4589// The value of srcRoiSize is less than the corresponding value of the tplRoiSize.
4590// ippStsAlgTypeErr Error when :
4591// The result of the bitwise AND operation between the algType and ippAlgMask differs from the ippAlgAuto, ippAlgDirect, or ippAlgFFT values.
4592// The result of the bitwise AND operation between the algType and ippiROIMask differs from the ippiROIFull, ippiROISame, or ippiROIValid values.
4593// The result of the bitwise AND operation between the algType and ippiNormMask differs from the ippiNormNone or ippiNormalized values.
4594*/
4595IPPAPI( IppStatus, ippiSqrDistanceNorm_32f_C1R, ( const Ipp32f* pSrc, int srcStep, IppiSize srcRoiSize, const Ipp32f* pTpl, int tplStep, IppiSize tplRoiSize,
4596 Ipp32f* pDst, int dstStep, IppEnum algType, Ipp8u* pBuffer ))
4597
4598IPPAPI( IppStatus, ippiSqrDistanceNorm_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep, IppiSize srcRoiSize, const Ipp8u* pTpl, int tplStep, IppiSize tplRoiSize,
4599 Ipp32f* pDst, int dstStep, IppEnum algType, Ipp8u* pBuffer ))
4600
4601
4602/* ////////////////////////////////////////////////////////////////////////////
4603// Names: ippiThreshold_GT_8u_C1R
4604// ippiThreshold_GT_8u_C3R
4605// ippiThreshold_GT_8u_AC4R
4606// ippiThreshold_GT_16s_C1R
4607// ippiThreshold_GT_16s_C3R
4608// ippiThreshold_GT_16s_AC4R
4609// ippiThreshold_GT_32f_C1R
4610// ippiThreshold_GT_32f_C3R
4611// ippiThreshold_GT_32f_AC4R
4612// ippiThreshold_GT_8u_C1IR
4613// ippiThreshold_GT_8u_C3IR
4614// ippiThreshold_GT_8u_AC4IR
4615// ippiThreshold_GT_16s_C1IR
4616// ippiThreshold_GT_16s_C3IR
4617// ippiThreshold_GT_16s_AC4IR
4618// ippiThreshold_GT_32f_C1IR
4619// ippiThreshold_GT_32f_C3IR
4620// ippiThreshold_GT_32f_AC4IR
4621// ippiThreshold_GT_16u_C1R
4622// ippiThreshold_GT_16u_C3R
4623// ippiThreshold_GT_16u_AC4R
4624// ippiThreshold_GT_16u_C1IR
4625// ippiThreshold_GT_16u_C3IR
4626// ippiThreshold_GT_16u_AC4IR
4627//
4628// Purpose: Performs threshold operation using the comparison "greater than"
4629// Returns:
4630// ippStsNoErr OK
4631// ippStsNullPtrErr One of the pointers is NULL
4632// ippStsSizeErr roiSize has a field with zero or negative value
4633// ippStsStepErr One of the step values is zero or negative
4634//
4635// Parameters:
4636// pSrc Pointer to the source image
4637// srcStep Step through the source image
4638// pDst Pointer to the destination image
4639// dstStep Step through the destination image
4640// pSrcDst Pointer to the source/destination image (in-place flavors)
4641// srcDstStep Step through the source/destination image (in-place flavors)
4642// roiSize Size of the ROI
4643// threshold Threshold level value (array of values for multi-channel data)
4644*/
4645IPPAPI(IppStatus,ippiThreshold_GT_8u_C1R,(const Ipp8u* pSrc, int srcStep,
4646 Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp8u threshold))
4647IPPAPI(IppStatus,ippiThreshold_GT_16s_C1R,(const Ipp16s* pSrc, int srcStep,
4648 Ipp16s* pDst, int dstStep, IppiSize roiSize, Ipp16s threshold))
4649IPPAPI(IppStatus,ippiThreshold_GT_32f_C1R,(const Ipp32f* pSrc, int srcStep,
4650 Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f threshold))
4651IPPAPI(IppStatus,ippiThreshold_GT_8u_C3R,(const Ipp8u* pSrc, int srcStep,
4652 Ipp8u* pDst, int dstStep, IppiSize roiSize, const Ipp8u threshold[3]))
4653IPPAPI(IppStatus,ippiThreshold_GT_16s_C3R,(const Ipp16s* pSrc, int srcStep,
4654 Ipp16s* pDst, int dstStep, IppiSize roiSize, const Ipp16s threshold[3]))
4655IPPAPI(IppStatus,ippiThreshold_GT_32f_C3R,(const Ipp32f* pSrc, int srcStep,
4656 Ipp32f* pDst, int dstStep, IppiSize roiSize, const Ipp32f threshold[3]))
4657IPPAPI(IppStatus,ippiThreshold_GT_8u_C1IR,(Ipp8u* pSrcDst, int srcDstStep,
4658 IppiSize roiSize, Ipp8u threshold))
4659IPPAPI(IppStatus,ippiThreshold_GT_16s_C1IR,(Ipp16s* pSrcDst, int srcDstStep,
4660 IppiSize roiSize, Ipp16s threshold))
4661IPPAPI(IppStatus,ippiThreshold_GT_32f_C1IR,(Ipp32f* pSrcDst, int srcDstStep,
4662 IppiSize roiSize, Ipp32f threshold))
4663IPPAPI(IppStatus,ippiThreshold_GT_8u_C3IR,(Ipp8u* pSrcDst, int srcDstStep,
4664 IppiSize roiSize, const Ipp8u threshold[3]))
4665IPPAPI(IppStatus,ippiThreshold_GT_16s_C3IR,(Ipp16s* pSrcDst, int srcDstStep,
4666 IppiSize roiSize, const Ipp16s threshold[3]))
4667IPPAPI(IppStatus,ippiThreshold_GT_32f_C3IR,(Ipp32f* pSrcDst, int srcDstStep,
4668 IppiSize roiSize, const Ipp32f threshold[3]))
4669IPPAPI(IppStatus,ippiThreshold_GT_16u_C1R,(const Ipp16u* pSrc, int srcStep,
4670 Ipp16u* pDst, int dstStep, IppiSize roiSize, Ipp16u threshold))
4671IPPAPI(IppStatus,ippiThreshold_GT_16u_C3R,(const Ipp16u* pSrc, int srcStep,
4672 Ipp16u* pDst, int dstStep, IppiSize roiSize, const Ipp16u threshold[3]))
4673IPPAPI(IppStatus,ippiThreshold_GT_16u_C1IR,(Ipp16u* pSrcDst, int srcDstStep,
4674 IppiSize roiSize, Ipp16u threshold))
4675IPPAPI(IppStatus,ippiThreshold_GT_16u_C3IR,(Ipp16u* pSrcDst, int srcDstStep,
4676 IppiSize roiSize, const Ipp16u threshold[3]))
4677
4678
4679/* ////////////////////////////////////////////////////////////////////////////
4680// Names: ippiThreshold_GTVal_8u_C1R
4681// ippiThreshold_GTVal_8u_C3R
4682// ippiThreshold_GTVal_8u_AC4R
4683// ippiThreshold_GTVal_16s_C1R
4684// ippiThreshold_GTVal_16s_C3R
4685// ippiThreshold_GTVal_16s_AC4R
4686// ippiThreshold_GTVal_32f_C1R
4687// ippiThreshold_GTVal_32f_C3R
4688// ippiThreshold_GTVal_32f_AC4R
4689// ippiThreshold_GTVal_8u_C1IR
4690// ippiThreshold_GTVal_8u_C3IR
4691// ippiThreshold_GTVal_8u_AC4IR
4692// ippiThreshold_GTVal_16s_C1IR
4693// ippiThreshold_GTVal_16s_C3IR
4694// ippiThreshold_GTVal_16s_AC4IR
4695// ippiThreshold_GTVal_32f_C1IR
4696// ippiThreshold_GTVal_32f_C3IR
4697// ippiThreshold_GTVal_32f_AC4IR
4698// ippiThreshold_GTVal_8u_C4R
4699// ippiThreshold_GTVal_16s_C4R
4700// ippiThreshold_GTVal_32f_C4R
4701// ippiThreshold_GTVal_8u_C4IR
4702// ippiThreshold_GTVal_16s_C4IR
4703// ippiThreshold_GTVal_32f_C4IR
4704// ippiThreshold_GTVal_16u_C1R
4705// ippiThreshold_GTVal_16u_C3R
4706// ippiThreshold_GTVal_16u_AC4R
4707// ippiThreshold_GTVal_16u_C1IR
4708// ippiThreshold_GTVal_16u_C3IR
4709// ippiThreshold_GTVal_16u_AC4IR
4710// ippiThreshold_GTVal_16u_C4R
4711// ippiThreshold_GTVal_16u_C4IR
4712//
4713// Purpose: Performs thresholding of pixel values: pixels that are
4714// greater than threshold, are set to a specified value
4715// Returns:
4716// ippStsNoErr OK
4717// ippStsNullPtrErr One of the pointers is NULL
4718// ippStsSizeErr roiSize has a field with zero or negative value
4719// ippStsStepErr One of the step values is zero or negative
4720//
4721// Parameters:
4722// pSrc Pointer to the source image
4723// srcStep Step through the source image
4724// pDst Pointer to the destination image
4725// dstStep Step through the destination image
4726// pSrcDst Pointer to the source/destination image (in-place flavors)
4727// srcDstStep Step through the source/destination image (in-place flavors)
4728// roiSize Size of the ROI
4729// threshold Threshold level value (array of values for multi-channel data)
4730// value The output value (array or values for multi-channel data)
4731*/
4732IPPAPI(IppStatus,ippiThreshold_GTVal_8u_C1R,(const Ipp8u* pSrc, int srcStep,
4733 Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp8u threshold,
4734 Ipp8u value))
4735IPPAPI(IppStatus,ippiThreshold_GTVal_16s_C1R,(const Ipp16s* pSrc, int srcStep,
4736 Ipp16s* pDst, int dstStep, IppiSize roiSize, Ipp16s threshold,
4737 Ipp16s value))
4738IPPAPI(IppStatus,ippiThreshold_GTVal_32f_C1R,(const Ipp32f* pSrc, int srcStep,
4739 Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f threshold,
4740 Ipp32f value))
4741IPPAPI(IppStatus,ippiThreshold_GTVal_8u_C3R,(const Ipp8u* pSrc, int srcStep,
4742 Ipp8u* pDst, int dstStep, IppiSize roiSize, const Ipp8u threshold[3],
4743 const Ipp8u value[3]))
4744IPPAPI(IppStatus,ippiThreshold_GTVal_16s_C3R,(const Ipp16s* pSrc, int srcStep,
4745 Ipp16s* pDst, int dstStep, IppiSize roiSize, const Ipp16s threshold[3],
4746 const Ipp16s value[3]))
4747IPPAPI(IppStatus,ippiThreshold_GTVal_32f_C3R,(const Ipp32f* pSrc, int srcStep,
4748 Ipp32f* pDst, int dstStep, IppiSize roiSize, const Ipp32f threshold[3],
4749 const Ipp32f value[3]))
4750IPPAPI(IppStatus,ippiThreshold_GTVal_8u_C1IR,(Ipp8u* pSrcDst, int srcDstStep,
4751 IppiSize roiSize, Ipp8u threshold, Ipp8u value))
4752IPPAPI(IppStatus,ippiThreshold_GTVal_16s_C1IR,(Ipp16s* pSrcDst, int srcDstStep,
4753 IppiSize roiSize, Ipp16s threshold, Ipp16s value))
4754IPPAPI(IppStatus,ippiThreshold_GTVal_32f_C1IR,(Ipp32f* pSrcDst, int srcDstStep,
4755 IppiSize roiSize, Ipp32f threshold, Ipp32f value))
4756IPPAPI(IppStatus,ippiThreshold_GTVal_8u_C3IR,(Ipp8u* pSrcDst, int srcDstStep,
4757 IppiSize roiSize, const Ipp8u threshold[3], const Ipp8u value[3]))
4758IPPAPI(IppStatus,ippiThreshold_GTVal_16s_C3IR,(Ipp16s* pSrcDst, int srcDstStep,
4759 IppiSize roiSize, const Ipp16s threshold[3], const Ipp16s value[3]))
4760IPPAPI(IppStatus,ippiThreshold_GTVal_32f_C3IR,(Ipp32f* pSrcDst, int srcDstStep,
4761 IppiSize roiSize, const Ipp32f threshold[3], const Ipp32f value[3]))
4762IPPAPI(IppStatus,ippiThreshold_GTVal_8u_C4R,(const Ipp8u* pSrc, int srcStep,
4763 Ipp8u* pDst, int dstStep, IppiSize roiSize, const Ipp8u threshold[4],
4764 const Ipp8u value[4]))
4765IPPAPI(IppStatus,ippiThreshold_GTVal_16s_C4R,(const Ipp16s* pSrc, int srcStep,
4766 Ipp16s* pDst, int dstStep, IppiSize roiSize, const Ipp16s threshold[4],
4767 const Ipp16s value[4]))
4768IPPAPI(IppStatus,ippiThreshold_GTVal_32f_C4R,(const Ipp32f* pSrc, int srcStep,
4769 Ipp32f* pDst, int dstStep, IppiSize roiSize, const Ipp32f threshold[4],
4770 const Ipp32f value[4]))
4771IPPAPI(IppStatus,ippiThreshold_GTVal_8u_C4IR,(Ipp8u* pSrcDst, int srcDstStep,
4772 IppiSize roiSize, const Ipp8u threshold[4], const Ipp8u value[4]))
4773IPPAPI(IppStatus,ippiThreshold_GTVal_16s_C4IR,(Ipp16s* pSrcDst, int srcDstStep,
4774 IppiSize roiSize, const Ipp16s threshold[4], const Ipp16s value[4]))
4775IPPAPI(IppStatus,ippiThreshold_GTVal_32f_C4IR,(Ipp32f* pSrcDst, int srcDstStep,
4776 IppiSize roiSize, const Ipp32f threshold[4], const Ipp32f value[4]))
4777IPPAPI(IppStatus,ippiThreshold_GTVal_16u_C1R,(const Ipp16u* pSrc, int srcStep,
4778 Ipp16u* pDst, int dstStep, IppiSize roiSize, Ipp16u threshold,
4779 Ipp16u value))
4780IPPAPI(IppStatus,ippiThreshold_GTVal_16u_C3R,(const Ipp16u* pSrc, int srcStep,
4781 Ipp16u* pDst, int dstStep, IppiSize roiSize, const Ipp16u threshold[3],
4782 const Ipp16u value[3]))
4783IPPAPI(IppStatus,ippiThreshold_GTVal_16u_C1IR,(Ipp16u* pSrcDst, int srcDstStep,
4784 IppiSize roiSize, Ipp16u threshold, Ipp16u value))
4785IPPAPI(IppStatus,ippiThreshold_GTVal_16u_C3IR,(Ipp16u* pSrcDst, int srcDstStep,
4786 IppiSize roiSize, const Ipp16u threshold[3], const Ipp16u value[3]))
4787IPPAPI(IppStatus,ippiThreshold_GTVal_16u_C4R,(const Ipp16u* pSrc, int srcStep,
4788 Ipp16u* pDst, int dstStep, IppiSize roiSize, const Ipp16u threshold[4],
4789 const Ipp16u value[4]))
4790IPPAPI(IppStatus,ippiThreshold_GTVal_16u_C4IR,(Ipp16u* pSrcDst, int srcDstStep,
4791 IppiSize roiSize, const Ipp16u threshold[4], const Ipp16u value[4]))
4792
4793/* ////////////////////////////////////////////////////////////////////////////
4794// Names: ippiThreshold_LTVal_8u_C1R
4795// ippiThreshold_LTVal_8u_C3R
4796// ippiThreshold_LTVal_8u_AC4R
4797// ippiThreshold_LTVal_16s_C1R
4798// ippiThreshold_LTVal_16s_C3R
4799// ippiThreshold_LTVal_16s_AC4R
4800// ippiThreshold_LTVal_32f_C1R
4801// ippiThreshold_LTVal_32f_C3R
4802// ippiThreshold_LTVal_32f_AC4R
4803// ippiThreshold_LTVal_8u_C1IR
4804// ippiThreshold_LTVal_8u_C3IR
4805// ippiThreshold_LTVal_8u_AC4IR
4806// ippiThreshold_LTVal_16s_C1IR
4807// ippiThreshold_LTVal_16s_C3IR
4808// ippiThreshold_LTVal_16s_AC4IR
4809// ippiThreshold_LTVal_32f_C1IR
4810// ippiThreshold_LTVal_32f_C3IR
4811// ippiThreshold_LTVal_32f_AC4IR
4812// ippiThreshold_LTVal_8u_C4R
4813// ippiThreshold_LTVal_16s_C4R
4814// ippiThreshold_LTVal_32f_C4R
4815// ippiThreshold_LTVal_8u_C4IR
4816// ippiThreshold_LTVal_16s_C4IR
4817// ippiThreshold_LTVal_32f_C4IR
4818// ippiThreshold_LTVal_16u_C1R
4819// ippiThreshold_LTVal_16u_C3R
4820// ippiThreshold_LTVal_16u_AC4R
4821// ippiThreshold_LTVal_16u_C1IR
4822// ippiThreshold_LTVal_16u_C3IR
4823// ippiThreshold_LTVal_16u_AC4IR
4824// ippiThreshold_LTVal_16u_C4R
4825// ippiThreshold_LTVal_16u_C4IR
4826//
4827// Purpose: Performs thresholding of pixel values: pixels that are
4828// less than threshold, are set to a specified value
4829// Returns:
4830// ippStsNoErr OK
4831// ippStsNullPtrErr One of the pointers is NULL
4832// ippStsSizeErr roiSize has a field with zero or negative value
4833// ippStsStepErr One of the step values is zero or negative
4834//
4835// Parameters:
4836// pSrc Pointer to the source image
4837// srcStep Step through the source image
4838// pDst Pointer to the destination image
4839// dstStep Step through the destination image
4840// pSrcDst Pointer to the source/destination image (in-place flavors)
4841// srcDstStep Step through the source/destination image (in-place flavors)
4842// roiSize Size of the ROI
4843// threshold Threshold level value (array of values for multi-channel data)
4844// value The output value (array or values for multi-channel data)
4845*/
4846IPPAPI(IppStatus,ippiThreshold_LTVal_8u_C1R,(const Ipp8u* pSrc, int srcStep,
4847 Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp8u threshold,
4848 Ipp8u value))
4849IPPAPI(IppStatus,ippiThreshold_LTVal_16s_C1R,(const Ipp16s* pSrc, int srcStep,
4850 Ipp16s* pDst, int dstStep, IppiSize roiSize, Ipp16s threshold,
4851 Ipp16s value))
4852IPPAPI(IppStatus,ippiThreshold_LTVal_32f_C1R,(const Ipp32f* pSrc, int srcStep,
4853 Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f threshold,
4854 Ipp32f value))
4855IPPAPI(IppStatus,ippiThreshold_LTVal_8u_C3R,(const Ipp8u* pSrc, int srcStep,
4856 Ipp8u* pDst, int dstStep, IppiSize roiSize, const Ipp8u threshold[3],
4857 const Ipp8u value[3]))
4858IPPAPI(IppStatus,ippiThreshold_LTVal_16s_C3R,(const Ipp16s* pSrc, int srcStep,
4859 Ipp16s* pDst, int dstStep, IppiSize roiSize, const Ipp16s threshold[3],
4860 const Ipp16s value[3]))
4861IPPAPI(IppStatus,ippiThreshold_LTVal_32f_C3R,(const Ipp32f* pSrc, int srcStep,
4862 Ipp32f* pDst, int dstStep, IppiSize roiSize, const Ipp32f threshold[3],
4863 const Ipp32f value[3]))
4864IPPAPI(IppStatus,ippiThreshold_LTVal_8u_C1IR,(Ipp8u* pSrcDst, int srcDstStep,
4865 IppiSize roiSize, Ipp8u threshold, Ipp8u value))
4866IPPAPI(IppStatus,ippiThreshold_LTVal_16s_C1IR,(Ipp16s* pSrcDst, int srcDstStep,
4867 IppiSize roiSize, Ipp16s threshold, Ipp16s value))
4868IPPAPI(IppStatus,ippiThreshold_LTVal_32f_C1IR,(Ipp32f* pSrcDst, int srcDstStep,
4869 IppiSize roiSize, Ipp32f threshold, Ipp32f value))
4870IPPAPI(IppStatus,ippiThreshold_LTVal_8u_C3IR,(Ipp8u* pSrcDst, int srcDstStep,
4871 IppiSize roiSize, const Ipp8u threshold[3], const Ipp8u value[3]))
4872IPPAPI(IppStatus,ippiThreshold_LTVal_16s_C3IR,(Ipp16s* pSrcDst, int srcDstStep,
4873 IppiSize roiSize, const Ipp16s threshold[3], const Ipp16s value[3]))
4874IPPAPI(IppStatus,ippiThreshold_LTVal_32f_C3IR,(Ipp32f* pSrcDst, int srcDstStep,
4875 IppiSize roiSize, const Ipp32f threshold[3], const Ipp32f value[3]))
4876IPPAPI(IppStatus,ippiThreshold_LTVal_8u_C4R,(const Ipp8u* pSrc, int srcStep,
4877 Ipp8u* pDst, int dstStep, IppiSize roiSize, const Ipp8u threshold[4],
4878 const Ipp8u value[4]))
4879IPPAPI(IppStatus,ippiThreshold_LTVal_16s_C4R,(const Ipp16s* pSrc, int srcStep,
4880 Ipp16s* pDst, int dstStep, IppiSize roiSize, const Ipp16s threshold[4],
4881 const Ipp16s value[4]))
4882IPPAPI(IppStatus,ippiThreshold_LTVal_32f_C4R,(const Ipp32f* pSrc, int srcStep,
4883 Ipp32f* pDst, int dstStep, IppiSize roiSize, const Ipp32f threshold[4],
4884 const Ipp32f value[4]))
4885IPPAPI(IppStatus,ippiThreshold_LTVal_8u_C4IR,(Ipp8u* pSrcDst, int srcDstStep,
4886 IppiSize roiSize, const Ipp8u threshold[4], const Ipp8u value[4]))
4887IPPAPI(IppStatus,ippiThreshold_LTVal_16s_C4IR,(Ipp16s* pSrcDst, int srcDstStep,
4888 IppiSize roiSize, const Ipp16s threshold[4], const Ipp16s value[4]))
4889IPPAPI(IppStatus,ippiThreshold_LTVal_32f_C4IR,(Ipp32f* pSrcDst, int srcDstStep,
4890 IppiSize roiSize, const Ipp32f threshold[4], const Ipp32f value[4]))
4891IPPAPI(IppStatus,ippiThreshold_LTVal_16u_C1R,(const Ipp16u* pSrc, int srcStep,
4892 Ipp16u* pDst, int dstStep, IppiSize roiSize, Ipp16u threshold,
4893 Ipp16u value))
4894IPPAPI(IppStatus,ippiThreshold_LTVal_16u_C3R,(const Ipp16u* pSrc, int srcStep,
4895 Ipp16u* pDst, int dstStep, IppiSize roiSize, const Ipp16u threshold[3],
4896 const Ipp16u value[3]))
4897IPPAPI(IppStatus,ippiThreshold_LTVal_16u_C1IR,(Ipp16u* pSrcDst, int srcDstStep,
4898 IppiSize roiSize, Ipp16u threshold, Ipp16u value))
4899IPPAPI(IppStatus,ippiThreshold_LTVal_16u_C3IR,(Ipp16u* pSrcDst, int srcDstStep,
4900 IppiSize roiSize, const Ipp16u threshold[3], const Ipp16u value[3]))
4901IPPAPI(IppStatus,ippiThreshold_LTVal_16u_C4R,(const Ipp16u* pSrc, int srcStep,
4902 Ipp16u* pDst, int dstStep, IppiSize roiSize, const Ipp16u threshold[4],
4903 const Ipp16u value[4]))
4904IPPAPI(IppStatus,ippiThreshold_LTVal_16u_C4IR,(Ipp16u* pSrcDst, int srcDstStep,
4905 IppiSize roiSize, const Ipp16u threshold[4], const Ipp16u value[4]))
4906
4907
4908/*F/////////////////////////////////////////////////////////////////////////////////
4909// Name: ippiComputeThreshold_Otsu_8u_C1R
4910//
4911// Purpose: Calculate Otsu theshold value of images
4912// Return:
4913// ippStsNoErr Ok
4914// ippStsNullPtrErr One of pointers is NULL
4915// ippStsSizeErr The width or height of images is less or equal zero
4916// ippStsStepErr The steps in images is less ROI
4917// Parameters:
4918// pSrc Pointer to image
4919// srcStep Image step
4920// roiSize Size of image ROI
4921// pThreshold Returned Otsu theshold value
4922//
4923//F*/
4924
4925IPPAPI (IppStatus, ippiComputeThreshold_Otsu_8u_C1R, (const Ipp8u* pSrc, int srcStep,
4926 IppiSize roiSize, Ipp8u* pThreshold))
4927
4928
4929/* /////////////////////////////////////////////////////////////////////////////
4930// Name: ippiFilterBoxBorderGetBufferSize
4931// Purpose: Computes the size of external buffer for FilterBoxBorder
4932//
4933// Parameters:
4934// roiSize Maximum size of the destination image ROI.
4935// maskSize Size of the mask in pixels.
4936// dataType Data type of the image. Possible values are Ipp8u, Ipp16u, Ipp16s, or Ipp32f.
4937// numChannels Number of channels in the image. Possible values are 1, 3, or 4.
4938// pBufferSize Pointer to the size of the external work buffer.
4939//
4940// Return Values:
4941// ippStsNoErr Indicates no error.
4942// ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
4943// ippStsMaskSizeErr Indicates an error when mask has an illegal value.
4944// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
4945// ippStsNumChannelsError Indicates an error when numChannels has an illegal value.
4946*/
4947IPPAPI (IppStatus, ippiFilterBoxBorderGetBufferSize,(IppiSize roiSize, IppiSize maskSize, IppDataType dataType, int numChannels, int* pBufferSize))
4948
4949/* ///////////////////////////////////////////////////////////////////////////
4950// Name: ippiFilterBoxBorder_32f_<desc>R / ippiFilterBoxBorder_16u_<desc>R / ippiFilterBoxBorder_8u_<desc>R / ippiFilterBoxBorder_16s_<desc>R
4951// <desc> C1|C3|C4|AC4 (descriptor)
4952// Purpose: Blurs an image using a simple box filter
4953// Parameters:
4954// pSrc Pointer to the source image.
4955// srcStep Distance in bytes between starting points of consecutive lines in the source image.
4956// pDst Pointer to the destination image.
4957// dstStep Distance in bytes between starting points of consecutive lines in the destination image.
4958// dstRoiSize Size of the destination ROI in pixels.
4959// maskSize Size of the mask in pixels.
4960// border Type of border. Possible values are:
4961// ippBorderConst Values of all border pixels are set to constant.
4962// ippBorderRepl Border is replicated from the edge pixels.
4963// ippBorderInMem Border is obtained from the source image pixels in memory.
4964// Mixed borders are also supported. They can be obtained by the bitwise operation OR between ippBorderRepl and ippBorderInMemTop, ippBorderInMemBottom, ippBorderInMemLeft, ippBorderInMemRight.
4965// borderValue Constant value to assign to pixels of the constant border. This parameter is applicable only to the ippBorderConst border type.
4966// pBuffer Pointer to the work buffer.
4967// Returns:
4968// ippStsNoErr Indicates no error.
4969// ippStsNullPtrErr Indicates an error when pSrc or pDst is NULL.
4970// ippStsSizeErr Indicates an error if roiSize has a field with zero or negative value.
4971// ippStsMaskSizeErr Indicates an error if mask has an illegal value.
4972// ippStsBorderErr Indicates an error when border has an illegal value.
4973*/
4974
4975IPPAPI(IppStatus, ippiFilterBoxBorder_32f_C1R,(const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,IppiSize roiSize,
4976 IppiSize maskSize, IppiBorderType border,const Ipp32f* borderValue, Ipp8u* pBuffer))
4977
4978IPPAPI(IppStatus, ippiFilterBoxBorder_32f_C3R,(const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize,
4979 IppiSize maskSize, IppiBorderType border,const Ipp32f borderValue[3],Ipp8u* pBuffer))
4980
4981IPPAPI(IppStatus, ippiFilterBoxBorder_32f_C4R,(const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize,
4982 IppiSize maskSize, IppiBorderType border,const Ipp32f borderValue[4],Ipp8u* pBuffer))
4983
4984IPPAPI(IppStatus, ippiFilterBoxBorder_16u_C1R,(const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,IppiSize roiSize,
4985 IppiSize maskSize, IppiBorderType border,const Ipp16u* borderValue, Ipp8u* pBuffer))
4986
4987IPPAPI(IppStatus, ippiFilterBoxBorder_16u_C3R,(const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize,
4988 IppiSize maskSize, IppiBorderType border,const Ipp16u borderValue[3],Ipp8u* pBuffer))
4989
4990IPPAPI(IppStatus, ippiFilterBoxBorder_16u_C4R,(const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize,
4991 IppiSize maskSize, IppiBorderType border,const Ipp16u borderValue[3],Ipp8u* pBuffer))
4992
4993IPPAPI(IppStatus, ippiFilterBoxBorder_16s_C1R,(const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,IppiSize roiSize,
4994 IppiSize maskSize, IppiBorderType border,const Ipp16s* borderValue, Ipp8u* pBuffer))
4995
4996IPPAPI(IppStatus, ippiFilterBoxBorder_16s_C3R,(const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep, IppiSize roiSize,
4997 IppiSize maskSize, IppiBorderType border,const Ipp16s borderValue[3],Ipp8u* pBuffer))
4998
4999IPPAPI(IppStatus, ippiFilterBoxBorder_16s_C4R,(const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep, IppiSize roiSize,
5000 IppiSize maskSize, IppiBorderType border,const Ipp16s borderValue[3],Ipp8u* pBuffer))
5001
5002IPPAPI(IppStatus, ippiFilterBoxBorder_8u_C1R,(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,IppiSize roiSize,
5003 IppiSize maskSize, IppiBorderType border,const Ipp8u* borderValue, Ipp8u* pBuffer))
5004
5005IPPAPI(IppStatus, ippiFilterBoxBorder_8u_C3R,(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize,
5006 IppiSize maskSize, IppiBorderType border,const Ipp8u borderValue[3],Ipp8u* pBuffer))
5007
5008IPPAPI(IppStatus, ippiFilterBoxBorder_8u_C4R,(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize,
5009 IppiSize maskSize, IppiBorderType border,const Ipp8u borderValue[4],Ipp8u* pBuffer))
5010
5011
5012/* /////////////////////////////////////////////////////////////////////////////
5013// Name: ippiFilterMedianBorderGetBufferSize
5014//
5015// Purpose: Computes the size of the external buffer for median filter with border
5016//
5017// Parameters:
5018// roiSize Size of destination ROI in pixels.
5019// maskSize Size of filter mask.
5020// dataType Data type of the source an desination images.
5021// numChannels Number of channels in the images. Possible value is 1.
5022// pBufferSize Pointer to the size (in bytes) of the external work buffer.
5023//
5024// Return Values:
5025// ippStsNoErr Indicates no error.
5026// ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
5027// ippStsSizeErr Indicates an error when roiSize has a field with negative or zero value.
5028// ippStsMaskSizeErr Indicates an error when maskSize has a field with negative, zero or even value.
5029// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
5030// ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
5031*/
5032IPPAPI(IppStatus, ippiFilterMedianBorderGetBufferSize,(IppiSize dstRoiSize, IppiSize maskSize,
5033 IppDataType dataType, int numChannels, int* pBufferSize))
5034
5035
5036/* /////////////////////////////////////////////////////////////////////////////
5037// Name: ippiFilterMedianBorder_8u_C1R
5038// ippiFilterMedianBorder_16s_C1R
5039// ippiFilterMedianBorder_16u_C1R
5040// ippiFilterMedianBorder_32f_C1R
5041// Purpose: Perform median filtering of an image with border
5042//
5043// Parameters:
5044// pSrc Pointer to the source image ROI.
5045// srcStep Distance in bytes between starting points of consecutive lines in the sorce image.
5046// pDst Pointer to the destination image ROI.
5047// dstStep Distance in bytes between starting points of consecutive lines in the destination image.
5048// dstRoiSize Size of destination ROI in pixels.
5049// maskSize Size of filter mask.
5050// borderType Type of border.
5051// borderValue Constant value to assign to pixels of the constant border. This parameter is applicable
5052// only to the ippBorderConst border type.
5053// pBorderValue Pointer to constant value to assign to pixels of the constant border. This parameter is applicable
5054// only to the ippBorderConst border type.
5055// pBuffer Pointer to the work buffer.
5056//
5057// Return Values:
5058// ippStsNoErr Indicates no error.
5059// ippStsNullPtrErr Indicates an error when pSrc, pDst or pBufferSize is NULL.
5060// ippStsSizeErr Indicates an error when roiSize has a field with negative or zero value.
5061// ippStsMaskSizeErr Indicates an error when maskSize has a field with negative, zero or even value.
5062// ippStsNotEvenStepErr Indicated an error when one of the step values is not divisible by 4
5063// for floating-point images, or by 2 for short-integer images.
5064// ippStsBorderErr Indicates an error when borderType has illegal value.
5065*/
5066
5067IPPAPI(IppStatus, ippiFilterMedianBorder_8u_C1R, (const Ipp8u* pSrc, int srcStep,
5068 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5069 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
5070IPPAPI(IppStatus, ippiFilterMedianBorder_16s_C1R, (const Ipp16s* pSrc, int srcStep,
5071 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5072 IppiBorderType borderType, Ipp16s borderValue, Ipp8u* pBuffer))
5073IPPAPI(IppStatus, ippiFilterMedianBorder_16u_C1R, (const Ipp16u* pSrc, int srcStep,
5074 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5075 IppiBorderType borderType, Ipp16u borderValue, Ipp8u* pBuffer))
5076IPPAPI(IppStatus, ippiFilterMedianBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
5077 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5078 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
5079
5080IPPAPI(IppStatus, ippiFilterMedianBorder_8u_C3R, (const Ipp8u* pSrc, int srcStep,
5081 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5082 IppiBorderType borderType, const Ipp8u pBorderValue[3], Ipp8u* pBuffer))
5083IPPAPI(IppStatus, ippiFilterMedianBorder_16s_C3R, (const Ipp16s* pSrc, int srcStep,
5084 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5085 IppiBorderType borderType, const Ipp16s pBorderValue[3], Ipp8u* pBuffer))
5086IPPAPI(IppStatus, ippiFilterMedianBorder_16u_C3R, (const Ipp16u* pSrc, int srcStep,
5087 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5088 IppiBorderType borderType, const Ipp16u pBorderValue[3], Ipp8u* pBuffer))
5089
5090IPPAPI(IppStatus, ippiFilterMedianBorder_8u_C4R, (const Ipp8u* pSrc, int srcStep,
5091 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5092 IppiBorderType borderType, const Ipp8u pBorderValue[4], Ipp8u* pBuffer))
5093IPPAPI(IppStatus, ippiFilterMedianBorder_16s_C4R, (const Ipp16s* pSrc, int srcStep,
5094 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5095 IppiBorderType borderType, const Ipp16s pBorderValue[4], Ipp8u* pBuffer))
5096IPPAPI(IppStatus, ippiFilterMedianBorder_16u_C4R, (const Ipp16u* pSrc, int srcStep,
5097 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5098 IppiBorderType borderType, const Ipp16u pBorderValue[4], Ipp8u* pBuffer))
5099
5100
5101/* /////////////////////////////////////////////////////////////////////////////
5102// Name: ippiFilterMaxBorderGetBufferSize
5103// ippiFilterMinBorderGetBufferSize
5104//
5105// Purpose: Computes the size of the external buffer for median filter with border
5106//
5107// Parameters:
5108// roiSize Size of destination ROI in pixels.
5109// maskSize Size of mask.
5110// dataType data type of source and destination images.
5111// numChannels Number of channels in the images. Possible values is 1.
5112// pBufferSize Pointer to the size (in bytes) of the external work buffer.
5113//
5114// Return Values:
5115// ippStsNoErr Indicates no error.
5116// ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
5117// ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
5118// ippStsMaskSizeErr Indicates an error when maskSize is negative, or equal to zero.
5119// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
5120// ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
5121*/
5122IPPAPI(IppStatus, ippiFilterMaxBorderGetBufferSize,(IppiSize dstRoiSize, IppiSize maskSize,
5123 IppDataType dataType, int numChannels, int* pBufferSize))
5124IPPAPI(IppStatus, ippiFilterMinBorderGetBufferSize,(IppiSize dstRoiSize, IppiSize maskSize,
5125 IppDataType dataType, int numChannels, int* pBufferSize))
5126
5127
5128/* ////////////////////////////////////////////////////////////////////////////
5129// Names: ippiFilterMaxBorder_8u_C1R
5130// ippiFilterMaxBorder_8u_C3R
5131// ippiFilterMaxBorder_8u_AC4R
5132// ippiFilterMaxBorder_8u_C4R
5133// ippiFilterMaxBorder_16s_C1R
5134// ippiFilterMaxBorder_16s_C3R
5135// ippiFilterMaxBorder_16s_AC4R
5136// ippiFilterMaxBorder_16s_C4R
5137// ippiFilterMaxBorder_16u_C1R
5138// ippiFilterMaxBorder_16u_C3R
5139// ippiFilterMaxBorder_16u_AC4R
5140// ippiFilterMaxBorder_16u_C4R
5141// ippiFilterMaxBorder_32f_C1R
5142// ippiFilterMaxBorder_32f_C3R
5143// ippiFilterMaxBorder_32f_AC4R
5144// ippiFilterMaxBorder_32f_C4R
5145// ippiFilterMinBorder_8u_C1R
5146// ippiFilterMinBorder_8u_C3R
5147// ippiFilterMinBorder_8u_AC4R
5148// ippiFilterMinBorder_8u_C4R
5149// ippiFilterMinBorder_16s_C1R
5150// ippiFilterMinBorder_16s_C3R
5151// ippiFilterMinBorder_16s_AC4R
5152// ippiFilterMinBorder_16s_C4R
5153// ippiFilterMinBorder_16u_C1R
5154// ippiFilterMinBorder_16u_C3R
5155// ippiFilterMinBorder_16u_AC4R
5156// ippiFilterMinBorder_16u_C4R
5157// ippiFilterMinBorder_32f_C1R
5158// ippiFilterMinBorder_32f_C3R
5159// ippiFilterMinBorder_32f_AC4R
5160// ippiFilterMinBorder_32f_C4R
5161//
5162// Purpose: Max and Min Filter with Border
5163// Parameters:
5164// pSrc Pointer to the source image ROI.
5165// srcStep Distance in bytes between starting points of consecutive lines in the sorce image.
5166// pDst Pointer to the destination image ROI.
5167// dstStep Distance in bytes between starting points of consecutive lines in the destination image.
5168// dstRoiSize Size of destination ROI in pixels.
5169// maskSize Size of mask.
5170// borderType Type of border.
5171// borderValue Constant value to assign to pixels of the constant border. This parameter is applicable
5172// only to the ippBorderConst border type.
5173// pBorderValue Pointer to constant value to assign to pixels of the constant border. This parameter is applicable
5174// only to the ippBorderConst border type.
5175// pBuffer Pointer to the work buffer.
5176//
5177// Return Values:
5178// ippStsNoErr Indicates no error.
5179// ippStsNullPtrErr Indicates an error when pBuffer is NULL while it must be no NULL.
5180// ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
5181// ippStsStepErr Indicates an error when srcStep or dstStep is negative, or equal to zero.
5182// ippStsBorderErr Indicates an error when borderType has illegal value.
5183*/
5184IPPAPI(IppStatus, ippiFilterMaxBorder_8u_C1R, (const Ipp8u* pSrc, int srcStep,
5185 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5186 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
5187IPPAPI(IppStatus, ippiFilterMaxBorder_8u_C3R, (const Ipp8u* pSrc, int srcStep,
5188 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5189 IppiBorderType borderType, const Ipp8u pBorderValue[3], Ipp8u* pBuffer))
5190IPPAPI(IppStatus, ippiFilterMaxBorder_8u_C4R, (const Ipp8u* pSrc, int srcStep,
5191 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5192 IppiBorderType borderType, const Ipp8u pBorderValue[4], Ipp8u* pBuffer))
5193IPPAPI(IppStatus, ippiFilterMaxBorder_16s_C1R, (const Ipp16s* pSrc, int srcStep,
5194 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5195 IppiBorderType borderType, Ipp16s borderValue, Ipp8u* pBuffer))
5196IPPAPI(IppStatus, ippiFilterMaxBorder_16s_C3R, (const Ipp16s* pSrc, int srcStep,
5197 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5198 IppiBorderType borderType, const Ipp16s pBorderValue[3], Ipp8u* pBuffer))
5199IPPAPI(IppStatus, ippiFilterMaxBorder_16s_C4R, (const Ipp16s* pSrc, int srcStep,
5200 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5201 IppiBorderType borderType, const Ipp16s pBorderValue[4], Ipp8u* pBuffer))
5202IPPAPI(IppStatus, ippiFilterMaxBorder_16u_C1R, (const Ipp16u* pSrc, int srcStep,
5203 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5204 IppiBorderType borderType, Ipp16u borderValue, Ipp8u* pBuffer))
5205IPPAPI(IppStatus, ippiFilterMaxBorder_16u_C3R, (const Ipp16u* pSrc, int srcStep,
5206 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5207 IppiBorderType borderType, const Ipp16u pBorderValue[3], Ipp8u* pBuffer))
5208IPPAPI(IppStatus, ippiFilterMaxBorder_16u_C4R, (const Ipp16u* pSrc, int srcStep,
5209 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5210 IppiBorderType borderType, const Ipp16u pBorderValue[4], Ipp8u* pBuffer))
5211IPPAPI(IppStatus, ippiFilterMaxBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
5212 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5213 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
5214IPPAPI(IppStatus, ippiFilterMaxBorder_32f_C3R, (const Ipp32f* pSrc, int srcStep,
5215 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5216 IppiBorderType borderType, const Ipp32f pBorderValue[3], Ipp8u* pBuffer))
5217IPPAPI(IppStatus, ippiFilterMaxBorder_32f_C4R, (const Ipp32f* pSrc, int srcStep,
5218 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5219 IppiBorderType borderType, const Ipp32f pBorderValue[4], Ipp8u* pBuffer))
5220
5221IPPAPI(IppStatus, ippiFilterMinBorder_8u_C1R, (const Ipp8u* pSrc, int srcStep,
5222 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5223 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
5224IPPAPI(IppStatus, ippiFilterMinBorder_8u_C3R, (const Ipp8u* pSrc, int srcStep,
5225 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5226 IppiBorderType borderType, const Ipp8u pBorderValue[3], Ipp8u* pBuffer))
5227IPPAPI(IppStatus, ippiFilterMinBorder_8u_C4R, (const Ipp8u* pSrc, int srcStep,
5228 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5229 IppiBorderType borderType, const Ipp8u pBorderValue[4], Ipp8u* pBuffer))
5230IPPAPI(IppStatus, ippiFilterMinBorder_16s_C1R, (const Ipp16s* pSrc, int srcStep,
5231 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5232 IppiBorderType borderType, Ipp16s borderValue, Ipp8u* pBuffer))
5233IPPAPI(IppStatus, ippiFilterMinBorder_16s_C3R, (const Ipp16s* pSrc, int srcStep,
5234 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5235 IppiBorderType borderType, const Ipp16s pBorderValue[3], Ipp8u* pBuffer))
5236IPPAPI(IppStatus, ippiFilterMinBorder_16s_C4R, (const Ipp16s* pSrc, int srcStep,
5237 Ipp16s* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5238 IppiBorderType borderType, const Ipp16s pBorderValue[4], Ipp8u* pBuffer))
5239IPPAPI(IppStatus, ippiFilterMinBorder_16u_C1R, (const Ipp16u* pSrc, int srcStep,
5240 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5241 IppiBorderType borderType, Ipp16u borderValue, Ipp8u* pBuffer))
5242IPPAPI(IppStatus, ippiFilterMinBorder_16u_C3R, (const Ipp16u* pSrc, int srcStep,
5243 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5244 IppiBorderType borderType, const Ipp16u pBorderValue[3], Ipp8u* pBuffer))
5245IPPAPI(IppStatus, ippiFilterMinBorder_16u_C4R, (const Ipp16u* pSrc, int srcStep,
5246 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5247 IppiBorderType borderType, const Ipp16u pBorderValue[4], Ipp8u* pBuffer))
5248IPPAPI(IppStatus, ippiFilterMinBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
5249 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5250 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
5251IPPAPI(IppStatus, ippiFilterMinBorder_32f_C3R, (const Ipp32f* pSrc, int srcStep,
5252 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5253 IppiBorderType borderType, const Ipp32f pBorderValue[3], Ipp8u* pBuffer))
5254IPPAPI(IppStatus, ippiFilterMinBorder_32f_C4R, (const Ipp32f* pSrc, int srcStep,
5255 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize,
5256 IppiBorderType borderType, const Ipp32f pBorderValue[4], Ipp8u* pBuffer))
5257
5258
5259/* /////////////////////////////////////////////////////////////////////////////
5260// Bilateral filter function
5261*/
5262
5263/* /////////////////////////////////////////////////////////////////////////////
5264// Bilateral filter functions with Border
5265// /////////////////////////////////////////////////////////////////////////////
5266// Name: ippiFilterBilateralBorderGetBufferSize
5267// Purpose: to define buffer size for bilateral filter
5268// Parameters:
5269// filter Type of bilateral filter. Possible value is ippiFilterBilateralGauss.
5270// dstRoiSize Roi size (in pixels) of destination image what will be applied
5271// for processing.
5272// radius Radius of circular neighborhood what defines pixels for calculation.
5273// dataType Data type of the source and desination images. Possible values
5274// are ipp8u and ipp32f.
5275// numChannels Number of channels in the images. Possible values are 1 and 3.
5276// distMethod The type of method for definition of distance beetween pixel untensity.
5277// Possible value is ippDistNormL1.
5278// pSpecSize Pointer to the size (in bytes) of the spec.
5279// pBufferSize Pointer to the size (in bytes) of the external work buffer.
5280// Return:
5281// ippStsNoErr OK
5282// ippStsNullPtrErr any pointer is NULL
5283// ippStsSizeErr size of dstRoiSize is less or equal 0
5284// ippStsMaskSizeErr radius is less or equal 0
5285// ippStsNotSupportedModeErr filter or distMethod is not supported
5286// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
5287// ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
5288*/
5289IPPAPI(IppStatus,ippiFilterBilateralBorderGetBufferSize,
5290 (IppiFilterBilateralType filter, IppiSize dstRoiSize,
5291 int radius, IppDataType dataType, int numChannels,
5292 IppiDistanceMethodType distMethodType, int *pSpecSize, int *pBufferSize))
5293
5294
5295/* /////////////////////////////////////////////////////////////////////////////
5296// Name: ippiFilterBilateralBorderInit
5297// Purpose: initialization of Spec for bilateral filter with border
5298// Parameters:
5299// filter Type of bilateral filter. Possible value is ippiFilterBilateralGauss.
5300// dstRoiSize Roi size (in pixels) of destination image what will be applied
5301// for processing.
5302// radius Radius of circular neighborhood what defines pixels for calculation.
5303// dataType Data type of the source and desination images. Possible values
5304// are ipp8u and ipp32f.
5305// numChannels Number of channels in the images. Possible values are 1 and 3.
5306// distMethodType The type of method for definition of distance beetween pixel intensity.
5307// Possible value is ippDistNormL1.
5308// valSquareSigma square of Sigma for factor function for pixel intensity
5309// posSquareSigma square of Sigma for factor function for pixel position
5310// pSpec pointer to Spec
5311// Return:
5312// ippStsNoErr OK
5313// ippStsNullPtrErr pointer ro Spec is NULL
5314// ippStsSizeErr size of dstRoiSize is less or equal 0
5315// ippStsMaskSizeErr radius is less or equal 0
5316// ippStsNotSupportedModeErr filter or distMethod is not supported
5317// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
5318// ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
5319// ippStsBadArgErr valSquareSigma or posSquareSigma is less or equal 0
5320*/
5321IPPAPI(IppStatus,ippiFilterBilateralBorderInit,
5322 (IppiFilterBilateralType filter, IppiSize dstRoiSize,
5323 int radius, IppDataType dataType, int numChannels,
5324 IppiDistanceMethodType distMethod, Ipp32f valSquareSigma,
5325 Ipp32f posSquareSigma, IppiFilterBilateralSpec *pSpec))
5326
5327
5328/* /////////////////////////////////////////////////////////////////////////////
5329// Name: ippiFilterBilateralBorder_8u_C1R
5330// ippiFilterBilateralBorder_8u_C3R
5331// ippiFilterBilateralBorder_32f_C1R
5332// ippiFilterBilateralBorder_32f_C3R
5333// Purpose: bilateral filter
5334// Parameters:
5335// pSrc Pointer to the source image
5336// srcStep Step through the source image
5337// pDst Pointer to the destination image
5338// dstStep Step through the destination image
5339// dstRoiSize Size of the destination ROI
5340// borderType Type of border.
5341// borderValue Pointer to constant value to assign to pixels of the constant border. This parameter is applicable
5342// only to the ippBorderConst border type. If this pointer is NULL than the constant value is equal 0.
5343// pSpec Pointer to filter spec
5344// pBuffer Pointer ro work buffer
5345// Return:
5346// ippStsNoErr OK
5347// ippStsNullPtrErr pointer to Src, Dst, Spec or Buffer is NULL
5348// ippStsSizeErr size of dstRoiSize is less or equal 0
5349// ippStsContextMatchErr filter Spec is not match
5350// ippStsNotEvenStepErr Indicated an error when one of the step values is not divisible by 4
5351// for floating-point images.
5352// ippStsBorderErr Indicates an error when borderType has illegal value.
5353*/
5354IPPAPI(IppStatus,ippiFilterBilateralBorder_8u_C1R,(const Ipp8u *pSrc, int srcStep,
5355 Ipp8u *pDst, int dstStep, IppiSize dstRoiSize,
5356 IppiBorderType borderType, Ipp8u *pBorderValue, IppiFilterBilateralSpec *pSpec,
5357 Ipp8u* pBuffer))
5358IPPAPI(IppStatus,ippiFilterBilateralBorder_8u_C3R,(const Ipp8u *pSrc, int srcStep,
5359 Ipp8u *pDst, int dstStep, IppiSize dstRoiSize,
5360 IppiBorderType borderType, Ipp8u *pBorderValue, IppiFilterBilateralSpec *pSpec,
5361 Ipp8u* pBuffer))
5362IPPAPI(IppStatus,ippiFilterBilateralBorder_32f_C1R,(const Ipp32f *pSrc, int srcStep,
5363 Ipp32f *pDst, int dstStep, IppiSize dstRoiSize,
5364 IppiBorderType borderType, Ipp32f *pBorderValue, IppiFilterBilateralSpec *pSpec,
5365 Ipp8u* pBuffer))
5366IPPAPI(IppStatus,ippiFilterBilateralBorder_32f_C3R,(const Ipp32f *pSrc, int srcStep,
5367 Ipp32f *pDst, int dstStep, IppiSize dstRoiSize,
5368 IppiBorderType borderType, Ipp32f *pBorderValue, IppiFilterBilateralSpec *pSpec,
5369 Ipp8u* pBuffer))
5370
5371
5372/* ////////////////////////////////////////////////////////////////////////////
5373// Names: ippiLUTPalette
5374// Purpose: intensity transformation of image using the palette lookup table pTable
5375// Parameters:
5376// pSrc pointer to the source image
5377// srcStep line offset in input data in bytes
5378// alphaValue constant alpha channel
5379// pDst pointer to the destination image
5380// dstStep line offset in output data in bytes
5381// roiSize size of source ROI in pixels
5382// pTable pointer to palette table of size 2^nBitSize or
5383// array of pointers to each channel
5384// nBitSize number of valid bits in the source image
5385// (range [1,8] for 8u source images and range [1,16] for 16u source images)
5386// Returns:
5387// ippStsNoErr no errors
5388// ippStsNullPtrErr pSrc == NULL or pDst == NULL or pTable == NULL
5389// ippStsSizeErr width or height of ROI is less or equal zero
5390// ippStsOutOfRangeErr nBitSize is out of range
5391// Notes:
5392*/
5393
5394IPPAPI(IppStatus, ippiLUTPalette_8u_C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
5395 IppiSize roiSize, const Ipp8u* const pTable[3], int nBitSize))
5396
5397IPPAPI(IppStatus, ippiLUTPalette_8u_C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
5398 IppiSize roiSize, const Ipp8u* const pTable[4], int nBitSize))
5399
5400
5401/* =============================================================================
5402 ippCV
5403============================================================================= */
5404
5405/* ///////////////////////////////////////////////////////////////////////////////////////
5406// Name: ippcvGetLibVersion
5407//
5408// Purpose: getting of the library version
5409//
5410// Returns: the structure of information about version of ippcv library
5411//
5412// Parameters:
5413//
5414// Notes: not necessary to release the returned structure
5415*/
5416IPPAPI( const IppLibraryVersion*, ippcvGetLibVersion, (void) )
5417
5418
5419/****************************************************************************************\
5420* Fixed Filters *
5421\****************************************************************************************/
5422
5423
5424/* ///////////////////////////////////////////////////////////////////////////////////////////////////
5425// Name: ippiFilterSobelCrossGetBufferSize_8u16s_C1R, ippiFilterLaplacianGetBufferSize_8u16s_C1R,
5426// ippiFilterLowpassGetBufferSize_8u_C1R, ippiFilterSobelCrossGetBufferSize_32f_C1R,
5427// ippiFilterLaplacianGetBufferSize_32f_C1R, ippiFilterLowpassGetBufferSize_32f_C1R
5428//
5429//
5430// Purpose: Perform convolution operation with fixed kernels 3x3 and 5x5
5431//
5432// Return:
5433// ippStsNoErr Ok
5434// ippStsNullPtrErr One of pointers is NULL
5435// ippStsSizeErr The width of the image is less or equal zero
5436// ippStsMaskSizeErr Wrong mask size
5437//
5438// Parameters:
5439// roiSize The image ROI size
5440// mask The mask size
5441// pBufferSize The pointer to the buffer size
5442*/
5443IPPAPI(IppStatus, ippiFilterLaplacianGetBufferSize_8u16s_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
5444
5445IPPAPI(IppStatus, ippiFilterLaplacianGetBufferSize_32f_C1R, (IppiSize roiSize, IppiMaskSize mask, int* pBufferSize))
5446
5447
5448/*F///////////////////////////////////////////////////////////////////////////////////////
5449// Name: ippiFilterSobelCrossBorder_8u16s_C1R, ippiFilterLaplacianBorder_8u16s_C1R
5450// ippiFilterLowpassBorder_8u_C1R, ippiFilterSobelCrossBorder_32f_C1R
5451// ippiFilterLowpassBorder_32f_C1R, ippiFilterLaplacianBorder_32f_C1R
5452//
5453// Purpose: Perform convolution operation with fixed kernels 3x3 and 5x5
5454//
5455// Return:
5456// ippStsNoErr Ok
5457// ippStsNullPtrErr One of pointers is NULL
5458// ippStsSizeErr The width or height of images is less or equal zero
5459// ippStsStepErr The steps in images are too small
5460// ippStsNotEvenStepErr Step is not multiple of element.
5461// ippStsMaskSizeErr Wrong mask size
5462// ippStsBadArgErr Wrong border type or zero divisor
5463//
5464// Parameters:
5465// pSrc The pointer to the source image
5466// srcStep The step in the source image
5467// pDst The pointer to the destination image
5468// dstStep The step in the destination image
5469// roiSize The image ROI size
5470// mask The mask size
5471// borderType The type of the border
5472// borderValue The value for the constant border
5473// pBuffer The pointer to the working buffer
5474// divisor The value to divide output pixels by , (for integer functions)
5475//F*/
5476
5477IPPAPI(IppStatus, ippiFilterLaplacianBorder_8u16s_C1R, (const Ipp8u* pSrc, int srcStep,
5478 Ipp16s* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
5479 IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
5480
5481IPPAPI(IppStatus, ippiFilterLaplacianBorder_32f_C1R, (const Ipp32f* pSrc, int srcStep,
5482 Ipp32f* pDst, int dstStep, IppiSize roiSize, IppiMaskSize mask,
5483 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
5484
5485
5486/****************************************************************************************\
5487* Separable Filters *
5488\****************************************************************************************/
5489
5490
5491/* ///////////////////////////////////////////////////////////////////////////////////////////////////
5492// Name: ippiFilterRowBorderPipelineGetBufferSize_8u16s_C1R, ippiFilterRowBorderPipelineGetBufferSize_8u16s_C3R
5493// ippiFilterRowBorderPipelineGetBufferSize_16s_C1R, ippiFilterRowBorderPipelineGetBufferSize_16s_C3R
5494// ippiFilterRowBorderPipelineGetBufferSize_16u_C1R, ippiFilterRowBorderPipelineGetBufferSize_16u_C3R
5495// ippiFilterRowBorderPipelineGetBufferSize_Low_16s_C1R, ippiFilterRowBorderPipelineGetBufferSize_Low_16s_C3R
5496// ippiFilterRowBorderPipelineGetBufferSize_32f_C1R, ippiFilterRowBorderPipelineGetBufferSize_32f_C3R
5497//
5498// Purpose: Get size of external buffer.
5499//
5500// Return:
5501// ippStsNoErr Ok
5502// ippStsNullPtrErr One of pointers is NULL
5503// ippStsSizeErr The width of the image or kernel size are less or equal zero
5504//
5505// Parameters:
5506// roiSize The image ROI size
5507// kernelSize The size of the kernel
5508// pBufferSize The pointer to the buffer size
5509*/
5510
5511IPPAPI(IppStatus, ippiFilterRowBorderPipelineGetBufferSize_32f_C1R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
5512
5513IPPAPI(IppStatus, ippiFilterRowBorderPipelineGetBufferSize_32f_C3R, (IppiSize roiSize, int kernelSize, int* pBufferSize))
5514
5515
5516/*F///////////////////////////////////////////////////////////////////////////////////////////
5517// Name: ippiFilterRowBorderPipeline_8u16s_C1R, ippiFilterRowBorderPipeline_8u16s_C3R
5518// ippiFilterRowBorderPipeline_16s_C1R, ippiFilterRowBorderPipeline_16s_C3R
5519// ippiFilterRowBorderPipeline_16u_C1R, ippiFilterRowBorderPipeline_16u_C3R
5520// ippiFilterRowBorderPipeline_Low_16s_C1R, ippiFilterRowBorderPipeline_Low_16s_C3R
5521// ippiFilterRowBorderPipeline_32f_C1R, ippiFilterRowBorderPipeline_32f_C3R
5522//
5523// Purpose: Convolves source image rows with the row kernel
5524//
5525// Return:
5526// ippStsNoErr Ok
5527// ippStsNullPtrErr One of pointers is NULL
5528// ippStsSizeErr The width or height of images is less or equal zero
5529// ippStsStepErr The steps in images are too small
5530// ippStsNotEvenStepErr Step is not multiple of element.
5531// ippStsAnchorErr The anchor outside the kernel
5532// ippStsBadArgErr Wrong border type or zero divisor
5533//
5534// Parameters:
5535// pSrc The pointer to the source image
5536// srcStep The step in the source image
5537// ppDst The double pointer to the destination image
5538// roiSize The image ROI size
5539// pKernel The pointer to the kernel
5540// kernelSize The size of the kernel
5541// xAnchor The anchor value , (0<=xAnchor<kernelSize)
5542// borderType The type of the border
5543// borderValue The value for the constant border
5544// divisor The value to divide output pixels by , (for integer functions)
5545// pBuffer The pointer to the working buffer
5546// Notes: The output is the doulble pointer to support the circle buffer
5547//F*/
5548
5549IPPAPI(IppStatus, ippiFilterRowBorderPipeline_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f** ppDst,
5550 IppiSize roiSize, const Ipp32f* pKernel, int kernelSize, int xAnchor,
5551 IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
5552
5553IPPAPI(IppStatus, ippiFilterRowBorderPipeline_32f_C3R, (const Ipp32f* pSrc, int srcStep, Ipp32f** ppDst,
5554 IppiSize roiSize, const Ipp32f* pKernel, int kernelSize, int xAnchor,
5555 IppiBorderType borderType, Ipp32f borderValue[3], Ipp8u* pBuffer))
5556
5557
5558/* ///////////////////////////////////////////////////////////////////////////////////////
5559// Name: ippiAdd_8u32f_C1IR, ippiAdd_8s32f_C1IR,
5560// ippiAdd_16u32f_C1IR,
5561// ippiAdd_8u32f_C1IMR, ippiAdd_8s32f_C1IMR,
5562// ippiAdd_16u32f_C1IMR, ippiAdd_32f_C1IMR
5563//
5564// Purpose: Add image to accumulator.
5565//
5566// Return:
5567// ippStsNoErr Ok
5568// ippStsNullPtrErr One of pointers is NULL
5569// ippStsSizeErr The width or height of images is less or equal zero
5570// ippStsStepErr Step is too small to fit image.
5571// ippStsNotEvenStepErr Step is not multiple of element.
5572//
5573// Arguments:
5574// pSrc Pointer to source image
5575// srcStep Step in the source image
5576// pMask Pointer to mask
5577// maskStep Step in the mask image
5578// pSrcDst Pointer to accumulator image
5579// srcDstStep Step in the accumulator image
5580// roiSize Image size
5581*/
5582
5583IPPAPI(IppStatus, ippiAdd_8u32f_C1IR, (const Ipp8u* pSrc, int srcStep,
5584 Ipp32f* pSrcDst, int srcDstStep,
5585 IppiSize roiSize ))
5586
5587IPPAPI(IppStatus, ippiAdd_16u32f_C1IR, (const Ipp16u* pSrc, int srcStep,
5588 Ipp32f* pSrcDst, int srcDstStep,
5589 IppiSize roiSize ))
5590
5591
5592IPPAPI(IppStatus, ippiAdd_8u32f_C1IMR,(const Ipp8u* pSrc, int srcStep,
5593 const Ipp8u* pMask, int maskStep,
5594 Ipp32f* pSrcDst, int srcDstStep,
5595 IppiSize roiSize ))
5596
5597IPPAPI(IppStatus, ippiAdd_16u32f_C1IMR,(const Ipp16u* pSrc, int srcStep,
5598 const Ipp8u* pMask, int maskStep,
5599 Ipp32f* pSrcDst, int srcDstStep,
5600 IppiSize roiSize ))
5601
5602IPPAPI(IppStatus, ippiAdd_32f_C1IMR, (const Ipp32f* pSrc, int srcStep,
5603 const Ipp8u* pMask, int maskStep,
5604 Ipp32f* pSrcDst, int srcDstStep,
5605 IppiSize roiSize ))
5606
5607
5608
5609
5610/* ///////////////////////////////////////////////////////////////////////////////////////
5611// Name: ippiAddSquare_8u32f_C1IR, ippiAddSquare_8s32f_C1IR,
5612// ippiAddSquare_16u32f_C1IR, ippiAddSquare_32f_C1IR,
5613// ippiAddSquare_8u32f_C1IMR, ippiAddSquare_8s32f_C1IMR,
5614// ippiAddSquare_16u32f_C1IMR, ippiAddSquare_32f_C1IMR
5615//
5616// Purpose: Add squared image (i.e. multiplied by itself) to accumulator.
5617//
5618// Return:
5619// ippStsNoErr Ok
5620// ippStsNullPtrErr One of pointers is NULL
5621// ippStsSizeErr The width or height of images is less or equal zero
5622// ippStsStepErr Step is too small to fit image.
5623// ippStsNotEvenStepErr Step is not multiple of element.
5624//
5625// Arguments:
5626// pSrc Pointer to source image
5627// srcStep Step in the source image
5628// pMask Pointer to mask
5629// maskStep Step in the mask image
5630// pSrcDst Pointer to accumulator image
5631// srcDstStep Step in the accumulator image
5632// roiSize Image size
5633*/
5634
5635IPPAPI(IppStatus, ippiAddSquare_8u32f_C1IR, (const Ipp8u* pSrc, int srcStep,
5636 Ipp32f* pSrcDst, int srcDstStep,
5637 IppiSize roiSize ))
5638
5639IPPAPI(IppStatus, ippiAddSquare_16u32f_C1IR, (const Ipp16u* pSrc, int srcStep,
5640 Ipp32f* pSrcDst, int srcDstStep,
5641 IppiSize roiSize ))
5642
5643IPPAPI(IppStatus, ippiAddSquare_32f_C1IR, (const Ipp32f* pSrc, int srcStep,
5644 Ipp32f* pSrcDst, int srcDstStep,
5645 IppiSize roiSize ))
5646
5647IPPAPI(IppStatus, ippiAddSquare_8u32f_C1IMR,(const Ipp8u* pSrc, int srcStep,
5648 const Ipp8u* pMask, int maskStep,
5649 Ipp32f* pSrcDst, int srcDstStep,
5650 IppiSize roiSize ))
5651
5652IPPAPI(IppStatus, ippiAddSquare_16u32f_C1IMR,(const Ipp16u* pSrc, int srcStep,
5653 const Ipp8u* pMask, int maskStep,
5654 Ipp32f* pSrcDst, int srcDstStep,
5655 IppiSize roiSize ))
5656
5657IPPAPI(IppStatus, ippiAddSquare_32f_C1IMR, (const Ipp32f* pSrc, int srcStep,
5658 const Ipp8u* pMask, int maskStep,
5659 Ipp32f* pSrcDst, int srcDstStep,
5660 IppiSize roiSize ))
5661
5662
5663/* ///////////////////////////////////////////////////////////////////////////////////////
5664// Name: ippiAddProduct_8u32f_C1IR, ippiAddProduct_8s32f_C1IR,
5665// ippiAddProduct_16u32f_C1IR, ippiAddProduct_32f_C1IR,
5666// ippiAddProduct_8u32f_C1IMR, ippiAddProduct_8s32f_C1IMR,
5667// ippiAddProduct_16u32f_C1IMR, ippiAddProduct_32f_C1IMR
5668//
5669// Purpose: Add product of two images to accumulator.
5670//
5671// Return:
5672// ippStsNoErr Ok
5673// ippStsNullPtrErr One of pointers is NULL
5674// ippStsSizeErr The width or height of images is less or equal zero
5675// ippStsStepErr Step is too small to fit image.
5676// ippStsNotEvenStepErr Step is not multiple of element.
5677//
5678// Arguments:
5679// pSrc1 Pointer to first source image
5680// src1Step Step in the first source image
5681// pSrc2 Pointer to second source image
5682// src2Step Step in the second source image
5683// pMask Pointer to mask
5684// maskStep Step in the mask image
5685// pSrcDst Pointer to accumulator image
5686// srcDstStep Step in the accumulator image
5687// roiSize Image size
5688*/
5689
5690IPPAPI(IppStatus, ippiAddProduct_8u32f_C1IR, (const Ipp8u* pSrc1, int src1Step,
5691 const Ipp8u* pSrc2, int src2Step,
5692 Ipp32f* pSrcDst, int srcDstStep,
5693 IppiSize roiSize ))
5694
5695IPPAPI(IppStatus, ippiAddProduct_16u32f_C1IR, (const Ipp16u* pSrc1, int src1Step,
5696 const Ipp16u* pSrc2, int src2Step,
5697 Ipp32f* pSrcDst, int srcDstStep,
5698 IppiSize roiSize ))
5699
5700IPPAPI(IppStatus, ippiAddProduct_32f_C1IR, (const Ipp32f* pSrc1, int src1Step,
5701 const Ipp32f* pSrc2, int src2Step,
5702 Ipp32f* pSrcDst, int srcDstStep,
5703 IppiSize roiSize ))
5704
5705IPPAPI(IppStatus, ippiAddProduct_8u32f_C1IMR,(const Ipp8u* pSrc1, int src1Step,
5706 const Ipp8u* pSrc2, int src2Step,
5707 const Ipp8u* pMask, int maskStep,
5708 Ipp32f* pSrcDst, int srcDstStep,
5709 IppiSize roiSize ))
5710
5711IPPAPI(IppStatus, ippiAddProduct_16u32f_C1IMR,(const Ipp16u* pSrc1, int src1Step,
5712 const Ipp16u* pSrc2, int src2Step,
5713 const Ipp8u* pMask, int maskStep,
5714 Ipp32f* pSrcDst, int srcDstStep,
5715 IppiSize roiSize ))
5716
5717IPPAPI(IppStatus, ippiAddProduct_32f_C1IMR, (const Ipp32f* pSrc1, int src1Step,
5718 const Ipp32f* pSrc2, int src2Step,
5719 const Ipp8u* pMask, int maskStep,
5720 Ipp32f* pSrcDst, int srcDstStep,
5721 IppiSize roiSize ))
5722
5723
5724/* ///////////////////////////////////////////////////////////////////////////////////////
5725// Name: ippiAddWeighted_8u32f_C1IR, ippiAddWeighted_8s32f_C1IR,
5726// ippiAddWeighted_16u32f_C1IR, ippiAddWeighted_32f_C1IR,
5727// ippiAddWeighted_8u32f_C1IMR, ippiAddWeighted_8s32f_C1IMR,
5728// ippiAddWeighted_16u32f_C1IMR,ippiAddWeighted_32f_C1IMR
5729// ippiAddWeighted_32f_C1R
5730//
5731// Purpose: Add image, multiplied by alpha, to accumulator, multiplied by (1 - alpha).
5732//
5733// Return:
5734// ippStsNoErr Ok
5735// ippStsNullPtrErr One of pointers is NULL
5736// ippStsSizeErr The width or height of images is less or equal zero
5737// ippStsStepErr Step is too small to fit image.
5738// ippStsNotEvenStepErr Step is not multiple of element.
5739//
5740// Arguments:
5741// pSrc1 Pointer to first source image
5742// src1Step Step in the first source image
5743// pSrc2 Pointer to second source image
5744// src2Step Step in the second source image
5745// pMask Pointer to mask
5746// maskStep Step in the mask image
5747// pSrcDst Pointer to accumulator image
5748// srcDstStep Step in the accumulator image
5749// pDst Pointer to destination image
5750// dstStep Step in the destination image
5751// roiSize Image size
5752// alpha Weight of source image
5753*/
5754
5755IPPAPI(IppStatus, ippiAddWeighted_8u32f_C1IR, (const Ipp8u* pSrc, int srcStep,
5756 Ipp32f* pSrcDst, int srcDstStep,
5757 IppiSize roiSize, Ipp32f alpha ))
5758
5759IPPAPI(IppStatus, ippiAddWeighted_16u32f_C1IR, (const Ipp16u* pSrc, int srcStep,
5760 Ipp32f* pSrcDst, int srcDstStep,
5761 IppiSize roiSize, Ipp32f alpha ))
5762
5763IPPAPI(IppStatus, ippiAddWeighted_32f_C1IR, (const Ipp32f* pSrc, int srcStep,
5764 Ipp32f* pSrcDst, int srcDstStep,
5765 IppiSize roiSize, Ipp32f alpha ))
5766
5767IPPAPI(IppStatus, ippiAddWeighted_8u32f_C1IMR,(const Ipp8u* pSrc, int srcStep,
5768 const Ipp8u* pMask, int maskStep,
5769 Ipp32f* pSrcDst, int srcDstStep,
5770 IppiSize roiSize, Ipp32f alpha ))
5771
5772IPPAPI(IppStatus, ippiAddWeighted_16u32f_C1IMR,(const Ipp16u* pSrc, int srcStep,
5773 const Ipp8u* pMask, int maskStep,
5774 Ipp32f* pSrcDst, int srcDstStep,
5775 IppiSize roiSize, Ipp32f alpha ))
5776
5777IPPAPI(IppStatus, ippiAddWeighted_32f_C1IMR, (const Ipp32f* pSrc, int srcStep,
5778 const Ipp8u* pMask, int maskStep,
5779 Ipp32f* pSrcDst, int srcDstStep,
5780 IppiSize roiSize, Ipp32f alpha ))
5781
5782
5783/*F////////////////////////////////////////////////////////////////////////////////////////////////
5784// Name: ippiCopySubpixIntersect_8u_C1R, ippiCopySubpixIntersect_16u_C1R,
5785// ippiCopySubpixIntersect_8u16u_C1R_Sfs, ippiCopySubpixIntersect_16u32f_C1R,
5786// ippiCopySubpixIntersect_8u32f_C1R, ippiCopySubpixIntersect_32f_C1R
5787//
5788// Purpose: finds intersection of centered window in the source image and copies
5789// in to destination image with the border
5790// border pixel are taken from the source image or replicated if they are outside it
5791//
5792// Returns:
5793// ippStsNoErr Ok
5794// ippStsNullPtrErr One of pointers is NULL
5795// ippStsSizeErr The width or height of images is less or equal zero
5796// ippStsStepErr The steps in images are too small
5797// ippStsNotEvenStepErr Step is not multiple of element.
5798//
5799// Parameters:
5800// pSrc Pointer to source image
5801// srcStep Step in source image
5802// srcRoiSize Source image ROI size.
5803// pDst Pointer to destination image
5804// dstStep Step in destination image
5805// dstRoiSize Destination image ROI size.
5806// point Center of dst window in src image (subpixel)
5807// pMin Top left corner of dst filled part
5808// pMax Bottom right corner of dst filled part
5809// scaleFactor Output scale factor, >= 0
5810//
5811// Notes: For integer point.x or point.y pixels from the last row
5812// or column are not copied. Branches are possible.
5813//F*/
5814
5815IPPAPI(IppStatus, ippiCopySubpixIntersect_8u_C1R, (const Ipp8u* pSrc, int srcStep,
5816 IppiSize srcRoiSize, Ipp8u* pDst, int dstStep, IppiSize dstRoiSize,
5817 IppiPoint_32f point, IppiPoint *pMin, IppiPoint *pMax))
5818
5819IPPAPI(IppStatus, ippiCopySubpixIntersect_8u32f_C1R, (const Ipp8u* pSrc, int srcStep,
5820 IppiSize srcRoiSize, Ipp32f* pDst, int dstStep, IppiSize dstRoiSize,
5821 IppiPoint_32f point, IppiPoint *pMin, IppiPoint *pMax))
5822
5823IPPAPI(IppStatus, ippiCopySubpixIntersect_32f_C1R, (const Ipp32f* pSrc, int srcStep,
5824 IppiSize srcRoiSize, Ipp32f* pDst, int dstStep, IppiSize dstRoiSize,
5825 IppiPoint_32f point, IppiPoint *pMin, IppiPoint *pMax))
5826
5827
5828/****************************************************************************************\
5829* Universal Pyramids *
5830\****************************************************************************************/
5831
5832/* ///////////////////////////////////////////////////////////////////////////////////////
5833// Name: ippiPyramidGetSize
5834//
5835// Purpose: Computes the size of the structure for pyramids and the size
5836// of the required work buffer (in bytes)
5837//
5838// Arguments:
5839// pPyrSize Pointer to the size value of pyramid structure
5840// pSizeBuf Pointer to the size value of the pyramid external work buffer
5841// level Maximal number pyramid level.
5842// roiSize Zero level image ROI size.
5843// rate Neighbour levels ratio (1<rate<=10)
5844//
5845// Return:
5846// ippStsNoErr Ok
5847// ippStsNullPtrErr One of pointers is NULL
5848// ippStsSizeErr roiSize has a field with zero or negative value.
5849// ippStsBadArgErr level is equal to or less than 0 or if rate has wrong value.
5850*/
5851
5852IPPAPI( IppStatus, ippiPyramidGetSize,(int* pPyrSize, int* pBufSize, int level, IppiSize roiSize, Ipp32f rate))
5853
5854
5855/* ///////////////////////////////////////////////////////////////////////////////////////
5856// Name: ippiPyramidInit
5857//
5858// Purpose: Initializes structure for pyramids, calculates ROI for layers.
5859//
5860// Arguments:
5861// pPyr Pointer to the pointer to the pyramid structure.
5862// level Maximal number pyramid level.
5863// roiSize Zero level image ROI size.
5864// rate Neighbour levels ratio (1<rate<=10).
5865// pPyrBuffer Pointer to the buffer to initialize structure for pyramids.
5866// pBuffer Pointer to the work buffer.
5867//
5868// Return:
5869// ippStsNoErr Ok
5870// ippStsNullPtrErr One of pointers is NULL
5871// ippStsSizeErr roiSize has a field with zero or negative value.
5872// ippStsBadArgErr level is equal to or less than 0 or if rate has wrong value.
5873*/
5874
5875IPPAPI( IppStatus, ippiPyramidInit,( IppiPyramid** pPyr, int level, IppiSize roiSize, Ipp32f rate, Ipp8u* pPyrBuffer, Ipp8u* pBuffer))
5876
5877
5878/* ///////////////////////////////////////////////////////////////////////////////////////
5879// Name: ippiPyramidLayerDownGetSize_8u_C1R, ippiPyramidLayerDownGetSize_8u_C3R
5880// ippiPyramidLayerDownGetSize_16u_C1R, ippiPyramidLayerDownGetSize_16u_C3R
5881// ippiPyramidLayerDownGetSize_32f_C1R, ippiPyramidLayerDownGetSize_32f_C3R
5882// ippiPyramidLayerUpGetSize_8u_C1R, ippiPyramidLayerUpGetSize_8u_C3R
5883// ippiPyramidLayerUpGetSize_16u_C1R, ippiPyramidLayerUpGetSize_16u_C3R
5884// ippiPyramidLayerUpGetSizec_32f_C1R, ippiPyramidLayerUpGetSize_32f_C3R
5885//
5886// Purpose: Calculates the size of structure for creating a lower(an upper) pyramid layer and the size
5887// of the temporary buffer (in bytes).
5888//
5889// Arguments:
5890// srcRoi Source image ROI size.
5891// dstRoi Destination image ROI size.
5892// rate Neighbour levels ratio (1<rate<=10)
5893// kerSize Kernel size
5894// pStateSize Pointer to the size value of pyramid state structure.
5895// pBufSize Pointer to the size value of the external work buffer.
5896//
5897// Return:
5898// ippStsNoErr Ok
5899// ippStsNullPtrErr One of pointers is NULL
5900// ippStsSizeErr The width or height of images is less or equal zero
5901// ippStsBadArgErr Bad rate or kernel size
5902//
5903*/
5904
5905IPPAPI(IppStatus, ippiPyramidLayerDownGetSize_8u_C1R, (IppiSize srcRoi, Ipp32f rate, int kerSize,
5906 int* pStateSize, int* pBufSize))
5907IPPAPI(IppStatus, ippiPyramidLayerDownGetSize_16u_C1R,(IppiSize srcRoi, Ipp32f rate, int kerSize,
5908 int* pStateSize, int* pBufSize))
5909IPPAPI(IppStatus, ippiPyramidLayerDownGetSize_32f_C1R,(IppiSize srcRoi, Ipp32f rate, int kerSize,
5910 int* pStateSize, int* pBufSize))
5911IPPAPI(IppStatus, ippiPyramidLayerDownGetSize_8u_C3R, (IppiSize srcRoi, Ipp32f rate, int kerSize,
5912 int* pStateSize, int* pBufSize))
5913IPPAPI(IppStatus, ippiPyramidLayerDownGetSize_16u_C3R,(IppiSize srcRoi, Ipp32f rate, int kerSize,
5914 int* pStateSize, int* pBufSize))
5915IPPAPI(IppStatus, ippiPyramidLayerDownGetSize_32f_C3R,(IppiSize srcRoi, Ipp32f rate, int kerSize,
5916 int* pStateSize, int* pBufSize))
5917
5918
5919IPPAPI(IppStatus, ippiPyramidLayerUpGetSize_8u_C1R, (IppiSize dstRoi, Ipp32f rate, int kerSize, int* pStateSize))
5920IPPAPI(IppStatus, ippiPyramidLayerUpGetSize_16u_C1R,(IppiSize dstRoi, Ipp32f rate, int kerSize, int* pStateSize))
5921IPPAPI(IppStatus, ippiPyramidLayerUpGetSize_32f_C1R,(IppiSize dstRoi, Ipp32f rate, int kerSize, int* pStateSize))
5922IPPAPI(IppStatus, ippiPyramidLayerUpGetSize_8u_C3R, (IppiSize dstRoi, Ipp32f rate, int kerSize, int* pStateSize))
5923IPPAPI(IppStatus, ippiPyramidLayerUpGetSize_16u_C3R,(IppiSize dstRoi, Ipp32f rate, int kerSize, int* pStateSize))
5924IPPAPI(IppStatus, ippiPyramidLayerUpGetSize_32f_C3R,(IppiSize dstRoi, Ipp32f rate, int kerSize, int* pStateSize))
5925
5926
5927
5928
5929/* ///////////////////////////////////////////////////////////////////////////////////////
5930// Name: ippiPyramidLayerDownInit_8u_C1R, ippiPyramidLayerDownInit_8u_C3R
5931// ippiPyramidLayerDownInit_16u_C1R, ippiPyramidLayerDownInit_16u_C3R
5932// ippiPyramidLayerDownInit_32f_C1R, ippiPyramidLayerDownInit_32f_C3R
5933// ippiPyramidLayerUpInit_8u_C1R, ippiPyramidLayerUpInit_8u_C3R
5934// ippiPyramidLayerUpInit_16u_C1R, ippiPyramidLayerUpInit_16u_C3R
5935// ippiPyramidLayerUpInit_32f_C1R, ippiPyramidLayerUpInit_32f_C3R
5936//
5937// Purpose: Initializesa structure for creating a lower(an upper) pyramid layer.
5938//
5939// Arguments:
5940// ppState Pointer to the pointer to initialized pyramid state structure
5941// srcRoi Source image ROI size.
5942// dstRoi Destination image ROI size.
5943// rate Neighbour levels ratio (1<rate<=10)
5944// pKernel Separable symmetric kernel of odd length
5945// kerSize Kernel size
5946// mode IPPI_INTER_LINEAR - bilinear interpolation
5947// StateBuf Pointer to the buffer to initialize state structure for pyramids.
5948// pBuffer Pointer to the work buffer.
5949//
5950// Return:
5951// ippStsNoErr Ok
5952// ippStsNullPtrErr One of pointers is NULL
5953// ippStsSizeErr The width or height of images is less or equal zero
5954// ippStsBadArgErr Bad mode, rate or kernel size
5955*/
5956
5957
5958IPPAPI(IppStatus, ippiPyramidLayerDownInit_8u_C1R, (IppiPyramidDownState_8u_C1R** ppState, IppiSize srcRoi,
5959 Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode, Ipp8u* StateBuf, Ipp8u* Buffer))
5960IPPAPI(IppStatus, ippiPyramidLayerDownInit_16u_C1R,(IppiPyramidDownState_16u_C1R** ppState, IppiSize srcRoi,
5961 Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode, Ipp8u* StateBuf, Ipp8u* Buffer))
5962IPPAPI(IppStatus, ippiPyramidLayerDownInit_32f_C1R,(IppiPyramidDownState_32f_C1R** pState, IppiSize srcRoi,
5963 Ipp32f rate, Ipp32f* pKernel, int kerSize, int mode, Ipp8u* StateBuf, Ipp8u* Buffer))
5964IPPAPI(IppStatus, ippiPyramidLayerDownInit_8u_C3R, (IppiPyramidDownState_8u_C3R** ppState, IppiSize srcRoi,
5965 Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode, Ipp8u* StateBuf, Ipp8u* Buffer))
5966IPPAPI(IppStatus, ippiPyramidLayerDownInit_16u_C3R,(IppiPyramidDownState_16u_C3R** ppState, IppiSize srcRoi,
5967 Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode, Ipp8u* StateBuf, Ipp8u* Buffer))
5968IPPAPI(IppStatus, ippiPyramidLayerDownInit_32f_C3R,(IppiPyramidDownState_32f_C3R** ppState, IppiSize srcRoi,
5969 Ipp32f rate, Ipp32f* pKernel, int kerSize, int mode, Ipp8u* StateBuf, Ipp8u* Buffer))
5970
5971
5972IPPAPI(IppStatus, ippiPyramidLayerUpInit_8u_C1R, (IppiPyramidUpState_8u_C1R** ppState, IppiSize dstRoi,
5973 Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode, Ipp8u* StateBuf))
5974IPPAPI(IppStatus, ippiPyramidLayerUpInit_16u_C1R,(IppiPyramidUpState_16u_C1R** ppState, IppiSize dstRoi,
5975 Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode, Ipp8u* StateBuf))
5976IPPAPI(IppStatus, ippiPyramidLayerUpInit_32f_C1R,(IppiPyramidUpState_32f_C1R** ppState, IppiSize dstRoi,
5977 Ipp32f rate, Ipp32f* pKernel, int kerSize, int mode, Ipp8u* StateBuf))
5978IPPAPI(IppStatus, ippiPyramidLayerUpInit_8u_C3R, (IppiPyramidUpState_8u_C3R** ppState, IppiSize dstRoi,
5979 Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode, Ipp8u* StateBuf))
5980IPPAPI(IppStatus, ippiPyramidLayerUpInit_16u_C3R,(IppiPyramidUpState_16u_C3R** ppState, IppiSize dstRoi,
5981 Ipp32f rate, Ipp16s* pKernel, int kerSize, int mode, Ipp8u* StateBuf))
5982IPPAPI(IppStatus, ippiPyramidLayerUpInit_32f_C3R,(IppiPyramidUpState_32f_C3R** ppState, IppiSize dstRoi,
5983 Ipp32f rate, Ipp32f* pKernel, int kerSize, int mode, Ipp8u* StateBuf))
5984
5985
5986/* ///////////////////////////////////////////////////////////////////////////////////////
5987// Name: ippiGetPyramidDownROI, ippiGetPyramidUpROI
5988//
5989// Purpose: Calculate possible size of destination ROI.
5990//
5991// Return:
5992// ippStsNoErr Ok
5993// ippStsNullPtrErr One of pointers is NULL
5994// ippStsSizeErr Wrong src roi
5995// ippStsBadArgErr Wrong rate
5996//
5997// Arguments:
5998// srcRoi Source image ROI size.
5999// pDstRoi Pointer to destination image ROI size (down).
6000// pDstRoiMin Pointer to minimal destination image ROI size (up).
6001// pDstRoiMax Pointer to maximal destination image ROI size (up).
6002// rate Neighbour levels ratio (1<rate<=10)
6003//
6004// Notes: For up case destination size belongs to interval
6005// max((int)((float)((src-1)*rate)),src+1)<=dst<=
6006// max((int)((float)(src)*rate)),src+1)
6007*/
6008
6009IPPAPI(IppStatus, ippiGetPyramidDownROI,(IppiSize srcRoi, IppiSize *pDstRoi, Ipp32f rate))
6010IPPAPI(IppStatus, ippiGetPyramidUpROI,(IppiSize srcRoi, IppiSize *pDstRoiMin, IppiSize *pDstRoiMax, Ipp32f rate))
6011
6012
6013/* ///////////////////////////////////////////////////////////////////////////////////////
6014// Name: ippiPyramidLayerDown_8u_C1R, ippiPyramidLayerDown_16u_C1R, ippiPyramidLayerDown_32f_C1R
6015// ippiPyramidLayerDown_8u_C3R, ippiPyramidLayerDown_16u_C3R, ippiPyramidLayerDown_32f_C3R
6016// ippiPyramidLayerUp_8u_C1R, ippiPyramidLayerUp_16u_C1R, ippiPyramidLayerUp_32f_C1R
6017// ippiPyramidLayerUp_8u_C3R, ippiPyramidLayerUp_16u_C3R, ippiPyramidLayerUp_32f_C3R
6018//
6019// Purpose: Perform downsampling/upsampling of the image with 5x5 gaussian.
6020//
6021// Return:
6022// ippStsNoErr Ok
6023// ippStsNullPtrErr One of the specified pointers is NULL
6024// ippStsSizeErr The srcRoiSize or dstRoiSize has a fild with zero or negativ value
6025// ippStsStepErr The steps in images are too small
6026// ippStsBadArgErr pState->rate has wrong value
6027// ippStsNotEvenStepErr One of the step values is not divisibly by 4 for floating-point
6028// images, or by 2 for short-integer images.
6029// Arguments:
6030// pSrc Pointer to the source image
6031// srcStep Step in byte through the source image
6032// srcRoiSize Size of the source image ROI in pixel.
6033// dstRoiSize Size of the destination image ROI in pixel.
6034// pDst Pointer to destination image
6035// dstStep Step in byte through the destination image
6036// pState Pointer to the pyramid layer structure
6037*/
6038
6039IPPAPI(IppStatus, ippiPyramidLayerDown_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize srcRoiSize,
6040 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_8u_C1R* pState))
6041IPPAPI(IppStatus, ippiPyramidLayerDown_8u_C3R, (const Ipp8u* pSrc, int srcStep, IppiSize srcRoiSize,
6042 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_8u_C3R* pState))
6043IPPAPI(IppStatus, ippiPyramidLayerDown_16u_C1R,(const Ipp16u* pSrc, int srcStep, IppiSize srcRoiSize,
6044 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_16u_C1R* pState))
6045IPPAPI(IppStatus, ippiPyramidLayerDown_16u_C3R,(const Ipp16u* pSrc, int srcStep, IppiSize srcRoiSize,
6046 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_16u_C3R* pState))
6047IPPAPI(IppStatus, ippiPyramidLayerDown_32f_C1R,(const Ipp32f* pSrc, int srcStep, IppiSize srcRoiSize,
6048 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_32f_C1R* pState))
6049IPPAPI(IppStatus, ippiPyramidLayerDown_32f_C3R,(const Ipp32f* pSrc, int srcStep, IppiSize srcRoiSize,
6050 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidDownState_32f_C3R* pState))
6051
6052IPPAPI(IppStatus, ippiPyramidLayerUp_8u_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize srcRoiSize,
6053 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_8u_C1R* pState))
6054IPPAPI(IppStatus, ippiPyramidLayerUp_8u_C3R, (const Ipp8u* pSrc, int srcStep, IppiSize srcRoiSize,
6055 Ipp8u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_8u_C3R* pState))
6056IPPAPI(IppStatus, ippiPyramidLayerUp_16u_C1R,(const Ipp16u* pSrc, int srcStep, IppiSize srcRoiSize,
6057 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_16u_C1R* pState))
6058IPPAPI(IppStatus, ippiPyramidLayerUp_16u_C3R,(const Ipp16u* pSrc, int srcStep, IppiSize srcRoiSize,
6059 Ipp16u* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_16u_C3R* pState))
6060IPPAPI(IppStatus, ippiPyramidLayerUp_32f_C1R,(const Ipp32f* pSrc, int srcStep, IppiSize srcRoiSize,
6061 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_32f_C1R* pState))
6062IPPAPI(IppStatus, ippiPyramidLayerUp_32f_C3R,(const Ipp32f* pSrc, int srcStep, IppiSize srcRoiSize,
6063 Ipp32f* pDst, int dstStep, IppiSize dstRoiSize, IppiPyramidUpState_32f_C3R* pState))
6064
6065
6066/****************************************************************************************\
6067* Haar Classifier *
6068\****************************************************************************************/
6069
6070
6071/* ///////////////////////////////////////////////////////////////////////////////////////
6072// Name: ippiHaarClassifierInit ippiTiltedHaarClassifierInit
6073//
6074// Purpose: Initializes memory for the stage of the Haar classifier.
6075//
6076// Arguments:
6077// pState The pointer to the pointer to the Haar classifier structure.
6078// pFeature The pointer to the array of features.
6079// pWeight The pointer to the array of feature weights.
6080// pThreshold The pointer to the array of classifier thresholds [length].
6081// pVal1, pVal2 Pointers to arrays of classifier results [length].
6082// pNum The pointer to the array of classifier lengths [length].
6083// length The number of classifiers in the stage.
6084//
6085// Return:
6086// ippStsNoErr Ok
6087// ippStsNullPtrErr One of pointers is NULL
6088// ippStsSizeErr The number of classifiers or features is less or equal zero
6089// ippStsbadArgErr The bad feature rectangular
6090// ippStsMemAllocErr Memory allocation error
6091//
6092// Notes: For integer version feature weights pWeight are in Q0, classifier thresholds
6093// pThreshold are in QT (see ApplyHaarClassifier), pVal1 and pVal2 are scale as
6094// stage thresholds threshold of ApplyHaarClassifier function
6095*/
6096IPPAPI(IppStatus, ippiHaarClassifierInit_32f, (IppiHaarClassifier_32f *pState, const IppiRect* pFeature, const Ipp32f* pWeight,
6097 const Ipp32f* pThreshold, const Ipp32f* pVal1, const Ipp32f* pVal2, const int* pNum, int length))
6098IPPAPI(IppStatus, ippiTiltedHaarClassifierInit_32f, (IppiHaarClassifier_32f *pState, const IppiRect* pFeature, const Ipp32f* pWeight,
6099 const Ipp32f* pThreshold, const Ipp32f* pVal1, const Ipp32f* pVal2, const int* pNum, int length))
6100
6101
6102IPPAPI(IppStatus, ippiHaarClassifierGetSize, ( IppDataType dataType, IppiSize roiSize, const int* pNum, int length, int *pSize ))
6103
6104
6105
6106/* ///////////////////////////////////////////////////////////////////////////////////////
6107// Name: ippiTiltHaarFeatures_32f, ippiTiltHaarFeatures_32s
6108// Purpose: Tilts marked feature on -45 degree
6109// Arguments:
6110// pMask The mask of feature to tilt.
6111// flag 1 - left bottom -45 degree
6112// 0 - left top +45 degree
6113// pState The pointer to the Haar classifier structure.
6114// Return:
6115// ippStsNoErr Ok
6116// ippStsNullPtrErr One of pointers is NULL
6117// Notes: The mask length is equal to the number of classifiers in the classifier
6118// If pMask[i] != 0 i-th feature is tilted
6119// Classifiers with tilted features require two input integral images and
6120// can be used by rippiApplyMixedHaarClassifier functions
6121*/
6122IPPAPI(IppStatus, ippiTiltHaarFeatures_32f, (const Ipp8u *pMask, int flag, IppiHaarClassifier_32f *pState))
6123
6124
6125/* ///////////////////////////////////////////////////////////////////////////////////////
6126// Name: ippiGetHaarClassifierSize_32f, ippiGetHaarClassifierSize_32s
6127// Purpose: Returns the size of the Haar classifier.
6128// Arguments:
6129// pState Pointer to the Haar classifier structure.
6130// pSize Pointer to the returned value of Haar classifier size.
6131// Return:
6132// ippStsNoErr Ok
6133// ippStsNullPtrErr One of pointers is NULL
6134*/
6135IPPAPI(IppStatus, ippiGetHaarClassifierSize_32f, (IppiHaarClassifier_32f* pState, IppiSize* pSize))
6136
6137
6138/* ///////////////////////////////////////////////////////////////////////////////////////
6139// Name: ippiApplyHaarClassifier, ippiApplyMixedHaarClassifier
6140// Purpose: Applies the stage of Haar classifiers to the image.
6141// Arguments:
6142// pSrc The pointer to the source image of integrals.
6143// srcStep The step in bytes through the source image.
6144// pNorm The pointer to the source image of norm factors.
6145// normStep The step in bytes through the image of norm factors.
6146// pMask The pointer to the source and destination image of classification decisions.
6147// maskStep The step in bytes through the image of classification decisions.
6148// pPositive The pointer to the number of positive decisions.
6149// roiSize The size of source and destination images ROI in pixels.
6150// threshold The stage threshold value.
6151// pState The pointer to the Haar classifier structure.
6152// scaleFactor Scale factor for classifier threshold*norm, <= 0
6153// Return:
6154// ippStsNoErr Ok
6155// ippStsNullPtrErr One of pointers is NULL
6156// ippStsSizeErr The number of classifiers or features is less or equal zero
6157// ippStsSizeErr The width or height of images is less or equal zero
6158// ippStsStepErr The steps in images are too small
6159// ippStsNotEvenStepErr Step is not multiple of element.
6160*/
6161IPPAPI(IppStatus, ippiApplyHaarClassifier_32f_C1R, (const Ipp32f* pSrc, int srcStep,
6162 const Ipp32f* pNorm, int normStep, Ipp8u* pMask, int maskStep, IppiSize roiSize, int *pPositive, Ipp32f threshold, IppiHaarClassifier_32f *pState))
6163
6164IPPAPI(IppStatus, ippiApplyMixedHaarClassifier_32f_C1R, (const Ipp32f* pSrc, int srcStep, const Ipp32f* pTilt, int tiltStep,
6165 const Ipp32f* pNorm, int normStep, Ipp8u* pMask, int maskStep, IppiSize roiSize, int *pPositive, Ipp32f threshold, IppiHaarClassifier_32f *pState))
6166
6167
6168/*F///////////////////////////////////////////////////////////////////////////////////////
6169// Name: ippiMinEigenValGetBufferSize_8u32f_C1R, ippiMinEigenValGetBufferSize_32f_C1R
6170//
6171// Purpose: Calculates size of temporary buffer, required to run one of MinEigenVal***
6172// functions.
6173//
6174// Return:
6175// ippStsNoErr Ok
6176// ippStsNullPtrErr One of pointers is NULL
6177// ippStsSizeErr The width is less or equal zero or bad window size
6178//
6179// Parameters:
6180// roiSize roiSize size in pixels
6181// apertureSize Linear size of derivative filter aperture
6182// avgWindow Linear size of averaging window
6183// bufferSize Output parameter. Calculated buffer size.
6184//F*/
6185
6186IPPAPI(IppStatus, ippiMinEigenValGetBufferSize_8u32f_C1R, ( IppiSize roiSize, int apertureSize,
6187 int avgWindow, int* bufferSize ))
6188
6189IPPAPI(IppStatus, ippiMinEigenValGetBufferSize_32f_C1R, ( IppiSize roiSize, int apertureSize,
6190 int avgWindow, int* bufferSize ))
6191
6192
6193/*F///////////////////////////////////////////////////////////////////////////////////////
6194// Name: ippiMinEigenVal_8u32f_C1R, ippiMinEigenVal_32f_C1R
6195//
6196// Purpose: Calculate minimal eigen value of 2x2 autocorrelation gradient matrix
6197// for every pixel. Pixels with relatively large minimal eigen values
6198// are strong corners on the picture.
6199//
6200// Return:
6201// ippStsNoErr Ok
6202// ippStsNullPtrErr One of pointers is NULL
6203// ippStsSizeErr The width or height of images is less or equal zero
6204// or bad window size
6205// ippStsStepErr The steps in images are too small
6206// ippStsNotEvenStepErr Step is not multiple of element.
6207//
6208// Parameters:
6209// pSrc Source image
6210// srcStep Its step
6211// pMinEigenVal Image, filled with minimal eigen values for every pixel
6212// minValStep Its step
6213// roiSize ROI size
6214// kernType Kernel type (Scharr 3x3 or Sobel 3x3, 5x5)
6215// apertureSize Linear size of derivative filter aperture
6216// avgWindow Linear size of averaging window
6217// pBuffer Preallocated temporary buffer, which size can be calculated
6218// using ippiMinEigenValGetSize function
6219//F*/
6220
6221IPPAPI(IppStatus, ippiMinEigenVal_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep,
6222 Ipp32f* pMinEigenVal, int minValStep,
6223 IppiSize roiSize, IppiKernelType kernType,
6224 int apertureSize, int avgWindow, Ipp8u* pBuffer ))
6225
6226IPPAPI(IppStatus, ippiMinEigenVal_32f_C1R, ( const Ipp32f* pSrc, int srcStep,
6227 Ipp32f* pMinEigenVal, int minValStep,
6228 IppiSize roiSize, IppiKernelType kernType,
6229 int apertureSize, int avgWindow, Ipp8u* pBuffer ))
6230
6231
6232/*F///////////////////////////////////////////////////////////////////////////////////////
6233// Name: ippiMinMaxIndx_8u_C1R, ippiMinMaxIndx_8s_C1R,
6234// ippiMinMaxIndx_16u_C1R, ippiMinMaxIndx_32f_C1R,
6235// ippiMinMaxIndx_8u_C3CR, ippiMinMaxIndx_8s_C3CR,
6236// ippiMinMaxIndx_16u_C3CR, ippiMinMaxIndx_32f_C3CR,
6237//
6238// Purpose: Finds minimum and maximum values in the image and their coordinates
6239//
6240// Return:
6241// ippStsNoErr Ok
6242// ippStsNullPtrErr One of pointers is NULL
6243// ippStsSizeErr The width or height of images is less or equal zero
6244// ippStsStepErr The steps in images are too small
6245// ippStsNotEvenStepErr Step is not multiple of element.
6246//
6247// Parameters:
6248// pSrc Pointer to image
6249// srcStep Image step
6250// roiSize Size of image ROI
6251// coi Index of color channel (1..3) (if color image)
6252// pMinVal Pointer to minimum value
6253// pMaxVal Pointer to maximum value
6254// pMinIndex Minimum's coordinates
6255// pMaxIndex Maximum's coordinates
6256//
6257// Notes:
6258// Any of output parameters is optional
6259//F*/
6260
6261IPPAPI(IppStatus, ippiMinMaxIndx_16u_C1R,( const Ipp16u* pSrc, int srcStep, IppiSize roiSize,
6262 Ipp32f* pMinVal, Ipp32f* pMaxVal,
6263 IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
6264
6265IPPAPI(IppStatus, ippiMinMaxIndx_32f_C1R,( const Ipp32f* pSrc, int step, IppiSize roiSize,
6266 Ipp32f* pMinVal, Ipp32f* pMaxVal,
6267 IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
6268
6269
6270IPPAPI(IppStatus, ippiMinMaxIndx_8u_C1R,( const Ipp8u* pSrc, int srcStep, IppiSize roiSize,
6271 Ipp32f* pMinVal, Ipp32f* pMaxVal,
6272 IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
6273
6274
6275/****************************************************************************************\
6276* Image Integrals *
6277\****************************************************************************************/
6278
6279
6280/* /////////////////////////////////////////////////////////////////////////////////////
6281// Name: ippiIntegral, ippiTiltedIntegral
6282// ippiSqrIntegral, ippiTiltedSqrIntegral
6283//
6284// Purpose: calculates pixel sum on subimage
6285//
6286// Returns:
6287// ippStsNoErr Ok
6288// ippStsNullPtrErr One of pointers is NULL
6289// ippStsSizeErr The width or height of images is less or equal zero
6290// ippStsStepErr The steps in images are too small
6291// ippStsNotEvenStepErr Step is not multiple of element.
6292//
6293// Parameters:
6294// pSrc The pointer to source image
6295// srcStep The step in source image
6296// pDst The pointer to destination integral image
6297// dstStep The step in destination image
6298// pSq The pointer to destination square integral image
6299// sqStep The step in destination image
6300// roiSize The source and destination image ROI size.
6301// val The value to add to pDst image pixels.
6302// valSqr The value to add to pSq image pixels.
6303*/
6304IPPAPI(IppStatus, ippiIntegral_8u32s_C1R,(const Ipp8u* pSrc, int srcStep, Ipp32s* pDst, int dstStep, IppiSize srcRoiSize, Ipp32s val))
6305IPPAPI(IppStatus, ippiIntegral_8u32f_C1R,(const Ipp8u* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize srcRoiSize, Ipp32f val))
6306IPPAPI(IppStatus, ippiIntegral_32f_C1R, (const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize srcRoiSize))
6307
6308IPPAPI(IppStatus, ippiTiltedIntegral_8u32s_C1R,(const Ipp8u* pSrc, int srcStep, Ipp32s* pDst, int dstStep, IppiSize roiSize, Ipp32s val))
6309IPPAPI(IppStatus, ippiTiltedIntegral_8u32f_C1R,(const Ipp8u* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f val))
6310
6311IPPAPI(IppStatus, ippiSqrIntegral_8u32s_C1R, (const Ipp8u* pSrc, int srcStep, Ipp32s* pDst, int dstStep, Ipp32s* pSqr, int sqrStep, IppiSize roi, Ipp32s val, Ipp32s valSqr))
6312IPPAPI(IppStatus, ippiSqrIntegral_8u32s64f_C1R,(const Ipp8u* pSrc, int srcStep, Ipp32s* pDst, int dstStep, Ipp64f* pSqr, int sqrStep, IppiSize roiSize, Ipp32s val, Ipp64f valSqr))
6313IPPAPI(IppStatus, ippiSqrIntegral_8u32f64f_C1R,(const Ipp8u* pSrc, int srcStep, Ipp32f* pDst, int dstStep, Ipp64f* pSqr, int sqrStep, IppiSize roiSize, Ipp32f val, Ipp64f valSqr))
6314
6315IPPAPI(IppStatus, ippiTiltedSqrIntegral_8u32s_C1R, (const Ipp8u* pSrc, int srcStep, Ipp32s* pDst, int dstStep, Ipp32s* pSqr, int sqrStep, IppiSize roi, Ipp32s val, Ipp32s valSqr))
6316IPPAPI(IppStatus, ippiTiltedSqrIntegral_8u32s64f_C1R,(const Ipp8u* pSrc, int srcStep, Ipp32s* pDst, int dstStep, Ipp64f* pSqr, int sqrStep, IppiSize roiSize, Ipp32s val, Ipp64f valSqr))
6317IPPAPI(IppStatus, ippiTiltedSqrIntegral_8u32f64f_C1R,(const Ipp8u* pSrc, int srcStep, Ipp32f* pDst, int dstStep, Ipp64f* pSqr, int sqrStep, IppiSize roiSize, Ipp32f val, Ipp64f valSqr))
6318
6319
6320
6321/* /////////////////////////////////////////////////////////////////////////////
6322//
6323// Name: ippiHarrisCorner
6324// Purpose: Performs Harris corner detector operations
6325//
6326// Parameters:
6327// pSrc Pointer to the source image
6328// srcStep Step through the source image
6329// pDst Pointer to the destination image
6330// dstStep Step through the destination image in pixels.
6331// roiSize Size of the source and destination image ROI.
6332// filterType Type of derivative operator
6333// filterMask Predefined mask of IppiMaskSize type.
6334// avgWndSize Size of a rectangle Window for computing an average value
6335// k Harris Corner free coefficient
6336// scale Destination image scale factor
6337// border Type of the border
6338// borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
6339// pBuffer Pointer to the work buffer
6340//
6341// Return Values:
6342// ippStsNoErr Indicates no error.
6343// ippStsNullPtrErr Indicates an error condition if pSrc, pDst or pBufferSize is NULL.
6344// ippStsSizeErr Indicates an error in the two cases:
6345// if roiSize is negative, or equal to zero;
6346// if avgWndSize is equal to zero.
6347// ippStsNotEvenStepErr Indicated an error when dstStep is not divisible by 4.
6348// ippStsFilterTypeErr Indicates an error when filterType has illegal value.
6349// ippStsMaskSizeErr Indicates an error condition if mask has an illegal value.
6350// ippStsBorderErr Indicates an error when borderType has illegal value.
6351// ippStsNanArg Indicates an error when one of k or scale is not a number
6352// ippStsSizeWrn Indicates a warning when avgWndSize is more
6353// than either image width or image height.
6354*/
6355
6356IPPAPI(IppStatus, ippiHarrisCorner_8u32f_C1R, (
6357 const Ipp8u *pSrc, int srcStep, Ipp32f *pDst, int dstStep, IppiSize roiSize,
6358 IppiDifferentialKernel filterType, IppiMaskSize filterMask, Ipp32u avgWndSize, float k,
6359 float scale, IppiBorderType borderType, Ipp8u borderValue, Ipp8u* pBuffer))
6360
6361IPPAPI(IppStatus, ippiHarrisCorner_32f_C1R, (
6362 const Ipp32f *pSrc, int srcStep, Ipp32f *pDst, int dstStep, IppiSize roiSize,
6363 IppiDifferentialKernel filterType, IppiMaskSize filterMask, Ipp32u avgWndSize, float k,
6364 float scale, IppiBorderType borderType, Ipp32f borderValue, Ipp8u* pBuffer))
6365
6366
6367/* /////////////////////////////////////////////////////////////////////////////
6368// Name: ippiHarrisCornerGetBufferSize
6369//
6370// Purpose: Computes the size of the external buffer for ippiHarrisCorner function
6371//
6372// Parameters:
6373// roiSize Size of the source and destination ROI in pixels.
6374// filterMask Linear size of derivative filter aperture.
6375// avgWndSize Neighborhood block size for smoothing
6376// dataType Data type of the source image.
6377// numChannels Number of channels in the images. Possible values is 1.
6378// pBufferSize Pointer to the size (in bytes) of the external work buffer.
6379//
6380// Return Values:
6381// ippStsNoErr Indicates no error.
6382// ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
6383// ippStsSizeErr Indicates an error in the two cases:
6384// if roiSize is negative, or equal to zero;
6385// if avgWndSize is equal to zero.
6386// ippStsFilterTypeErr Indicates an error when filterType has illegal value.
6387// ippStsMaskSizeErr Indicates an error condition if mask has a wrong value.
6388// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
6389// ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
6390// ippStsSizeWrn Indicates a warning when avgWndSize is more
6391// than either image width or image height.
6392*/
6393IPPAPI(IppStatus, ippiHarrisCornerGetBufferSize, (IppiSize roiSize, IppiMaskSize filterMask,
6394 Ipp32u avgWndSize, IppDataType dataType, int numChannels, int* pBufferSize))
6395
6396
6397/*F/////////////////////////////////////////////////////////////////////////////////////
6398// Name: ippiRectStdDev_32s32f_C1R, ippiRectStdDev_32f_C1R
6399// ippiTiltedRectStdDev_32s32f_C1R, ippiTiltedRectStdDev_32f_C1R
6400// ippiRectStdDev_32s_C1RSfs, ippiTiltedRectStdDev_32s_C1RSfs
6401//
6402// Purpose: Calculates standard deviation on rectangular window
6403//
6404// Returns:
6405// ippStsNoErr Ok
6406// ippStsNullPtrErr One of pointers is NULL
6407// ippStsSizeErr The width or height of images is less or equal zero
6408// ippStsStepErr The steps in images are too small
6409// ippStsNotEvenStepErr Step is not multiple of element.
6410//
6411// Parameters:
6412// pSrc The pointer to source image of integrals
6413// srcStep The step in source image
6414// pSqr The pointer to destination square integral image
6415// sqrStep The step in destination image
6416// pDst The pointer to destination image
6417// dstStep The step in destination image
6418// roiSize The destination image ROI size.
6419// rect The rectangular window for standard deviation calculation.
6420// scaleFactor Output scale factor
6421//
6422// Notes:
6423//F*/
6424
6425IPPAPI(IppStatus, ippiRectStdDev_32f_C1R, (const Ipp32f* pSrc, int srcStep,
6426 const Ipp64f* pSqr, int sqrStep, Ipp32f* pDst, int dstStep,
6427 IppiSize roiSize, IppiRect rect))
6428
6429
6430/*F///////////////////////////////////////////////////////////////////////////////////////
6431// Name: ippiAbsDiff_8u_C1R, ippiAbsDiff_8u_C3R, ippiAbsDiff_16u_C1R, ippiAbsDiff_32f_C1R,
6432//
6433// Purpose: Calculate absolute difference between corresponding pixels of the two images
6434// or between image pixels and scalar.
6435//
6436// Return:
6437// ippStsNoErr Ok
6438// ippStsNullPtrErr One of pointers is NULL
6439// ippStsSizeErr The width or height of images is less or equal zero
6440// ippStsStepErr The steps in images are too small
6441// ippStsNotEvenStepErr Step is not multiple of element.
6442//
6443// Parameters:
6444// pSrc1 Source image
6445// src1Step Its step
6446// pSrc2 Second source image
6447// src2Step Its step
6448// pDst Destination image
6449// dstStep Its step
6450// roiSize ROI size
6451//F*/
6452
6453IPPAPI(IppStatus, ippiAbsDiff_8u_C1R, ( const Ipp8u* pSrc1, int src1Step,
6454 const Ipp8u* pSrc2, int src2Step,
6455 Ipp8u* pDst, int dstStep, IppiSize roiSize ))
6456
6457IPPAPI(IppStatus, ippiAbsDiff_16u_C1R, ( const Ipp16u* pSrc1, int src1Step,
6458 const Ipp16u* pSrc2, int src2Step,
6459 Ipp16u* pDst, int dstStep, IppiSize roiSize ))
6460
6461IPPAPI(IppStatus, ippiAbsDiff_32f_C1R, ( const Ipp32f* pSrc1, int src1Step,
6462 const Ipp32f* pSrc2, int src2Step,
6463 Ipp32f* pDst, int dstStep, IppiSize roiSize ))
6464
6465
6466/*F///////////////////////////////////////////////////////////////////////////////////////
6467// Name: ippiMean_8u_C1MR, ippiMean_8s_C1MR, ippiMean_16u_C1MR, ippiMean_32f_C1MR,
6468// ippiMean_8u_C3CMR, ippiMean_8s_C3CMR, ippiMean_16u_C3CMR, ippiMean_32f_C3CMR
6469//
6470// Purpose: Find mean value for selected region
6471//
6472// Return:
6473// ippStsNoErr Ok
6474// ippStsNullPtrErr One of pointers is NULL
6475// ippStsSizeErr The width or height of images is less or equal zero
6476// ippStsStepErr The steps in images are too small
6477// ippStsNotEvenStepErr Step is not multiple of element.
6478// ippStsCOIErr COI index is illegal (coi<1 || coi>3)
6479//
6480// Parameters:
6481// pSrc Pointer to image
6482// srcStep Image step
6483// pMask Pointer to mask image
6484// maskStep Step in the mask image
6485// roiSize Size of image ROI
6486// coi Index of color channel (1..3) (if color image)
6487// pMean Returned mean value
6488//
6489// Notes:
6490//F*/
6491
6492IPPAPI( IppStatus, ippiMean_8u_C1MR, ( const Ipp8u* pSrc, int srcStep,
6493 const Ipp8u* pMask, int maskStep,
6494 IppiSize roiSize, Ipp64f* pMean ))
6495
6496IPPAPI( IppStatus, ippiMean_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
6497 const Ipp8u* pMask, int maskStep,
6498 IppiSize roiSize, int coi, Ipp64f* pMean ))
6499
6500
6501IPPAPI( IppStatus, ippiMean_16u_C1MR, ( const Ipp16u* pSrc, int srcStep,
6502 const Ipp8u* pMask, int maskStep,
6503 IppiSize roiSize, Ipp64f* pMean ))
6504
6505IPPAPI( IppStatus, ippiMean_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
6506 const Ipp8u* pMask, int maskStep,
6507 IppiSize roiSize, int coi, Ipp64f* pMean ))
6508
6509
6510IPPAPI( IppStatus, ippiMean_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
6511 const Ipp8u* pMask, int maskStep,
6512 IppiSize roiSize, Ipp64f* pMean ))
6513
6514IPPAPI( IppStatus, ippiMean_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
6515 const Ipp8u* pMask, int maskStep,
6516 IppiSize roiSize, int coi, Ipp64f* pMean ))
6517
6518
6519
6520/*F///////////////////////////////////////////////////////////////////////////////////////
6521// Name: ippiMean_StdDev_8u_C1MR, ippiMean_StdDev_8s_C1MR,
6522// ippiMean_StdDev_16u_C1MR, ippiMean_StdDev_32f_C1MR,
6523// ippiMean_StdDev_8u_C3CMR, ippiMean_StdDev_8s_C3CMR,
6524// ippiMean_StdDev_16u_C3CMR, ippiMean_StdDev_32f_C3CMR
6525//
6526// Purpose: Find mean and standard deviation values for selected region
6527//
6528// Return:
6529// ippStsNoErr Ok
6530// ippStsNullPtrErr One of pointers is NULL
6531// ippStsSizeErr The width or height of images is less or equal zero
6532// ippStsStepErr The steps in images are too small
6533// ippStsNotEvenStepErr Step is not multiple of element.
6534//
6535// Parameters:
6536// pSrc Pointer to image
6537// srcStep Image step
6538// pMask Pointer to mask image
6539// maskStep Step in the mask image
6540// roiSize Size of image ROI
6541// coi Index of color channel (1..3) (if color image)
6542// pMean Returned mean value
6543// pStdDev Returned standard deviation
6544//
6545// Notes:
6546//F*/
6547
6548IPPAPI( IppStatus, ippiMean_StdDev_8u_C1MR, ( const Ipp8u* pSrc, int srcStep,
6549 const Ipp8u* pMask, int maskStep,
6550 IppiSize roiSize,
6551 Ipp64f* pMean, Ipp64f* pStdDev ))
6552
6553IPPAPI( IppStatus, ippiMean_StdDev_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
6554 const Ipp8u* pMask, int maskStep,
6555 IppiSize roiSize, int coi,
6556 Ipp64f* pMean, Ipp64f* pStdDev ))
6557
6558IPPAPI( IppStatus, ippiMean_StdDev_16u_C1MR, ( const Ipp16u* pSrc, int srcStep,
6559 const Ipp8u* pMask, int maskStep,
6560 IppiSize roiSize,
6561 Ipp64f* pMean, Ipp64f* pStdDev ))
6562
6563IPPAPI( IppStatus, ippiMean_StdDev_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
6564 const Ipp8u* pMask, int maskStep,
6565 IppiSize roiSize, int coi,
6566 Ipp64f* pMean, Ipp64f* pStdDev ))
6567
6568IPPAPI( IppStatus, ippiMean_StdDev_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
6569 const Ipp8u* pMask, int maskStep,
6570 IppiSize roiSize,
6571 Ipp64f* pMean, Ipp64f* pStdDev ))
6572
6573IPPAPI( IppStatus, ippiMean_StdDev_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
6574 const Ipp8u* pMask, int maskStep,
6575 IppiSize roiSize, int coi,
6576 Ipp64f* pMean, Ipp64f* pStdDev ))
6577
6578
6579
6580/*F///////////////////////////////////////////////////////////////////////////////////////
6581// Name: ippiMean_StdDev_8u_C1R, ippiMean_StdDev_8s_C1R,
6582// ippiMean_StdDev_16u_C1R, ippiMean_StdDev_32f_C1R,
6583// ippiMean_StdDev_8u_C3CR, ippiMean_StdDev_8s_C3CR,
6584// ippiMean_StdDev_16u_C3CR, ippiMean_StdDev_32f_C3CR
6585//
6586// Purpose: Find mean and standard deviation values for selected region
6587//
6588// Return:
6589// ippStsNoErr Ok
6590// ippStsNullPtrErr One of pointers is NULL
6591// ippStsSizeErr The width or height of images is less or equal zero
6592// ippStsStepErr The steps in images are too small
6593// ippStsNotEvenStepErr Step is not multiple of element.
6594// ippStsCOIErr COI index is illegal (coi<1 || coi>3)
6595//
6596// Parameters:
6597// pSrc Pointer to image
6598// srcStep Image step
6599// roiSize Size of image ROI
6600// coi Index of color channel (1..3) (if color image)
6601// pMean Returned mean value
6602// pStdDev Returned standard deviation
6603//
6604// Notes:
6605//F*/
6606
6607IPPAPI( IppStatus, ippiMean_StdDev_8u_C1R, ( const Ipp8u* pSrc, int srcStep,
6608 IppiSize roiSize,
6609 Ipp64f* pMean, Ipp64f* pStdDev ))
6610
6611IPPAPI( IppStatus, ippiMean_StdDev_8u_C3CR, ( const Ipp8u* pSrc, int srcStep,
6612 IppiSize roiSize, int coi,
6613 Ipp64f* pMean, Ipp64f* pStdDev ))
6614
6615
6616IPPAPI( IppStatus, ippiMean_StdDev_16u_C1R, ( const Ipp16u* pSrc, int srcStep,
6617 IppiSize roiSize,
6618 Ipp64f* pMean, Ipp64f* pStdDev ))
6619
6620IPPAPI( IppStatus, ippiMean_StdDev_16u_C3CR, ( const Ipp16u* pSrc, int srcStep,
6621 IppiSize roiSize, int coi,
6622 Ipp64f* pMean, Ipp64f* pStdDev ))
6623
6624
6625IPPAPI( IppStatus, ippiMean_StdDev_32f_C1R, ( const Ipp32f* pSrc, int srcStep,
6626 IppiSize roiSize,
6627 Ipp64f* pMean, Ipp64f* pStdDev ))
6628
6629IPPAPI( IppStatus, ippiMean_StdDev_32f_C3CR, ( const Ipp32f* pSrc, int srcStep,
6630 IppiSize roiSize, int coi,
6631 Ipp64f* pMean, Ipp64f* pStdDev ))
6632
6633
6634
6635/*F///////////////////////////////////////////////////////////////////////////////////////
6636// Name: ippiMinMaxIndx_8u_C1MR, ippiMinMaxIndx_8s_C1MR,
6637// ippiMinMaxIndx_16u_C1MR, ippiMinMaxIndx_32f_C1MR,
6638// ippiMinMaxIndx_8u_C3CMR, ippiMinMaxIndx_8s_C3CMR,
6639// ippiMinMaxIndx_16u_C3CMR, ippiMinMaxIndx_32f_C3CMR,
6640//
6641// Purpose: Finds minimum and maximum values in the image and their coordinates
6642//
6643// Return:
6644// ippStsNoErr Ok
6645// ippStsNullPtrErr One of pointers is NULL
6646// ippStsSizeErr The width or height of images is less or equal zero
6647// ippStsStepErr The steps in images are too small
6648// ippStsNotEvenStepErr Step is not multiple of element.
6649//
6650// Parameters:
6651// pSrc Pointer to image
6652// srcStep Image step
6653// pMask Pointer to mask image
6654// maskStep Step in the mask image
6655// roiSize Size of image ROI
6656// coi Index of color channel (1..3) (if color image)
6657// pMinVal Pointer to minimum value
6658// pMaxVal Pointer to maximum value
6659// pMinIndex Minimum's coordinates
6660// pMaxIndex Maximum's coordinates
6661//
6662// Notes:
6663// Any of output parameters is optional
6664//F*/
6665
6666IPPAPI(IppStatus, ippiMinMaxIndx_8u_C1MR,( const Ipp8u* pSrc, int srcStep,
6667 const Ipp8u* pMask, int maskStep,
6668 IppiSize roiSize,
6669 Ipp32f* pMinVal, Ipp32f* pMaxVal,
6670 IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
6671
6672IPPAPI(IppStatus, ippiMinMaxIndx_16u_C1MR,( const Ipp16u* pSrc, int srcStep,
6673 const Ipp8u* pMask, int maskStep,
6674 IppiSize roiSize,
6675 Ipp32f* pMinVal, Ipp32f* pMaxVal,
6676 IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
6677
6678
6679IPPAPI( IppStatus, ippiMinMaxIndx_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
6680 const Ipp8u* pMask, int maskStep,
6681 IppiSize roiSize,
6682 Ipp32f* pMinVal, Ipp32f* pMaxVal,
6683 IppiPoint* pMinIndex, IppiPoint* pMaxIndex ))
6684
6685
6686/*F///////////////////////////////////////////////////////////////////////////////////////
6687// Names: ippiNorm_Inf_8u_C1MR, ippiNorm_Inf_8s_C1MR,
6688// ippiNorm_Inf_16u_C1MR, ippiNorm_Inf_32f_C1MR,
6689// ippiNorm_Inf_8u_C3CMR, ippiNorm_Inf_8s_C3CMR,
6690// ippiNorm_Inf_16u_C3CMR, ippiNorm_Inf_32f_C3CMR,
6691// ippiNormDiff_Inf_8u_C1MR, ippiNormDiff_Inf_8s_C1MR,
6692// ippiNormDiff_Inf_16u_C1MR, ippiNormDiff_Inf_32f_C1MR,
6693// ippiNormDiff_Inf_8u_C3CMR, ippiNormDiff_Inf_8s_C3CMR,
6694// ippiNormDiff_Inf_16u_C3CMR, ippiNormDiff_Inf_32f_C3CMR,
6695// ippiNormRel_Inf_8u_C1MR, ippiNormRel_Inf_8s_C1MR,
6696// ippiNormRel_Inf_16u_C1MR, ippiNormRel_Inf_32f_C1MR,
6697// ippiNormRel_Inf_8u_C3CMR, ippiNormRel_Inf_8s_C3CMR,
6698// ippiNormRel_Inf_16u_C3CMR, ippiNormRel_Inf_32f_C3CMR,
6699//
6700// ippiNorm_L1_8u_C1MR, ippiNorm_L1_8s_C1MR,
6701// ippiNorm_L1_16u_C1MR, ippiNorm_L1_32f_C1MR,
6702// ippiNorm_L1_8u_C3CMR, ippiNorm_L1_8s_C3CMR,
6703// ippiNorm_L1_16u_C3CMR, ippiNorm_L1_32f_C3CMR,
6704// ippiNormDiff_L1_8u_C1MR, ippiNormDiff_L1_8s_C1MR,
6705// ippiNormDiff_L1_16u_C1MR, ippiNormDiff_L1_32f_C1MR,
6706// ippiNormDiff_L1_8u_C3CMR, ippiNormDiff_L1_8s_C3CMR,
6707// ippiNormDiff_L1_16u_C3CMR, ippiNormDiff_L1_32f_C3CMR,
6708// ippiNormRel_L1_8u_C1MR, ippiNormRel_L1_8s_C1MR,
6709// ippiNormRel_L1_16u_C1MR, ippiNormRel_L1_32f_C1MR,
6710// ippiNormRel_L1_8u_C3CMR, ippiNormRel_L1_8s_C3CMR,
6711// ippiNormRel_L1_16u_C3CMR, ippiNormRel_L1_32f_C3CMR,
6712//
6713// ippiNorm_L2_8u_C1MR, ippiNorm_L2_8s_C1MR,
6714// ippiNorm_L2_16u_C1MR, ippiNorm_L2_32f_C1MR,
6715// ippiNorm_L2_8u_C3CMR, ippiNorm_L2_8s_C3CMR,
6716// ippiNorm_L2_16u_C3CMR, ippiNorm_L2_32f_C3CMR,
6717// ippiNormDiff_L2_8u_C1MR, ippiNormDiff_L2_8s_C1MR,
6718// ippiNormDiff_L2_16u_C1MR, ippiNormDiff_L2_32f_C1MR,
6719// ippiNormDiff_L2_8u_C3CMR, ippiNormDiff_L2_8s_C3CMR,
6720// ippiNormDiff_L2_16u_C3CMR, ippiNormDiff_L2_32f_C3CMR,
6721// ippiNormRel_L2_8u_C1MR, ippiNormRel_L2_8s_C1MR,
6722// ippiNormRel_L2_16u_C1MR, ippiNormRel_L2_32f_C1MR,
6723// ippiNormRel_L2_8u_C3CMR, ippiNormRel_L2_8s_C3CMR,
6724// ippiNormRel_L2_16u_C3CMR, ippiNormRel_L2_32f_C3CMR
6725//
6726// Purpose: Calculates ordinary, differential or relative norms of one or two images
6727// in an arbitrary image region.
6728//
6729// Returns:
6730// ippStsNoErr Ok
6731// ippStsNullPtrErr One of pointers is NULL
6732// ippStsSizeErr The width or height of images is less or equal zero
6733// ippStsStepErr The steps in images are too small
6734// ippStsNotEvenStepErr Step is not multiple of element.
6735//
6736// Parameters:
6737// pSrc, pSrc1 Pointers to source and mask images
6738// pSrc2, pMask
6739// srcStep, src1Step Their steps
6740// src2Step, maskStep
6741// roiSize Their size or ROI size
6742// coi COI index (1..3) (if 3-channel images)
6743// pNorm The pointer to calculated norm
6744//
6745// Notes:
6746//F*/
6747
6748/* ///////////////////////////////// 8uC1 flavor ////////////////////////////////////// */
6749
6750IPPAPI( IppStatus, ippiNorm_Inf_8u_C1MR, ( const Ipp8u* pSrc, int srcStep,
6751 const Ipp8u* pMask,int maskStep,
6752 IppiSize roiSize, Ipp64f* pNorm ) )
6753
6754IPPAPI( IppStatus, ippiNorm_Inf_16u_C1MR, ( const Ipp16u* pSrc, int srcStep,
6755 const Ipp8u* pMask,int maskStep,
6756 IppiSize roiSize, Ipp64f* pNorm ) )
6757
6758IPPAPI( IppStatus, ippiNorm_Inf_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
6759 const Ipp8u* pMask, int maskStep,
6760 IppiSize roiSize, Ipp64f* pNorm ) )
6761
6762
6763IPPAPI( IppStatus, ippiNorm_Inf_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
6764 const Ipp8u* pMask,int maskStep,
6765 IppiSize roiSize, int coi, Ipp64f* pNorm ) )
6766
6767IPPAPI( IppStatus, ippiNorm_Inf_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
6768 const Ipp8u* pMask,int maskStep,
6769 IppiSize roiSize, int coi, Ipp64f* pNorm ) )
6770
6771IPPAPI( IppStatus, ippiNorm_Inf_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
6772 const Ipp8u* pMask, int maskStep,
6773 IppiSize roiSize, int coi, Ipp64f* pNorm ) )
6774
6775
6776IPPAPI( IppStatus, ippiNormDiff_Inf_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
6777 const Ipp8u* pSrc2, int src2Step,
6778 const Ipp8u* pMask, int maskStep,
6779 IppiSize roiSize, Ipp64f* pNorm ) )
6780
6781IPPAPI( IppStatus, ippiNormDiff_Inf_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
6782 const Ipp16u* pSrc2, int src2Step,
6783 const Ipp8u* pMask, int maskStep,
6784 IppiSize roiSize, Ipp64f* pNorm ) )
6785
6786IPPAPI( IppStatus, ippiNormDiff_Inf_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
6787 const Ipp32f* pSrc2, int src2Step,
6788 const Ipp8u* pMask, int maskStep,
6789 IppiSize roiSize, Ipp64f* pNorm ) )
6790
6791
6792IPPAPI( IppStatus, ippiNormDiff_Inf_8u_C3CMR, (const Ipp8u* pSrc1, int src1Step,
6793 const Ipp8u* pSrc2, int src2Step,
6794 const Ipp8u* pMask, int maskStep,
6795 IppiSize roiSize, int coi, Ipp64f* pNorm ))
6796
6797IPPAPI( IppStatus, ippiNormDiff_Inf_16u_C3CMR, (const Ipp16u* pSrc1, int src1Step,
6798 const Ipp16u* pSrc2, int src2Step,
6799 const Ipp8u* pMask, int maskStep,
6800 IppiSize roiSize, int coi, Ipp64f* pNorm ))
6801
6802IPPAPI( IppStatus, ippiNormDiff_Inf_32f_C3CMR, (const Ipp32f* pSrc1, int src1Step,
6803 const Ipp32f* pSrc2, int src2Step,
6804 const Ipp8u* pMask, int maskStep,
6805 IppiSize roiSize, int coi, Ipp64f* pNorm ))
6806
6807
6808IPPAPI( IppStatus, ippiNormRel_Inf_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
6809 const Ipp8u* pSrc2, int src2Step,
6810 const Ipp8u* pMask, int maskStep,
6811 IppiSize roiSize, Ipp64f* pNorm ) )
6812
6813IPPAPI( IppStatus, ippiNormRel_Inf_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
6814 const Ipp16u* pSrc2, int src2Step,
6815 const Ipp8u* pMask, int maskStep,
6816 IppiSize roiSize, Ipp64f* pNorm ) )
6817
6818IPPAPI( IppStatus, ippiNormRel_Inf_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
6819 const Ipp32f* pSrc2, int src2Step,
6820 const Ipp8u* pMask, int maskStep,
6821 IppiSize roiSize, Ipp64f* pNorm ) )
6822
6823
6824IPPAPI( IppStatus, ippiNorm_L1_8u_C1MR, ( const Ipp8u* pSrc, int srcStep,
6825 const Ipp8u* pMask,int maskStep,
6826 IppiSize roiSize, Ipp64f* pNorm ) )
6827
6828IPPAPI( IppStatus, ippiNorm_L1_16u_C1MR, ( const Ipp16u* pSrc, int srcStep,
6829 const Ipp8u* pMask,int maskStep,
6830 IppiSize roiSize, Ipp64f* pNorm ) )
6831
6832IPPAPI( IppStatus, ippiNorm_L1_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
6833 const Ipp8u* pMask, int maskStep,
6834 IppiSize roiSize, Ipp64f* pNorm ) )
6835
6836
6837IPPAPI( IppStatus, ippiNorm_L1_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
6838 const Ipp8u* pMask,int maskStep,
6839 IppiSize roiSize, int coi, Ipp64f* pNorm ) )
6840
6841IPPAPI( IppStatus, ippiNorm_L1_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
6842 const Ipp8u* pMask,int maskStep,
6843 IppiSize roiSize, int coi, Ipp64f* pNorm ) )
6844
6845IPPAPI( IppStatus, ippiNorm_L1_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
6846 const Ipp8u* pMask, int maskStep,
6847 IppiSize roiSize, int coi, Ipp64f* pNorm ) )
6848
6849
6850IPPAPI( IppStatus, ippiNormDiff_L1_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
6851 const Ipp8u* pSrc2, int src2Step,
6852 const Ipp8u* pMask, int maskStep,
6853 IppiSize roiSize, Ipp64f* pNorm ) )
6854
6855IPPAPI( IppStatus, ippiNormDiff_L1_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
6856 const Ipp16u* pSrc2, int src2Step,
6857 const Ipp8u* pMask, int maskStep,
6858 IppiSize roiSize, Ipp64f* pNorm ) )
6859
6860IPPAPI( IppStatus, ippiNormDiff_L1_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
6861 const Ipp32f* pSrc2, int src2Step,
6862 const Ipp8u* pMask, int maskStep,
6863 IppiSize roiSize, Ipp64f* pNorm ) )
6864
6865
6866IPPAPI( IppStatus, ippiNormDiff_L1_8u_C3CMR, ( const Ipp8u* pSrc1, int src1Step,
6867 const Ipp8u* pSrc2, int src2Step,
6868 const Ipp8u* pMask, int maskStep,
6869 IppiSize roiSize, int coi, Ipp64f* pNorm ))
6870
6871IPPAPI( IppStatus, ippiNormDiff_L1_16u_C3CMR, ( const Ipp16u* pSrc1, int src1Step,
6872 const Ipp16u* pSrc2, int src2Step,
6873 const Ipp8u* pMask, int maskStep,
6874 IppiSize roiSize, int coi, Ipp64f* pNorm ))
6875
6876IPPAPI( IppStatus, ippiNormDiff_L1_32f_C3CMR, ( const Ipp32f* pSrc1, int src1Step,
6877 const Ipp32f* pSrc2, int src2Step,
6878 const Ipp8u* pMask, int maskStep,
6879 IppiSize roiSize, int coi, Ipp64f* pNorm ))
6880
6881
6882IPPAPI( IppStatus, ippiNormRel_L1_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
6883 const Ipp8u* pSrc2, int src2Step,
6884 const Ipp8u* pMask, int maskStep,
6885 IppiSize roiSize, Ipp64f* pNorm ) )
6886
6887IPPAPI( IppStatus, ippiNormRel_L1_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
6888 const Ipp16u* pSrc2, int src2Step,
6889 const Ipp8u* pMask, int maskStep,
6890 IppiSize roiSize, Ipp64f* pNorm ) )
6891
6892IPPAPI( IppStatus, ippiNormRel_L1_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
6893 const Ipp32f* pSrc2, int src2Step,
6894 const Ipp8u* pMask, int maskStep,
6895 IppiSize roiSize, Ipp64f* pNorm ) )
6896
6897
6898IPPAPI( IppStatus, ippiNorm_L2_8u_C1MR, ( const Ipp8u* pSrc, int srcStep,
6899 const Ipp8u* pMask,int maskStep,
6900 IppiSize roiSize, Ipp64f* pNorm ) )
6901
6902IPPAPI( IppStatus, ippiNorm_L2_16u_C1MR, ( const Ipp16u* pSrc, int srcStep,
6903 const Ipp8u* pMask,int maskStep,
6904 IppiSize roiSize, Ipp64f* pNorm ) )
6905
6906IPPAPI( IppStatus, ippiNorm_L2_32f_C1MR, ( const Ipp32f* pSrc, int srcStep,
6907 const Ipp8u* pMask, int maskStep,
6908 IppiSize roiSize, Ipp64f* pNorm ) )
6909
6910
6911IPPAPI( IppStatus, ippiNorm_L2_8u_C3CMR, ( const Ipp8u* pSrc, int srcStep,
6912 const Ipp8u* pMask,int maskStep,
6913 IppiSize roiSize, int coi, Ipp64f* pNorm ) )
6914
6915IPPAPI( IppStatus, ippiNorm_L2_16u_C3CMR, ( const Ipp16u* pSrc, int srcStep,
6916 const Ipp8u* pMask,int maskStep,
6917 IppiSize roiSize, int coi, Ipp64f* pNorm ) )
6918
6919IPPAPI( IppStatus, ippiNorm_L2_32f_C3CMR, ( const Ipp32f* pSrc, int srcStep,
6920 const Ipp8u* pMask, int maskStep,
6921 IppiSize roiSize, int coi, Ipp64f* pNorm ) )
6922
6923
6924IPPAPI( IppStatus, ippiNormDiff_L2_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
6925 const Ipp8u* pSrc2, int src2Step,
6926 const Ipp8u* pMask, int maskStep,
6927 IppiSize roiSize, Ipp64f* pNorm ) )
6928
6929IPPAPI( IppStatus, ippiNormDiff_L2_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
6930 const Ipp16u* pSrc2, int src2Step,
6931 const Ipp8u* pMask, int maskStep,
6932 IppiSize roiSize, Ipp64f* pNorm ) )
6933
6934IPPAPI( IppStatus, ippiNormDiff_L2_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
6935 const Ipp32f* pSrc2, int src2Step,
6936 const Ipp8u* pMask, int maskStep,
6937 IppiSize roiSize, Ipp64f* pNorm ) )
6938
6939
6940IPPAPI( IppStatus, ippiNormDiff_L2_8u_C3CMR, ( const Ipp8u* pSrc1, int src1Step,
6941 const Ipp8u* pSrc2, int src2Step,
6942 const Ipp8u* pMask, int maskStep,
6943 IppiSize roiSize, int coi, Ipp64f* pNorm ))
6944
6945IPPAPI( IppStatus, ippiNormDiff_L2_16u_C3CMR, ( const Ipp16u* pSrc1, int src1Step,
6946 const Ipp16u* pSrc2, int src2Step,
6947 const Ipp8u* pMask, int maskStep,
6948 IppiSize roiSize, int coi, Ipp64f* pNorm ))
6949
6950IPPAPI( IppStatus, ippiNormDiff_L2_32f_C3CMR, ( const Ipp32f* pSrc1, int src1Step,
6951 const Ipp32f* pSrc2, int src2Step,
6952 const Ipp8u* pMask, int maskStep,
6953 IppiSize roiSize, int coi, Ipp64f* pNorm ))
6954
6955
6956IPPAPI( IppStatus, ippiNormRel_L2_8u_C1MR, ( const Ipp8u* pSrc1, int src1Step,
6957 const Ipp8u* pSrc2, int src2Step,
6958 const Ipp8u* pMask, int maskStep,
6959 IppiSize roiSize, Ipp64f* pNorm ) )
6960
6961IPPAPI( IppStatus, ippiNormRel_L2_16u_C1MR, ( const Ipp16u* pSrc1, int src1Step,
6962 const Ipp16u* pSrc2, int src2Step,
6963 const Ipp8u* pMask, int maskStep,
6964 IppiSize roiSize, Ipp64f* pNorm ) )
6965
6966IPPAPI( IppStatus, ippiNormRel_L2_32f_C1MR, ( const Ipp32f* pSrc1, int src1Step,
6967 const Ipp32f* pSrc2, int src2Step,
6968 const Ipp8u* pMask, int maskStep,
6969 IppiSize roiSize, Ipp64f* pNorm ) )
6970
6971
6972/*F///////////////////////////////////////////////////////////////////////////////////////
6973// Name: ippiCannyGetSize
6974//
6975// Purpose: Calculates size of temporary buffer, required to run Canny function.
6976//
6977// Return:
6978// ippStsNoErr Ok
6979// ippStsNullPtrErr Pointer bufferSize is NULL
6980// ippStsSizeErr roiSize has a field with zero or negative value
6981//
6982// Parameters:
6983// roiSize Size of image ROI in pixel
6984// bufferSize Pointer to the variable that returns the size of the temporary buffer
6985//F*/
6986
6987IPPAPI( IppStatus, ippiCannyGetSize, ( IppiSize roiSize, int* bufferSize ))
6988
6989
6990/*F///////////////////////////////////////////////////////////////////////////////////////
6991// Name: ippiCanny_16s8u_C1IR, ippiCanny_32f8u_C1IR
6992//
6993// Purpose: Creates binary image of source's image edges,
6994// using derivatives of the first order.
6995//
6996// Return:
6997// ippStsNoErr Ok
6998// ippStsNullPtrErr One of pointers is NULL
6999// ippStsSizeErr The width or height of images is less or equal zero
7000// ippStsStepErr The steps in images are too small
7001// ippStsNotEvenStepErr Step is not multiple of element.
7002// ippStsBadArgErr Bad thresholds
7003//
7004// Parameters:
7005// pSrcDx Pointers to the source image ( first derivatives with respect to X )
7006// srcDxStep Step in bytes through the source image pSrcDx
7007// pSrcDy Pointers to the source image ( first derivatives with respect to Y )
7008// srcDyStep Step in bytes through the source image pSrcDy
7009//
7010// roiSize Size of the source images ROI in pixels
7011// lowThresh Low threshold for edges detection
7012// highThresh Upper threshold for edges detection
7013// pBuffer Pointer to the pre-allocated temporary buffer, which size can be
7014// calculated using ippiCannyGetSize function
7015//F*/
7016
7017IPPAPI(IppStatus, ippiCanny_16s8u_C1R, ( Ipp16s* pSrcDx, int srcDxStep,
7018 Ipp16s* pSrcDy, int srcDyStep,
7019 Ipp8u* pDstEdges, int dstEdgeStep,
7020 IppiSize roiSize,
7021 Ipp32f lowThresh,
7022 Ipp32f highThresh,
7023 Ipp8u* pBuffer ))
7024
7025IPPAPI(IppStatus, ippiCanny_32f8u_C1R, ( Ipp32f* pSrcDx, int srcDxStep,
7026 Ipp32f* pSrcDy, int srcDyStep,
7027 Ipp8u* pDstEdges, int dstEdgeStep,
7028 IppiSize roiSize,
7029 Ipp32f lowThresh,
7030 Ipp32f highThresh,
7031 Ipp8u* pBuffer ))
7032
7033
7034/*F///////////////////////////////////////////////////////////////////////////////////////
7035// Name: ippiCannyBorder_8u_C1R
7036// Purpose: Perform convolution operation with fixed kernels 3x3 and 5x5 and creates binary image of source's image edges,
7037// using derivatives of the first order.
7038// Parameters:
7039// pSrc The pointer to the source image
7040// srcStep The step in the source image
7041// pDst The pointer to the destination image
7042// dstStep The step in the destination image
7043// roiSize The image ROI size
7044// filterType the filter type(ippFilterSobel,ippFilterScharr)
7045// mask The mask size(ippMskSize3x3,ippMskSize5x5)
7046// borderType Type of border. Possible values are:
7047// ippBorderConst Values of all border pixels are set to constant.
7048// ippBorderRepl Border is replicated from the edge pixels.
7049// ippBorderInMem Border is obtained from the source image pixels in memory.
7050// Mixed borders are also supported. They can be obtained by the bitwise operation OR between ippBorderRepl and ippBorderInMemTop, ippBorderInMemBottom, ippBorderInMemLeft, ippBorderInMemRight.
7051// borderValue The value for the constant border
7052// lowThresh Low threshold for edges detection
7053// highThresh Upper threshold for edges detection
7054// norm Norm type (ippNormL1,ippNormL2)
7055// pBuffer Pointer to the pre-allocated temporary buffer, which size can be
7056// calculated using ippiCannyEdgeDetectionGetSize function
7057// Return:
7058// ippStsNoErr Ok
7059// ippStsMaskSizeErr Indicates an error when mask has an illegal value.
7060// ippStsNullPtrErr One of pointers is NULL
7061// ippStsSizeErr The width or height of images is less or equal zero
7062// ippStsNotEvenStepErr Step is not multiple of element.
7063// ippStsBadArgErr Bad thresholds
7064//
7065//F*/
7066
7067IPPAPI(IppStatus, ippiCannyBorder_8u_C1R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize,
7068 IppiDifferentialKernel filterType, IppiMaskSize mask,IppiBorderType borderType, Ipp8u borderValue,
7069 Ipp32f lowThresh, Ipp32f highThresh, IppNormType norm,Ipp8u* pBuffer ))
7070/*F///////////////////////////////////////////////////////////////////////////////////////
7071// Name: ippiCannyBorderGetSize
7072//
7073// Purpose: Calculates size of temporary buffer, required to run ippiCannyBorder_8u_C1R function.
7074// Parameters:
7075// roiSize Size of image ROI in pixel
7076// filterType The filter type(ippFilterSobel,ippFilterScharr)
7077// mask The mask size(ippMskSize3x3,ippMskSize5x5)
7078// dataType Data type of the image. Possible values are Ipp8u, Ipp16u, Ipp16s, or Ipp32f.
7079// pBufferSize Pointer to the variable that returns the size of the temporary buffer
7080//
7081// Return:
7082// ippStsNoErr Ok
7083// ippStsNullPtrErr Pointer bufferSize is NULL
7084// ippStsMaskSizeErr Indicates an error when mask has an illegal value.
7085// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
7086// ippStsSizeErr roiSize has a field with zero or negative value
7087//
7088//F*/
7089IPPAPI(IppStatus, ippiCannyBorderGetSize,( IppiSize roiSize, IppiDifferentialKernel filterType,IppiMaskSize mask, IppDataType dataType, int* pBufferSize ))
7090
7091/*F///////////////////////////////////////////////////////////////////////////////////////
7092// Name: ippiDistanceTransform_3x3_8u32f_C1R, ippiDistanceTransform_5x5_8u32f_C1R,
7093// ippiDistanceTransform_3x3_8u16u_C1R, ippiDistanceTransform_5x5_8u16u_C1R,
7094// ippiDistanceTransform_3x3_8u_C1R, ippiDistanceTransform_5x5_8u_C1R,
7095// ippiDistanceTransform_3x3_8u_C1IR, ippiDistanceTransform_5x5_8u_C1IR,
7096// ippiTrueDistanceTransform_8u32f_C1R
7097//
7098// Purpose: For every non-zero pixel in the source image, the functions calculate
7099// distance between that pixel and nearest zero pixel.
7100//
7101// Return:
7102// ippStsNoErr Ok
7103// ippStsNullPtrErr One of pointers is NULL
7104// ippStsSizeErr The width or height of images is less or equal zero
7105// ippStsStepErr The steps in images are too small
7106// ippStsNotEvenStepErr Step is not multiple of element.
7107// ippStsCoeffErr Zero mask coefficient
7108//
7109// Parameters:
7110// pSrc Source image
7111// pSrcDst Pointer to the input and output image
7112// srcStep Its step
7113// pDst Output image with distances
7114// dstStep Its step
7115// roiSize ROI size
7116// pMetrics Array that determines metrics used.
7117// scaleFactor Scale factor
7118// pBuffer The pointer to the working buffer
7119//
7120//F*/
7121
7122IPPAPI(IppStatus, ippiDistanceTransform_5x5_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep,
7123 Ipp32f* pDst, int dstStep,
7124 IppiSize roiSize, Ipp32f* pMetrics ))
7125
7126IPPAPI(IppStatus, ippiTrueDistanceTransform_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep,
7127 Ipp32f* pDst, int dstStep,
7128 IppiSize roiSize, Ipp8u* pBuffer ))
7129
7130IPPAPI(IppStatus, ippiDistanceTransform_3x3_8u_C1R, ( const Ipp8u* pSrc, int srcStep,
7131 Ipp8u* pDst, int dstStep,
7132 IppiSize roiSize, Ipp32s* pMetrics ))
7133
7134IPPAPI(IppStatus, ippiDistanceTransform_3x3_8u32f_C1R, ( const Ipp8u* pSrc, int srcStep,
7135 Ipp32f* pDst, int dstStep,
7136 IppiSize roiSize, Ipp32f* pMetrics ))
7137
7138
7139/* ///////////////////////////////////////////////////////////////////////////////////////////////////
7140// Name: ippiTrueDistanceTransformGetBufferSize_8u32f_C1R
7141//
7142// Purpose: Get size of external buffer.
7143//
7144// Return:
7145// ippStsNoErr Ok
7146// ippStsNullPtrErr One of pointers is NULL
7147// ippStsSizeErr Indicates an error condition if roiSize has a field with zero
7148// or negative value.
7149//
7150// Parameters:
7151// roiSize The image ROI size
7152// pBufferSize The pointer to the buffer size
7153*/
7154
7155IPPAPI(IppStatus, ippiTrueDistanceTransformGetBufferSize_8u32f_C1R, (IppiSize roiSize, int* pBufferSize))
7156
7157
7158/* ///////////////////////////////////////////////////////////////////////////////////////
7159// Name: ippiUpdateMotionHistory_8u32f_C1IR, ippiUpdateMotionHistory_16u32f_C1IR
7160// ippiUpdateMotionHistory_32f_C1IR
7161//
7162// Purpose: Sets motion history image (MHI) pixels to the current time stamp
7163// when the corrensonding pixels in the silhoette image are non zero.
7164// Else (silhouette pixels are zero) MHI pixels are
7165// cleared if their values are too small (less than timestamp - mhiDuration),
7166// i.e. they were updated far ago last time. Else MHI pixels remain unchanged.
7167//
7168// Return:
7169// ippStsNoErr Ok
7170// ippStsNullPtrErr One of pointers is NULL
7171// ippStsSizeErr The width or height of images is less or equal zero
7172// ippStsStepErr The steps in images are too small
7173// ippStsNotEvenStepErr Step is not multiple of element.
7174// ippStsOutOfRangeErr Maximal duration is negative
7175//
7176// Arguments:
7177// pSilhouette The pointer to silhouette image
7178// silhStep The step in silhouette image
7179// pMHI The pointer to motion history image
7180// mhiStep The step in mhi image
7181// roiSize ROI size
7182// timestamp Current time stamp (milliseconds)
7183// mhiDuration Maximal duration of motion track (milliseconds)
7184*/
7185
7186IPPAPI(IppStatus, ippiUpdateMotionHistory_8u32f_C1IR,
7187 ( const Ipp8u* pSilhouette, int silhStep,
7188 Ipp32f* pMHI, int mhiStep, IppiSize roiSize,
7189 Ipp32f timestamp, Ipp32f mhiDuration ))
7190
7191
7192/*
7193// Name: ippiHoughLine_Region_8u32f_C1R
7194//
7195//
7196// Purpose: Perform Hough transform algorithm in defined region
7197//
7198//
7199// Arguments:
7200// pSrc Pointer to the source image ROI
7201// srcStep Distance in bytes between starts of consecutive lines in the source image
7202// roiSize The size of source ROI.
7203// pLine Pointer to output array of detected lines
7204// dstRoi Bottom left and top right corners of searched lines. All founded lines must be
7205// in this area. (line[n].rho>=dstRoi[0].rho && line[n].theta>=dstRoi[0].theta &&
7206// line[n].rho<=dstRoi[1].rho && line[n].theta<=dstRoi[1].theta)
7207// maxLineCount Size of output array pLine in elements
7208// pLineCount Number of detected lines. If founded more than maxLineCount lines than function returns "ippStsDstSizeLessExpected" status
7209// delta Discretization step, delta.rho - distance resolution in pixels, delta.theta - angle resolution in radians
7210// threshold Threshold for a line is detected (if accumulator value > threshold)
7211// pBuffer Pointer to the pre-allocated temporary buffer
7212//
7213// Return:
7214// ippStsNoErr Ok
7215// ippStsNullPtrErr pSrc or pLine or pLineCount or pBuffer is NULL
7216// ippStsStepErr srcStep is not valid
7217// ippStsSizeErr roiSize has a field with zero or negative value or maxLineCount is zero or negative
7218// ippStsBadArgErr threshold or is less than or equal to zero or delta.rho less 0 or more ROI width+height or
7219// delta.theta less 0 or more PI or dstRoi[0].rho more dstRoi[1].rho or dstRoi[0].theta more dstRoi[1].theta
7220// ippStsDstSizeLessExpected Ok, but lines detected more than maxLineCount
7221//
7222*/
7223
7224IPPAPI(IppStatus, ippiHoughLine_Region_8u32f_C1R, (const Ipp8u* pSrc, int srcStep, IppiSize roiSize,
7225 IppPointPolar* pLine, IppPointPolar dstRoi[2], int maxLineCount, int* pLineCount, IppPointPolar delta, int threshold, Ipp8u* pBuffer))
7226
7227
7228/* ///////////////////////////////////////////////////////////////////////////////////////
7229// Name: ippiHoughLineGetSize_8u_C1R()
7230//
7231//
7232// Purpose: Calculate the size of temporary buffer for ippiHoughLine_8u32f_C1R function.
7233//
7234// Arguments:
7235// roiSize The size of source ROI.
7236// delta Discretization step, delta.rho - distance resolution in pixels, delta.theta - angle resolution in radians
7237// maxLineCount The size of detected line buffer
7238// pBufSize Pointer to the computed size of the temporary buffer
7239//
7240// Return:
7241// ippStsNoErr Ok
7242// ippStsNullPtrErr pBufSize is NULL
7243// ippStsSizeErr The roiSize or delta has a field with zero or negative value
7244// ippStsOverflow The size of buffer too big. Overflow.
7245//
7246*/
7247
7248IPPAPI(IppStatus, ippiHoughLineGetSize_8u_C1R, (IppiSize roiSize, IppPointPolar delta, int maxLineCount, int* pBufSize))
7249
7250
7251/*
7252// Name: ippiHoughLine_Region_8u32f_C1R
7253//
7254//
7255// Purpose: Perform Hough transform algorithm in defined region
7256//
7257//
7258// Arguments:
7259// pSrc Pointer to the source image ROI
7260// srcStep Distance in bytes between starts of consecutive lines in the source image
7261// roiSize The size of source ROI.
7262// pLine Pointer to output array of detected lines
7263// dstRoi Bottom left and top right corners of searched lines. All founded lines must be
7264// in this area. (line[n].rho>=dstRoi[0].rho && line[n].theta>=dstRoi[0].theta &&
7265// line[n].rho<=dstRoi[1].rho && line[n].theta<=dstRoi[1].theta)
7266// maxLineCount Size of output array pLine in elements
7267// pLineCount Number of detected lines. If founded more than maxLineCount lines than function returns "ippStsDstSizeLessExpected" status
7268// delta Discretization step, delta.rho - distance resolution in pixels, delta.theta - angle resolution in radians
7269// threshold Threshold for a line is detected (if accumulator value > threshold)
7270// pBuffer Pointer to the pre-allocated temporary buffer
7271//
7272// Return:
7273// ippStsNoErr Ok
7274// ippStsNullPtrErr pSrc or pLine or pLineCount or pBuffer is NULL
7275// ippStsStepErr srcStep is not valid
7276// ippStsSizeErr roiSize has a field with zero or negative value or maxLineCount is zero or negative
7277// ippStsBadArgErr threshold or is less than or equal to zero or delta.rho less 0 or more ROI width+height or
7278// delta.theta less 0 or more PI or dstRoi[0].rho more dstRoi[1].rho or dstRoi[0].theta more dstRoi[1].theta
7279// ippStsDstSizeLessExpected Ok, but lines detected more than maxLineCount
7280//
7281*/
7282
7283IPPAPI(IppStatus, ippiHoughProbLineGetSize_8u_C1R, (
7284 IppiSize roiSize,
7285 IppPointPolar delta,
7286 int* pSpecSize,
7287 int* pBufSize))
7288
7289IPPAPI(IppStatus, ippiHoughProbLineInit_8u32f_C1R,(
7290 IppiSize roiSize,
7291 IppPointPolar delta,
7292 IppHintAlgorithm hint,
7293 IppiHoughProbSpec* pSpec))
7294
7295IPPAPI(IppStatus, ippiHoughProbLine_8u32f_C1R,(
7296 const Ipp8u* pSrc,
7297 int srcStep,
7298 IppiSize roiSize,
7299 int threshold,
7300 int lineLength,
7301 int lineGap,
7302 IppiPoint* pLine,
7303 int maxLineCount,
7304 int* pLineCount,
7305 Ipp8u* pBuffer,
7306 const IppiHoughProbSpec* pSpec
7307 ))
7308
7309/* /////////////////////////////////////////////////////////////////////////////
7310// Name: ippiFilterSpeckleGetBufferSize
7311//
7312// Purpose: Computes the size of the external buffer for ippiFilterSpeckle function
7313//
7314// Parameters:
7315// dstRoiSize Size of destination ROI in pixels.
7316// dataType Data type of the source and destination images.
7317// numChannels Number of channels in the images. Possible value is 1.
7318// pBufferSize Pointer to the size (in bytes) of the external work buffer.
7319//
7320// Return Values:
7321// ippStsNoErr Indicates no error.
7322// ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
7323// ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
7324// ippStsDataTypeErr Indicates an error when dataType has an illegal value.
7325// ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
7326*/
7327
7328IPPAPI(IppStatus, ippiMarkSpecklesGetBufferSize, (IppiSize roiSize,
7329 IppDataType dataType, int numChannels, int* pBufferSize))
7330
7331
7332/* /////////////////////////////////////////////////////////////////////////////
7333//
7334// Name: rippiFilterSpeckle
7335// Purpose: Performs filtering of small noise blobs (speckles)
7336// in the image
7337//
7338// Parameters:
7339// pSrcDst Pointer to the source and destination image
7340// srcDstStep Step through the source and destination image
7341// roiSize Size of the source and destination image ROI.
7342// speckleVal The disparity value used to paint-off the speckles
7343// maxSpeckleSize The maximum speckle size to consider it a speckle.
7344// maxPixDiff Maximum difference between neighbor pixels to put them into the same blob.
7345// norm Specifies type of the norm to form the mask for marker propagation:
7346// ippiNormInf Infinity norm (8-connectivity);
7347// ippiNormL1 L1 norm (4-connectivity).
7348// pBuffer Pointer to the work buffer
7349//
7350// Return Values:
7351// ippStsNoErr Indicates no error.
7352// ippStsNullPtrErr Indicates an error condition if pSrc, pDst or pBufferSize is NULL.
7353// ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
7354// ippStsNotEvenStepErr Indicated an error when one of the step values is not divisible by 4
7355// for floating-point images, or by 2 for short-integer images.
7356// ippStsNanArg Indicates an error when one of speckleVal or maxPixDiff is not a number
7357// ippStsNormErr Indicates an error when norm is incorrect or not supported
7358*/
7359
7360IPPAPI(IppStatus, ippiMarkSpeckles_16s_C1IR, (Ipp16s *pSrcDst, int srcDstStep, IppiSize roiSize,
7361 Ipp16s speckleVal, int maxSpeckleSize, Ipp16s maxPixDiff, IppiNorm norm, Ipp8u* pBuffer))
7362
7363IPPAPI(IppStatus, ippiMarkSpeckles_8u_C1IR, (Ipp8u *pSrcDst, int srcDstStep, IppiSize roiSize,
7364 Ipp8u speckleVal, int maxSpeckleSize, Ipp8u maxPixDiff, IppiNorm norm, Ipp8u* pBuffer))
7365
7366
7367
7368/* =============================================================================
7369 ippCC
7370============================================================================= */
7371
7372/* /////////////////////////////////////////////////////////////////////////////
7373// Name: ippccGetLibVersion
7374// Purpose: getting of the library version
7375// Returns: the structure of information about version
7376// of ippCC library
7377// Parameters:
7378//
7379// Notes: not necessary to release the returned structure
7380*/
7381IPPAPI( const IppLibraryVersion*, ippccGetLibVersion, (void) )
7382
7383
7384/* /////////////////////////////////////////////////////////////////////////////
7385// Name: ippiBGRToLab_8u_C3R and ippiLabToBGR_8u_C3R
7386// ippiBGRToLab_8u16u_C3R and ippiLabToBGR_16u8u_C3R
7387// Purpose: Converts an RGB image to CIE Lab color model and vice-versa
7388// Parameters:
7389// pSrc Pointer to the source image ROI
7390// srcStep Step through the source image (bytes)
7391// pDst Pointer to the destination image ROI
7392// dstStep Step through the destination image (bytes)
7393// roiSize Size of the ROI
7394// Returns:
7395// ippStsNullPtrErr if src == NULL or dst == NULL
7396// ippStsSizeErr if imgSize.width <= 0 || imgSize.height <= 0
7397// ippStsNoErr otherwise
7398// Reference:
7399// Computer graphics: principles and practices. James D. Foley... [et al.]. 2nd ed.
7400// Addison-Wesley, c1990.p.(584)
7401//
7402// At first an RGB image is converted to the XYZ color model (see the function
7403// ippRGBToXYZ_8u_C3R), then to the CIELab with the white point D65 and CIE chromaticity
7404// coordinates of white point (xn,yn) = (0.312713, 0.329016)
7405// L = 116. *((Y/Yn)^(1/3)) - 16 for Y/Yn > 0.008856
7406// L = 903.3*(Y/Yn) for Y/Yn <= 0.008856
7407// a = 500. * (f(X/Xn) - f(Y/Yn))
7408// b = 200. * (f(Y/Yn) - f(Z/Zn))
7409// where f(t)=t^(1/3) for t > 0.008856
7410// f(t)=7.787*t+16/116 for t <= 0.008856
7411// These values are quantized and scaled to the 8-bit range of 0 to 255 for ippiBGRToLab_8u_C3R.
7412// L = L * 255. / 100.
7413// a = (a + 128.)
7414// b = (a + 128.)
7415// and they are quantized and scaled to the 16-bit range of 0 to 65535 for ippiBGRToLab_8u16u_C3R
7416// L = L * 65535. / 100.
7417// a = (a + 128.)* 255
7418// b = (a + 128.)* 255
7419// where:
7420// normalizing multipliers
7421// Yn = 1.0 * 255
7422// Xn = 0.950455 * 255
7423// Zn = 1.088753 * 255
7424//
7425// L component values are in the range [0..100], a and b component values are
7426// in the range [-128..127].
7427//
7428// The CIELab to RGB conversion is performed as follows. At first
7429// a Lab image is converted to the XYZ image
7430// for ippiLabToBGR_8u_C3R
7431// L = L * 100./ 255.
7432// a = (a - 128.)
7433// b = (a - 128.)
7434// or for ippiLabToBGR_16u8u_C3R
7435// L = L * 100./ 65535.
7436// a = (a / 255 - 128.)
7437// b = (b / 255 - 128.)
7438// X = Xn * ( P + a / 500 )^3
7439// Y = Yn * P^3
7440// Z = Zn * ( P - b / 200 )^3
7441// where P = (L + 16) / 116
7442// Then the XYZ image is converted to the RGB color model (see the function
7443// ippXYZToRGB_8u_C3R).
7444//
7445*/
7446IPPAPI(IppStatus, ippiBGRToLab_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst,int dstStep, IppiSize roiSize))
7447IPPAPI(IppStatus, ippiLabToBGR_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst,int dstStep, IppiSize roiSize))
7448
7449
7450/* /////////////////////////////////////////////////////////////////////////////
7451// Name: ippiGrayToRGB
7452// Purpose: Converts gray scale image to RGB/BGR image by copiing luminance component to color components
7453// Parameters:
7454// pSrc Pointer to the source image
7455// pDst Pointer to the destination image
7456// roiSize Size of source and destination ROI in pixels
7457// srcStep Step in bytes through the source image to jump on the next line
7458// dstStep Step in bytes through the destination image to jump on the next line
7459// aval Constant value to create the fourth channel
7460// Returns:
7461// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
7462// ippStsSizeErr roiSize has a field with zero or negative value
7463// ippStsNoErr No errors
7464//
7465*/
7466IPPAPI(IppStatus, ippiGrayToRGB_8u_C1C3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
7467IPPAPI(IppStatus, ippiGrayToRGB_16u_C1C3R,(const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize))
7468IPPAPI(IppStatus, ippiGrayToRGB_32f_C1C3R,(const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize))
7469IPPAPI(IppStatus, ippiGrayToRGB_8u_C1C4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp8u aval))
7470IPPAPI(IppStatus, ippiGrayToRGB_16u_C1C4R,(const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize, Ipp16u aval))
7471IPPAPI(IppStatus, ippiGrayToRGB_32f_C1C4R,(const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f aval))
7472
7473/* /////////////////////////////////////////////////////////////////////////////
7474// Name: ippiColorToGray
7475// Purpose: Converts an RGB image to gray scale (custom coefficients)
7476// Parameters:
7477// pSrc Pointer to the source image , points to point(0,0)
7478// pDst Pointer to the destination image , points to point(0,0)
7479// roiSize Size of the ROI in pixels. Since the function performs point
7480// operations (without a border), the ROI may be the whole image.
7481// srcStep Step in bytes through the source image to jump on the next line
7482// dstStep Step in bytes through the destination image to jump on the next line
7483// coeffs[3] User-defined vector of coefficients.
7484// The sum of the coefficients should be less than or equal to 1
7485// Returns:
7486// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
7487// ippStsSizeErr roiSize has a field with zero or negative value
7488// ippStsNoErr No errors
7489//
7490// The following equation is used to convert an RGB image to gray scale:
7491//
7492// Y = coeffs[0] * R + coeffs[1] * G + coeffs[2] * B;
7493//
7494//
7495*/
7496
7497IPPAPI(IppStatus,ippiColorToGray_8u_C3C1R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
7498IPPAPI(IppStatus,ippiColorToGray_16u_C3C1R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
7499IPPAPI(IppStatus,ippiColorToGray_16s_C3C1R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
7500IPPAPI(IppStatus,ippiColorToGray_32f_C3C1R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
7501
7502IPPAPI(IppStatus,ippiColorToGray_8u_AC4C1R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
7503IPPAPI(IppStatus,ippiColorToGray_16u_AC4C1R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
7504IPPAPI(IppStatus,ippiColorToGray_16s_AC4C1R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
7505IPPAPI(IppStatus,ippiColorToGray_32f_AC4C1R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
7506
7507
7508/* /////////////////////////////////////////////////////////////////////////////
7509// Name: ippiRGBToGray
7510// Purpose: Converts an RGB image to gray scale (fixed coefficients)
7511// Parameters:
7512// pSrc Pointer to the source image , points to point(0,0)
7513// pDst Pointer to the destination image , points to point(0,0)
7514// roiSize Size of the ROI in pixels. Since the function performs point
7515// operations (without a border), the ROI may be the whole image.
7516// srcStep Step in bytes through the source image to jump on the next line
7517// dstStep Step in bytes through the destination image to jump on the next line
7518// Returns:
7519// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
7520// ippStsSizeErr roiSize has a field with zero or negative value
7521// ippStsNoErr No errors
7522// Reference:
7523// Jack Keith
7524// Video Demystified: A Handbook for the Digital Engineer, 2nd ed.
7525// 1996.p.(82)
7526//
7527// The transform coefficients of equation below correspond to the standard for
7528// NTSC red, green and blue CRT phosphors (1953) that are standardized in the
7529// ITU-R Recommendation BT. 601-2 (formerly CCIR Rec. 601-2).
7530//
7531// The basic equation to compute non-linear video luma (monochrome) from non-linear
7532// (gamma-corrected) RGB(R'G'B') is:
7533//
7534// Y' = 0.299 * R' + 0.587 * G' + 0.114 * B';
7535//
7536//
7537*/
7538
7539IPPAPI(IppStatus,ippiRGBToGray_8u_C3C1R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize))
7540IPPAPI(IppStatus,ippiRGBToGray_16u_C3C1R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize))
7541IPPAPI(IppStatus,ippiRGBToGray_16s_C3C1R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize))
7542IPPAPI(IppStatus,ippiRGBToGray_32f_C3C1R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep,IppiSize roiSize))
7543IPPAPI(IppStatus,ippiRGBToGray_8u_AC4C1R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize))
7544IPPAPI(IppStatus,ippiRGBToGray_16u_AC4C1R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize))
7545IPPAPI(IppStatus,ippiRGBToGray_16s_AC4C1R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize))
7546IPPAPI(IppStatus,ippiRGBToGray_32f_AC4C1R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep,IppiSize roiSize))
7547
7548
7549/* /////////////////////////////////////////////////////////////////////////////
7550// Name: ippiRGBToLUV, ippiLUVToRGB
7551// Purpose: Converts an RGB image to the LUV color model and vice versa.
7552// Parameters:
7553// pSrc Pointer to the source image ROI
7554// srcStep Step through the source image (bytes)
7555// pDst Pointer to the destination image ROI
7556// dstStep Step through the destination image (bytes)
7557// dstRoiSize size of the ROI
7558// Returns:
7559// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
7560// ippStsStepErr srcStep or dstStep is less than or equal to zero
7561// ippStsSizeErr roiSize has a field with zero or negative value
7562// ippStsNoErr No errors
7563// Reference:
7564// Computer Graphics: Principles and Practices. James D. Foley... [et al]. 2nd edition.
7565// Addison-Wesley, 1990.p.(584)
7566//
7567// At first an RGB image is converted to the XYZ format image (see the functions
7568// ippiRGBToXYZ), then to the CIELUV with the white point D65 and CIE chromaticity
7569// coordinates of white point (xn,yn) = (0.312713, 0.329016), and Yn = 1.0 - the luminance of white point.
7570//
7571// L = 116. * (Y/Yn)**1/3. - 16.
7572// U = 13. * L * ( u - un )
7573// V = 13. * L * ( v - vn )
7574// These are quantized and limited to the 8-bit range of 0 to 255.
7575// L = L * 255. / 100.
7576// U = ( U + 134. ) * 255. / 354.
7577// V = ( V + 140. ) * 255. / 256.
7578// where:
7579// u' = 4.*X / (X + 15.*Y + 3.*Z)
7580// v' = 9.*Y / (X + 15.*Y + 3.*Z)
7581// un = 4.*xn / ( -2.*xn + 12.*yn + 3. )
7582// vn = 9.*yn / ( -2.*xn + 12.*yn + 3. ).
7583// xn, yn is the CIE chromaticity coordinates of white point.
7584// Yn = 255. is the luminance of white point.
7585//
7586// The L component values are in the range [0..100], the U component values are
7587// in the range [-134..220], and the V component values are in the range [-140..122].
7588//
7589// The CIELUV to RGB conversion is performed as following. At first
7590// a LUV image is converted to the XYZ image
7591// L = L * 100./ 255.
7592// U = ( U * 354./ 255.) - 134.
7593// V = ( V * 256./ 255.) - 140.
7594// u = U / ( 13.* L ) + un
7595// v = V / ( 13.* L ) + vn
7596// Y = (( L + 16. ) / 116. )**3.
7597// Y *= Yn
7598// X = -9.* Y * u / (( u - 4.)* v - u * v )
7599// Z = ( 9.*Y - 15*v*Y - v*X ) / 3. * v
7600// where:
7601// un = 4.*xn / ( -2.*xn + 12.*yn + 3. )
7602// vn = 9.*yn / ( -2.*xn + 12.*yn + 3. ).
7603// xn, yn is the CIE chromaticity coordinates of white point.
7604// Yn = 255. is the luminance of white point.
7605//
7606// Then the XYZ image is converted to the RGB image (see the functions
7607// ippiXYZToRGB).
7608//
7609*/
7610IPPAPI(IppStatus, ippiRGBToLUV_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
7611IPPAPI(IppStatus, ippiLUVToRGB_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
7612
7613IPPAPI(IppStatus, ippiRGBToLUV_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
7614IPPAPI(IppStatus, ippiLUVToRGB_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
7615
7616IPPAPI(IppStatus, ippiRGBToLUV_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
7617IPPAPI(IppStatus, ippiLUVToRGB_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
7618
7619IPPAPI(IppStatus, ippiRGBToLUV_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
7620IPPAPI(IppStatus, ippiLUVToRGB_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
7621
7622
7623/* /////////////////////////////////////////////////////////////////////////////
7624// Name: ippiRGBToXYZ, ippiXYZToRGB
7625// Purpose: Converts an RGB image to the XYZ color model and vice versa.
7626// Parameters:
7627// pSrc Pointer to the source image ROI
7628// srcStep Step through the source image (bytes)
7629// pDst Pointer to the destination image ROI
7630// dstStep Step through the destination image (bytes)
7631// dstRoiSize size of the ROI
7632// Returns:
7633// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
7634// ippStsStepErr srcStep or dstStep is less than or equal to zero
7635// ippStsSizeErr roiSize has a field with zero or negative value
7636// ippStsNoErr No errors
7637// Reference:
7638// David F. Rogers
7639// Procedural Elements for Computer Graphics.
7640// 1985.
7641//
7642// The basic equations to convert between Rec. 709 RGB (with its D65 white point) and CIE XYZ are:
7643//
7644// X = 0.412453 * R + 0.35758 * G + 0.180423 * B
7645// Y = 0.212671 * R + 0.71516 * G + 0.072169 * B
7646// Z = 0.019334 * R + 0.119193* G + 0.950227 * B
7647//
7648// R = 3.240479 * X - 1.53715 * Y - 0.498535 * Z
7649// G =-0.969256 * X + 1.875991 * Y + 0.041556 * Z
7650// B = 0.055648 * X - 0.204043 * Y + 1.057311 * Z
7651// Equations are given above in assumption that the X,Y,Z,R,G, and B
7652// values are in the range [0..1].
7653// Y, C1, C2, R, G, B - are scaled to the range:
7654// [0..1] for the 32f depth,
7655// [0..IPP_MAX_8u] for the 8u depth,
7656// [0..IPP_MAX_16u] for the 16u depth,
7657// [IPP_MIN_16s..IPP_MAX_16s] for the 16s depth.
7658//
7659*/
7660
7661IPPAPI(IppStatus, ippiRGBToXYZ_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
7662IPPAPI(IppStatus, ippiXYZToRGB_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
7663IPPAPI(IppStatus, ippiRGBToXYZ_16u_C3R,(const Ipp16u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
7664IPPAPI(IppStatus, ippiXYZToRGB_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
7665IPPAPI(IppStatus, ippiRGBToXYZ_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
7666IPPAPI(IppStatus, ippiXYZToRGB_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
7667
7668
7669/* ////////////////////////////////////////////////////////////////////////////
7670// Name: ippiRGBToHSV, ippiHSVToRGB
7671// Purpose: Converts an RGB image to the HSV color model and vice versa
7672// Parameters:
7673// pSrc Pointer to the source image , points to point(0,0)
7674// pDst Pointer to the destination image , points to point(0,0)
7675// roiSize Size of the ROI in pixels.
7676// srcStep Step in bytes through the source image to jump on the next line
7677// dstStep Step in bytes through the destination image to jump on the next line
7678// Returns:
7679// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
7680// ippStsStepErr srcStep or dstStep is less than or equal to zero
7681// ippStsSizeErr roiSize has a field with zero or negative value
7682// ippStsNoErr No errors
7683// Reference:
7684// David F.Rogers
7685// Procedural Elements for Computer Graphics
7686// 1985.pp.(401-403)
7687//
7688// H is the hue red at 0 degrees, which has range [0 .. 360 degrees],
7689// S is the saturation,
7690// V is the value
7691// The RGB to HSV conversion algorithm in pseudo code:
7692// Value:
7693// V = max(R,G,B);
7694// Saturation:
7695// temp = min(R,G,B);
7696// if V = 0 then // achromatic case
7697// S = 0
7698// H = 0
7699// else // chromatics case
7700// S = (V - temp)/V
7701// Hue:
7702// Cr = (V - R) / (V - temp)
7703// Cg = (V - G) / (V - temp)
7704// Cb = (V - B) / (V - temp)
7705// if R = V then H = Cb - Cg
7706// if G = V then H = 2 + Cr - Cb
7707// if B = V then H = 4 + Cg - Cr
7708// H = 60*H
7709// if H < 0 then H = H + 360
7710//
7711// The HSV to RGB conversion algorithm in pseudo code:
7712// if S = 0 then
7713// R = G = B = V
7714// else
7715// if H = 360 then
7716// H = 0
7717// else
7718// H = H/60
7719// I = floor(H)
7720// F = H - I;
7721// M = V * ( 1 - S);
7722// N = V * ( 1 - S * F);
7723// K = V * ( 1 - S * (1 - F));
7724// if(I == 0)then{ R = V;G = K;B = M;}
7725// if(I == 1)then{ R = N;G = V;B = M;}
7726// if(I == 2)then{ R = M;G = V;B = K;}
7727// if(I == 3)then{ R = M;G = N;B = V;}
7728// if(I == 4)then{ R = K;G = M;B = V;}
7729// if(I == 5)then{ R = V;G = M;B = N;}
7730//
7731// in the range [0..IPP_MAX_8u ] for the 8u depth,
7732// in the range [0..IPP_MAX_16u] for the 16u depth,
7733//
7734*/
7735
7736IPPAPI(IppStatus, ippiRGBToHSV_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
7737IPPAPI(IppStatus, ippiHSVToRGB_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
7738IPPAPI(IppStatus, ippiRGBToHSV_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
7739IPPAPI(IppStatus, ippiHSVToRGB_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
7740
7741
7742/* ////////////////////////////////////////////////////////////////////////////
7743// Name: ippiRGBToHLS, ippiHLSToRGB
7744// ippiBGRToHLS, ippiHLSToBGR
7745// Purpose: Converts an RGB(BGR) image to the HLS color model and vice versa
7746// Parameters:
7747// pSrc Pointer to the source image , points to point(0,0)
7748// pDst Pointer to the destination image , points to point(0,0)
7749// roiSize Size of the ROI in pixels. Since the function performs point
7750// operations (without a border), the ROI may be the whole image.
7751// srcStep Step in bytes through the source image to jump on the next line
7752// dstStep Step in bytes through the destination image to jump on the next line
7753// Returns:
7754// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
7755// ippStsStepErr srcStep or dstStep is less than or equal to zero
7756// ippStsSizeErr roiSize has a field with zero or negative value
7757// ippStsNoErr No errors
7758// RGB and HLS values for the 32f data type should be in the range [0..1]
7759// Reference:
7760// David F.Rogers
7761// Procedural Elements for Computer Graphics
7762// 1985.pp.(403-406)
7763//
7764// H is the hue red at 0 degrees, which has range [0 .. 360 degrees],
7765// L is the lightness,
7766// S is the saturation,
7767//
7768// The RGB to HLS conversion algorithm in pseudo code:
7769// Lightness:
7770// M1 = max(R,G,B); M2 = max(R,G,B); L = (M1+M2)/2
7771// Saturation:
7772// if M1 = M2 then // achromatic case
7773// S = 0
7774// H = 0
7775// else // chromatics case
7776// if L <= 0.5 then
7777// S = (M1-M2) / (M1+M2)
7778// else
7779// S = (M1-M2) / (2-M1-M2)
7780// Hue:
7781// Cr = (M1-R) / (M1-M2)
7782// Cg = (M1-G) / (M1-M2)
7783// Cb = (M1-B) / (M1-M2)
7784// if R = M2 then H = Cb - Cg
7785// if G = M2 then H = 2 + Cr - Cb
7786// if B = M2 then H = 4 + Cg - Cr
7787// H = 60*H
7788// if H < 0 then H = H + 360
7789//
7790// The HSL to RGB conversion algorithm in pseudo code:
7791// if L <= 0.5 then
7792// M2 = L *(1 + S)
7793// else
7794// M2 = L + S - L * S
7795// M1 = 2 * L - M2
7796// if S = 0 then
7797// R = G = B = L
7798// else
7799// h = H + 120
7800// if h > 360 then
7801// h = h - 360
7802
7803// if h < 60 then
7804// R = ( M1 + ( M2 - M1 ) * h / 60)
7805// else if h < 180 then
7806// R = M2
7807// else if h < 240 then
7808// R = M1 + ( M2 - M1 ) * ( 240 - h ) / 60
7809// else
7810// R = M1
7811// h = H
7812// if h < 60 then
7813// G = ( M1 + ( M2 - M1 ) * h / 60
7814// else if h < 180 then
7815// G = M2
7816// else if h < 240 then
7817// G = M1 + ( M2 - M1 ) * ( 240 - h ) / 60
7818// else
7819// G = M1
7820// h = H - 120
7821// if h < 0 then
7822// h += 360
7823// if h < 60 then
7824// B = ( M1 + ( M2 - M1 ) * h / 60
7825// else if h < 180 then
7826// B = M2
7827// else if h < 240 then
7828// B = M1 + ( M2 - M1 ) * ( 240 - h ) / 60
7829// else
7830// B = M1
7831//
7832// H,L,S,R,G,B are scaled to the range:
7833// [0..1] for the 32f depth,
7834// [0..IPP_MAX_8u] for the 8u depth,
7835// [0..IPP_MAX_16u] for the 16u depth,
7836// [IPP_MIN_16S..IPP_MAX_16s] for the 16s depth.
7837//
7838*/
7839
7840IPPAPI(IppStatus, ippiRGBToHLS_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
7841IPPAPI(IppStatus, ippiHLSToRGB_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
7842IPPAPI(IppStatus, ippiRGBToHLS_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
7843IPPAPI(IppStatus, ippiHLSToRGB_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
7844IPPAPI(IppStatus, ippiRGBToHLS_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
7845IPPAPI(IppStatus, ippiHLSToRGB_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
7846
7847
7848/* /////////////////////////////////////////////////////////////////////////////
7849// Name: ippiRGBToYUV_8u_C3R, ippiYUVToRGB_8u_C3R.ippiRGBToYUV_8u_C3R
7850// ippiRGBToYUV_8u_AC4R, ippiYUVToRGB_8u_AC4R.
7851// ippiRGBToYUV_8u_P3R, ippiYUVToRGB_8u_P3R.
7852// ippiRGBToYUV_8u_C3P3R,ippiYUVToRGB_8u_P3C3R.
7853// Purpose: Converts an RGB image to the YUV color model and vice versa.
7854// Parameters:
7855// pSrc Pointer to the source image (for pixel-order data).An array of pointers
7856// to separate source color planes (for plane-order data)
7857// pDst Pointer to the destination image (for pixel-order data).An array of
7858// pointers to separate destination color planes (for of plane-order data)
7859// roiSize Size of ROI in pixels.
7860// srcStep Step in bytes through the source image to jump on the next line
7861// dstStep Step in bytes through the destination image to jump on the next line
7862// Returns:
7863// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
7864// ippStsStepErr, srcStep or dstStep is less than or equal to zero
7865// ippStsSizeErr roiSize has a field with zero or negative value
7866// ippStsNoErr No errors
7867// Reference:
7868// Jack Keith
7869// Video Demystified: A Handbook for the Digital Engineer, 2nd ed.
7870// 1996.pp.(40-41)
7871//
7872// The YUV color space is the basic color space used by the PAL, NTSC, and
7873// SECAM composite color video standards.
7874//
7875// These functions operate with gamma-corrected images.
7876// The basic equations for conversion between gamma-corrected RGB(R'G'B')and YUV are:
7877//
7878// Y' = 0.299*R' + 0.587*G' + 0.114*B'
7879// U = -0.147*R' - 0.289*G' + 0.436*B' = 0.492*(B' - Y' )
7880// V = 0.615*R' - 0.515*G' - 0.100*B' = 0.877*(R' - Y' )
7881//
7882// R' = Y' + 1.140 * V
7883// G' = Y' - 0.394 * U - 0.581 * V
7884// B' = Y' + 2.032 * U
7885//
7886// For digital RGB values in the range [0 .. 255], Y has a range [0..255],
7887// U a range [-112 .. +112], and V a range [-157..+157].
7888//
7889// These equations are usually scaled to simplify the implementation in an actual
7890// NTSC or PAL digital encoder or decoder.
7891//
7892*/
7893IPPAPI(IppStatus, ippiRGBToYUV_8u_C3R,(const Ipp8u* pSrc, int srcStep , Ipp8u* pDst, int dstStep, IppiSize roiSize))
7894IPPAPI(IppStatus, ippiYUVToRGB_8u_C3R,(const Ipp8u* pSrc, int srcStep , Ipp8u* pDst, int dstStep, IppiSize roiSize))
7895
7896
7897#ifdef __cplusplus
7898}
7899#endif
7900
7901#endif /* __IPPICV_H__ */
7902

source code of opencv/build/3rdparty/ippicv/ippicv_lnx/icv/include/ippicv.h