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