Point Cloud Library (PCL) 1.12.0
Loading...
Searching...
No Matches
NPP_staging.hpp
1/*
2 * Software License Agreement (BSD License)
3 *
4 * Point Cloud Library (PCL) - www.pointclouds.org
5 * Copyright (C) 2009-2010, NVIDIA Corporation, all rights reserved.
6 * Third party copyrights are property of their respective owners.
7 *
8 * All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 *
14 * * Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * * Redistributions in binary form must reproduce the above
17 * copyright notice, this list of conditions and the following
18 * disclaimer in the documentation and/or other materials provided
19 * with the distribution.
20 * * Neither the name of Willow Garage, Inc. nor the names of its
21 * contributors may be used to endorse or promote products derived
22 * from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
27 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
28 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
29 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
30 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
31 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
32 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
34 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 * POSSIBILITY OF SUCH DAMAGE.
36 *
37 * $Id: $
38 * Ported to PCL by Koen Buys : Attention Work in progress!
39 */
40
41#ifndef _npp_staging_hpp_
42#define _npp_staging_hpp_
43
44#include "NCV.hpp"
45
46
47/**
48* \file NPP_staging.hpp
49* NPP Staging Library
50*/
51
52
53/** \defgroup core_npp NPPST Core
54 * Basic functions for CUDA streams management.
55 * @{
56 */
57
58
59/**
60 * Gets an active CUDA stream used by NPPST
61 * NOT THREAD SAFE
62 * \return Current CUDA stream
63 */
64NCV_EXPORTS
66
67
68/**
69 * Sets an active CUDA stream used by NPPST
70 * NOT THREAD SAFE
71 * \param cudaStream [IN] cudaStream CUDA stream to become current
72 * \return CUDA stream used before
73 */
74NCV_EXPORTS
75cudaStream_t nppStSetActiveCUDAstream(cudaStream_t cudaStream);
76
77
78/**@}*/
79
80
81/** \defgroup nppi NPPST Image Processing
82* @{
83*/
84
85
86/** Border type
87 *
88 * Filtering operations assume that each pixel has a neighborhood of pixels.
89 * The following structure describes possible ways to define non-existent pixels.
90 */
92{
93 nppStBorderNone = 0, ///< There is no need to define additional pixels, image is extended already
94 nppStBorderClamp = 1, ///< Clamp out of range position to borders
95 nppStBorderWrap = 2, ///< Wrap out of range position. Image becomes periodic.
96 nppStBorderMirror = 3 ///< reflect out of range position across borders
97};
98
99
100/**
101 * Filter types for image resizing
102 */
104{
105 nppStSupersample, ///< Supersampling. For downscaling only
106 nppStBicubic ///< Bicubic convolution filter, a = -0.5 (cubic Hermite spline)
108
109
110/** Frame interpolation state
111 *
112 * This structure holds parameters required for frame interpolation.
113 * Forward displacement field is a per-pixel mapping from frame 0 to frame 1.
114 * Backward displacement field is a per-pixel mapping from frame 1 to frame 0.
115 */
116
118{
119 NcvSize32u size; ///< frame size
120 Ncv32u nStep; ///< pitch
121 Ncv32f pos; ///< new frame position
122 Ncv32f *pSrcFrame0; ///< frame 0
123 Ncv32f *pSrcFrame1; ///< frame 1
124 Ncv32f *pFU; ///< forward horizontal displacement
125 Ncv32f *pFV; ///< forward vertical displacement
126 Ncv32f *pBU; ///< backward horizontal displacement
127 Ncv32f *pBV; ///< backward vertical displacement
128 Ncv32f *pNewFrame; ///< new frame
129 Ncv32f *ppBuffers[6]; ///< temporary buffers
130};
131
132
133/** Size of a buffer required for interpolation.
134 *
135 * Requires several such buffers. See \see NppStInterpolationState.
136 *
137 * \param srcSize [IN] Frame size (both frames must be of the same size)
138 * \param nStep [IN] Frame line step
139 * \param hpSize [OUT] Where to store computed size (host memory)
140 *
141 * \return NCV status code
142 */
143NCV_EXPORTS
145 Ncv32u nStep,
146 Ncv32u *hpSize);
147
148
149/** Interpolate frames (images) using provided optical flow (displacement field).
150 * 32-bit floating point images, single channel
151 *
152 * \param pState [IN] structure containing all required parameters (host memory)
153 *
154 * \return NCV status code
155 */
156NCV_EXPORTS
158
159
160/** Row linear filter. 32-bit floating point image, single channel
161 *
162 * Apply horizontal linear filter
163 *
164 * \param pSrc [IN] Source image pointer (CUDA device memory)
165 * \param srcSize [IN] Source image size
166 * \param nSrcStep [IN] Source image line step
167 * \param pDst [OUT] Destination image pointer (CUDA device memory)
168 * \param dstSize [OUT] Destination image size
169 * \param nDstStep
170 * \param oROI [IN] Region of interest in the source image
171 * \param borderType [IN] Type of border
172 * \param pKernel [IN] Pointer to row kernel values (CUDA device memory)
173 * \param nKernelSize [IN] Size of the kernel in pixels
174 * \param nAnchor [IN] The kernel row alignment with respect to the position of the input pixel
175 * \param multiplier [IN] Value by which the computed result is multiplied
176 *
177 * \return NCV status code
178 */
179NCV_EXPORTS
180NCVStatus nppiStFilterRowBorder_32f_C1R(const Ncv32f *pSrc,
181 NcvSize32u srcSize,
182 Ncv32u nSrcStep,
183 Ncv32f *pDst,
184 NcvSize32u dstSize,
185 Ncv32u nDstStep,
186 NcvRect32u oROI,
187 NppStBorderType borderType,
188 const Ncv32f *pKernel,
189 Ncv32s nKernelSize,
190 Ncv32s nAnchor,
191 Ncv32f multiplier);
192
193
194/** Column linear filter. 32-bit floating point image, single channel
195 *
196 * Apply vertical linear filter
197 *
198 * \param pSrc [IN] Source image pointer (CUDA device memory)
199 * \param srcSize [IN] Source image size
200 * \param nSrcStep [IN] Source image line step
201 * \param pDst [OUT] Destination image pointer (CUDA device memory)
202 * \param dstSize [OUT] Destination image size
203 * \param nDstStep
204 * \param oROI [IN] Region of interest in the source image
205 * \param borderType [IN] Type of border
206 * \param pKernel [IN] Pointer to column kernel values (CUDA device memory)
207 * \param nKernelSize [IN] Size of the kernel in pixels
208 * \param nAnchor [IN] The kernel column alignment with respect to the position of the input pixel
209 * \param multiplier [IN] Value by which the computed result is multiplied
210 *
211 * \return NCV status code
212 */
213NCV_EXPORTS
214NCVStatus nppiStFilterColumnBorder_32f_C1R(const Ncv32f *pSrc,
215 NcvSize32u srcSize,
216 Ncv32u nSrcStep,
217 Ncv32f *pDst,
218 NcvSize32u dstSize,
219 Ncv32u nDstStep,
220 NcvRect32u oROI,
221 NppStBorderType borderType,
222 const Ncv32f *pKernel,
223 Ncv32s nKernelSize,
224 Ncv32s nAnchor,
225 Ncv32f multiplier);
226
227
228/** Size of buffer required for vector image warping.
229 *
230 * \param srcSize [IN] Source image size
231 * \param nSrcStep [IN] Source image line step
232 * \param hpSize [OUT] Where to store computed size (host memory)
233 *
234 * \return NCV status code
235 */
236NCV_EXPORTS
238 Ncv32u nSrcStep,
239 Ncv32u *hpSize);
240
241
242/** Warp image using provided 2D vector field and 1x1 point spread function.
243 * 32-bit floating point image, single channel
244 *
245 * During warping pixels from the source image may fall between pixels of the destination image.
246 * PSF (point spread function) describes how the source image pixel affects pixels of the destination.
247 * For 1x1 PSF only single pixel with the largest intersection is affected (similar to nearest interpolation).
248 *
249 * Destination image size and line step must be the same as the source image size and line step
250 *
251 * \param pSrc [IN] Source image pointer (CUDA device memory)
252 * \param srcSize [IN] Source image size
253 * \param nSrcStep [IN] Source image line step
254 * \param pU [IN] Pointer to horizontal displacement field (CUDA device memory)
255 * \param pV [IN] Pointer to vertical displacement field (CUDA device memory)
256 * \param nVFStep [IN] Displacement field line step
257 * \param timeScale [IN] Value by which displacement field will be scaled for warping
258 * \param pDst [OUT] Destination image pointer (CUDA device memory)
259 *
260 * \return NCV status code
261 */
262NCV_EXPORTS
263NCVStatus nppiStVectorWarp_PSF1x1_32f_C1(const Ncv32f *pSrc,
264 NcvSize32u srcSize,
265 Ncv32u nSrcStep,
266 const Ncv32f *pU,
267 const Ncv32f *pV,
268 Ncv32u nVFStep,
269 Ncv32f timeScale,
270 Ncv32f *pDst);
271
272
273/** Warp image using provided 2D vector field and 2x2 point spread function.
274 * 32-bit floating point image, single channel
275 *
276 * During warping pixels from the source image may fall between pixels of the destination image.
277 * PSF (point spread function) describes how the source image pixel affects pixels of the destination.
278 * For 2x2 PSF all four intersected pixels will be affected.
279 *
280 * Destination image size and line step must be the same as the source image size and line step
281 *
282 * \param pSrc [IN] Source image pointer (CUDA device memory)
283 * \param srcSize [IN] Source image size
284 * \param nSrcStep [IN] Source image line step
285 * \param pU [IN] Pointer to horizontal displacement field (CUDA device memory)
286 * \param pV [IN] Pointer to vertical displacement field (CUDA device memory)
287 * \param nVFStep [IN] Displacement field line step
288 * \param pBuffer
289 * \param timeScale [IN] Value by which displacement field will be scaled for warping
290 * \param pDst [OUT] Destination image pointer (CUDA device memory)
291 *
292 * \return NCV status code
293 */
294NCV_EXPORTS
295NCVStatus nppiStVectorWarp_PSF2x2_32f_C1(const Ncv32f *pSrc,
296 NcvSize32u srcSize,
297 Ncv32u nSrcStep,
298 const Ncv32f *pU,
299 const Ncv32f *pV,
300 Ncv32u nVFStep,
301 Ncv32f *pBuffer,
302 Ncv32f timeScale,
303 Ncv32f *pDst);
304
305
306/** Resize. 32-bit floating point image, single channel
307 *
308 * Resizes image using specified filter (interpolation type)
309 *
310 * \param pSrc [IN] Source image pointer (CUDA device memory)
311 * \param srcSize [IN] Source image size
312 * \param nSrcStep [IN] Source image line step
313 * \param srcROI [IN] Source image region of interest
314 * \param pDst [OUT] Destination image pointer (CUDA device memory)
315 * \param dstSize [IN] Destination image size
316 * \param nDstStep [IN] Destination image line step
317 * \param dstROI [IN] Destination image region of interest
318 * \param xFactor [IN] Row scale factor
319 * \param yFactor [IN] Column scale factor
320 * \param interpolation [IN] Interpolation type
321 *
322 * \return NCV status code
323 */
324NCV_EXPORTS
325NCVStatus nppiStResize_32f_C1R(const Ncv32f *pSrc,
326 NcvSize32u srcSize,
327 Ncv32u nSrcStep,
328 NcvRect32u srcROI,
329 Ncv32f *pDst,
330 NcvSize32u dstSize,
331 Ncv32u nDstStep,
332 NcvRect32u dstROI,
333 Ncv32f xFactor,
334 Ncv32f yFactor,
335 NppStInterpMode interpolation);
336
337
338/**
339 * Downsamples (decimates) an image using the nearest neighbor algorithm. 32-bit unsigned pixels, single channel.
340 *
341 * \param d_src [IN] Source image pointer (CUDA device memory)
342 * \param srcStep [IN] Source image line step
343 * \param d_dst [OUT] Destination image pointer (CUDA device memory)
344 * \param dstStep [IN] Destination image line step
345 * \param srcRoi [IN] Region of interest in the source image
346 * \param scale [IN] Downsampling scale factor (positive integer)
347 * \param readThruTexture [IN] Performance hint to cache source in texture (true) or read directly (false)
348 *
349 * \return NCV status code
350 */
351NCV_EXPORTS
352NCVStatus nppiStDecimate_32u_C1R(Ncv32u *d_src, Ncv32u srcStep,
353 Ncv32u *d_dst, Ncv32u dstStep,
354 NcvSize32u srcRoi, Ncv32u scale,
355 NcvBool readThruTexture);
356
357
358/**
359 * Downsamples (decimates) an image using the nearest neighbor algorithm. 32-bit signed pixels, single channel.
360 * \see nppiStDecimate_32u_C1R
361 */
362NCV_EXPORTS
363NCVStatus nppiStDecimate_32s_C1R(Ncv32s *d_src, Ncv32u srcStep,
364 Ncv32s *d_dst, Ncv32u dstStep,
365 NcvSize32u srcRoi, Ncv32u scale,
366 NcvBool readThruTexture);
367
368
369/**
370 * Downsamples (decimates) an image using the nearest neighbor algorithm. 32-bit float pixels, single channel.
371 * \see nppiStDecimate_32u_C1R
372 */
373NCV_EXPORTS
374NCVStatus nppiStDecimate_32f_C1R(Ncv32f *d_src, Ncv32u srcStep,
375 Ncv32f *d_dst, Ncv32u dstStep,
376 NcvSize32u srcRoi, Ncv32u scale,
377 NcvBool readThruTexture);
378
379
380/**
381* Downsamples (decimates) an image using the nearest neighbor algorithm. 64-bit unsigned pixels, single channel.
382* \see nppiStDecimate_32u_C1R
383*/
384NCV_EXPORTS
385NCVStatus nppiStDecimate_64u_C1R(Ncv64u *d_src, Ncv32u srcStep,
386 Ncv64u *d_dst, Ncv32u dstStep,
387 NcvSize32u srcRoi, Ncv32u scale,
388 NcvBool readThruTexture);
389
390
391/**
392 * Downsamples (decimates) an image using the nearest neighbor algorithm. 64-bit signed pixels, single channel.
393 * \see nppiStDecimate_32u_C1R
394 */
395NCV_EXPORTS
396NCVStatus nppiStDecimate_64s_C1R(Ncv64s *d_src, Ncv32u srcStep,
397 Ncv64s *d_dst, Ncv32u dstStep,
398 NcvSize32u srcRoi, Ncv32u scale,
399 NcvBool readThruTexture);
400
401
402/**
403 * Downsamples (decimates) an image using the nearest neighbor algorithm. 64-bit float pixels, single channel.
404 * \see nppiStDecimate_32u_C1R
405 */
406NCV_EXPORTS
407NCVStatus nppiStDecimate_64f_C1R(Ncv64f *d_src, Ncv32u srcStep,
408 Ncv64f *d_dst, Ncv32u dstStep,
409 NcvSize32u srcRoi, Ncv32u scale,
410 NcvBool readThruTexture);
411
412
413/**
414 * Downsamples (decimates) an image using the nearest neighbor algorithm. 32-bit unsigned pixels, single channel. Host implementation.
415 *
416 * \param h_src [IN] Source image pointer (Host or pinned memory)
417 * \param srcStep [IN] Source image line step
418 * \param h_dst [OUT] Destination image pointer (Host or pinned memory)
419 * \param dstStep [IN] Destination image line step
420 * \param srcRoi [IN] Region of interest in the source image
421 * \param scale [IN] Downsampling scale factor (positive integer)
422 *
423 * \return NCV status code
424 */
425NCV_EXPORTS
426NCVStatus nppiStDecimate_32u_C1R_host(Ncv32u *h_src, Ncv32u srcStep,
427 Ncv32u *h_dst, Ncv32u dstStep,
428 NcvSize32u srcRoi, Ncv32u scale);
429
430
431/**
432 * Downsamples (decimates) an image using the nearest neighbor algorithm. 32-bit signed pixels, single channel. Host implementation.
433 * \see nppiStDecimate_32u_C1R_host
434 */
435NCV_EXPORTS
436NCVStatus nppiStDecimate_32s_C1R_host(Ncv32s *h_src, Ncv32u srcStep,
437 Ncv32s *h_dst, Ncv32u dstStep,
438 NcvSize32u srcRoi, Ncv32u scale);
439
440
441/**
442 * Downsamples (decimates) an image using the nearest neighbor algorithm. 32-bit float pixels, single channel. Host implementation.
443 * \see nppiStDecimate_32u_C1R_host
444 */
445NCV_EXPORTS
446NCVStatus nppiStDecimate_32f_C1R_host(Ncv32f *h_src, Ncv32u srcStep,
447 Ncv32f *h_dst, Ncv32u dstStep,
448 NcvSize32u srcRoi, Ncv32u scale);
449
450
451/**
452 * Downsamples (decimates) an image using the nearest neighbor algorithm. 64-bit unsigned pixels, single channel. Host implementation.
453 * \see nppiStDecimate_32u_C1R_host
454 */
455NCV_EXPORTS
456NCVStatus nppiStDecimate_64u_C1R_host(Ncv64u *h_src, Ncv32u srcStep,
457 Ncv64u *h_dst, Ncv32u dstStep,
458 NcvSize32u srcRoi, Ncv32u scale);
459
460
461/**
462 * Downsamples (decimates) an image using the nearest neighbor algorithm. 64-bit signed pixels, single channel. Host implementation.
463 * \see nppiStDecimate_32u_C1R_host
464 */
465NCV_EXPORTS
466NCVStatus nppiStDecimate_64s_C1R_host(Ncv64s *h_src, Ncv32u srcStep,
467 Ncv64s *h_dst, Ncv32u dstStep,
468 NcvSize32u srcRoi, Ncv32u scale);
469
470
471/**
472 * Downsamples (decimates) an image using the nearest neighbor algorithm. 64-bit float pixels, single channel. Host implementation.
473 * \see nppiStDecimate_32u_C1R_host
474 */
475NCV_EXPORTS
476NCVStatus nppiStDecimate_64f_C1R_host(Ncv64f *h_src, Ncv32u srcStep,
477 Ncv64f *h_dst, Ncv32u dstStep,
478 NcvSize32u srcRoi, Ncv32u scale);
479
480
481/**
482 * Computes standard deviation for each rectangular region of the input image using integral images.
483 *
484 * \param d_sum [IN] Integral image pointer (CUDA device memory)
485 * \param sumStep [IN] Integral image line step
486 * \param d_sqsum [IN] Squared integral image pointer (CUDA device memory)
487 * \param sqsumStep [IN] Squared integral image line step
488 * \param d_norm [OUT] Stddev image pointer (CUDA device memory). Each pixel contains stddev of a rect with top-left corner at the original location in the image
489 * \param normStep [IN] Stddev image line step
490 * \param roi [IN] Region of interest in the source image
491 * \param rect [IN] Rectangular region to calculate stddev over
492 * \param scaleArea [IN] Multiplication factor to account decimated scale
493 * \param readThruTexture [IN] Performance hint to cache source in texture (true) or read directly (false)
494 *
495 * \return NCV status code
496 */
497NCV_EXPORTS
498NCVStatus nppiStRectStdDev_32f_C1R(Ncv32u *d_sum, Ncv32u sumStep,
499 Ncv64u *d_sqsum, Ncv32u sqsumStep,
500 Ncv32f *d_norm, Ncv32u normStep,
501 NcvSize32u roi, NcvRect32u rect,
502 Ncv32f scaleArea, NcvBool readThruTexture);
503
504
505/**
506 * Computes standard deviation for each rectangular region of the input image using integral images. Host implementation
507 *
508 * \param h_sum [IN] Integral image pointer (Host or pinned memory)
509 * \param sumStep [IN] Integral image line step
510 * \param h_sqsum [IN] Squared integral image pointer (Host or pinned memory)
511 * \param sqsumStep [IN] Squared integral image line step
512 * \param h_norm [OUT] Stddev image pointer (Host or pinned memory). Each pixel contains stddev of a rect with top-left corner at the original location in the image
513 * \param normStep [IN] Stddev image line step
514 * \param roi [IN] Region of interest in the source image
515 * \param rect [IN] Rectangular region to calculate stddev over
516 * \param scaleArea [IN] Multiplication factor to account decimated scale
517 *
518 * \return NCV status code
519 */
520NCV_EXPORTS
521NCVStatus nppiStRectStdDev_32f_C1R_host(Ncv32u *h_sum, Ncv32u sumStep,
522 Ncv64u *h_sqsum, Ncv32u sqsumStep,
523 Ncv32f *h_norm, Ncv32u normStep,
524 NcvSize32u roi, NcvRect32u rect,
525 Ncv32f scaleArea);
526
527
528/**
529 * Transposes an image. 32-bit unsigned pixels, single channel
530 *
531 * \param d_src [IN] Source image pointer (CUDA device memory)
532 * \param srcStride [IN] Source image line step
533 * \param d_dst [OUT] Destination image pointer (CUDA device memory)
534 * \param dstStride [IN] Destination image line step
535 * \param srcRoi [IN] Region of interest of the source image
536 *
537 * \return NCV status code
538 */
539NCV_EXPORTS
540NCVStatus nppiStTranspose_32u_C1R(Ncv32u *d_src, Ncv32u srcStride,
541 Ncv32u *d_dst, Ncv32u dstStride, NcvSize32u srcRoi);
542
543
544/**
545 * Transposes an image. 32-bit signed pixels, single channel
546 * \see nppiStTranspose_32u_C1R
547 */
548NCV_EXPORTS
549NCVStatus nppiStTranspose_32s_C1R(Ncv32s *d_src, Ncv32u srcStride,
550 Ncv32s *d_dst, Ncv32u dstStride, NcvSize32u srcRoi);
551
552
553/**
554 * Transposes an image. 32-bit float pixels, single channel
555 * \see nppiStTranspose_32u_C1R
556 */
557NCV_EXPORTS
558NCVStatus nppiStTranspose_32f_C1R(Ncv32f *d_src, Ncv32u srcStride,
559 Ncv32f *d_dst, Ncv32u dstStride, NcvSize32u srcRoi);
560
561
562/**
563 * Transposes an image. 64-bit unsigned pixels, single channel
564 * \see nppiStTranspose_32u_C1R
565 */
566NCV_EXPORTS
567NCVStatus nppiStTranspose_64u_C1R(Ncv64u *d_src, Ncv32u srcStride,
568 Ncv64u *d_dst, Ncv32u dstStride, NcvSize32u srcRoi);
569
570
571/**
572 * Transposes an image. 64-bit signed pixels, single channel
573 * \see nppiStTranspose_32u_C1R
574 */
575NCV_EXPORTS
576NCVStatus nppiStTranspose_64s_C1R(Ncv64s *d_src, Ncv32u srcStride,
577 Ncv64s *d_dst, Ncv32u dstStride, NcvSize32u srcRoi);
578
579
580/**
581 * Transposes an image. 64-bit float pixels, single channel
582 * \see nppiStTranspose_32u_C1R
583 */
584NCV_EXPORTS
585NCVStatus nppiStTranspose_64f_C1R(Ncv64f *d_src, Ncv32u srcStride,
586 Ncv64f *d_dst, Ncv32u dstStride, NcvSize32u srcRoi);
587
588
589/**
590 * Transposes an image. 128-bit pixels of any type, single channel
591 * \see nppiStTranspose_32u_C1R
592 */
593NCV_EXPORTS
594NCVStatus nppiStTranspose_128_C1R(void *d_src, Ncv32u srcStep,
595 void *d_dst, Ncv32u dstStep, NcvSize32u srcRoi);
596
597
598/**
599 * Transposes an image. 32-bit unsigned pixels, single channel. Host implementation
600 *
601 * \param h_src [IN] Source image pointer (Host or pinned memory)
602 * \param srcStride [IN] Source image line step
603 * \param h_dst [OUT] Destination image pointer (Host or pinned memory)
604 * \param dstStride [IN] Destination image line step
605 * \param srcRoi [IN] Region of interest of the source image
606 *
607 * \return NCV status code
608 */
609NCV_EXPORTS
610NCVStatus nppiStTranspose_32u_C1R_host(Ncv32u *h_src, Ncv32u srcStride,
611 Ncv32u *h_dst, Ncv32u dstStride, NcvSize32u srcRoi);
612
613
614/**
615 * Transposes an image. 32-bit signed pixels, single channel. Host implementation
616 * \see nppiStTranspose_32u_C1R_host
617 */
618NCV_EXPORTS
619NCVStatus nppiStTranspose_32s_C1R_host(Ncv32s *h_src, Ncv32u srcStride,
620 Ncv32s *h_dst, Ncv32u dstStride, NcvSize32u srcRoi);
621
622
623/**
624 * Transposes an image. 32-bit float pixels, single channel. Host implementation
625 * \see nppiStTranspose_32u_C1R_host
626 */
627NCV_EXPORTS
628NCVStatus nppiStTranspose_32f_C1R_host(Ncv32f *h_src, Ncv32u srcStride,
629 Ncv32f *h_dst, Ncv32u dstStride, NcvSize32u srcRoi);
630
631
632/**
633 * Transposes an image. 64-bit unsigned pixels, single channel. Host implementation
634 * \see nppiStTranspose_32u_C1R_host
635 */
636NCV_EXPORTS
637NCVStatus nppiStTranspose_64u_C1R_host(Ncv64u *h_src, Ncv32u srcStride,
638 Ncv64u *h_dst, Ncv32u dstStride, NcvSize32u srcRoi);
639
640
641/**
642 * Transposes an image. 64-bit signed pixels, single channel. Host implementation
643 * \see nppiStTranspose_32u_C1R_host
644 */
645NCV_EXPORTS
646NCVStatus nppiStTranspose_64s_C1R_host(Ncv64s *h_src, Ncv32u srcStride,
647 Ncv64s *h_dst, Ncv32u dstStride, NcvSize32u srcRoi);
648
649
650/**
651 * Transposes an image. 64-bit float pixels, single channel. Host implementation
652 * \see nppiStTranspose_32u_C1R_host
653 */
654NCV_EXPORTS
655NCVStatus nppiStTranspose_64f_C1R_host(Ncv64f *h_src, Ncv32u srcStride,
656 Ncv64f *h_dst, Ncv32u dstStride, NcvSize32u srcRoi);
657
658
659/**
660 * Transposes an image. 128-bit pixels of any type, single channel. Host implementation
661 * \see nppiStTranspose_32u_C1R_host
662 */
663NCV_EXPORTS
664NCVStatus nppiStTranspose_128_C1R_host(void *d_src, Ncv32u srcStep,
665 void *d_dst, Ncv32u dstStep, NcvSize32u srcRoi);
666
667
668/**
669 * Calculates the size of the temporary buffer for integral image creation
670 *
671 * \param roiSize [IN] Size of the input image
672 * \param pBufsize [OUT] Pointer to host variable that returns the size of the temporary buffer (in bytes)
673 * \param devProp [IN] CUDA device properties structure, containing texture alignment information
674 *
675 * \return NCV status code
676 */
677NCV_EXPORTS
678NCVStatus nppiStIntegralGetSize_8u32u(NcvSize32u roiSize, Ncv32u *pBufsize, cudaDeviceProp &devProp);
679
680
681/**
682 * Calculates the size of the temporary buffer for integral image creation
683 * \see nppiStIntegralGetSize_8u32u
684 */
685NCV_EXPORTS
686NCVStatus nppiStIntegralGetSize_32f32f(NcvSize32u roiSize, Ncv32u *pBufsize, cudaDeviceProp &devProp);
687
688
689/**
690 * Creates an integral image representation for the input image
691 *
692 * \param d_src [IN] Source image pointer (CUDA device memory)
693 * \param srcStep [IN] Source image line step
694 * \param d_dst [OUT] Destination integral image pointer (CUDA device memory)
695 * \param dstStep [IN] Destination image line step
696 * \param roiSize [IN] Region of interest of the source image
697 * \param pBuffer [IN] Pointer to the pre-allocated temporary buffer (CUDA device memory)
698 * \param bufSize [IN] Size of the pBuffer in bytes
699 * \param devProp [IN] CUDA device properties structure, containing texture alignment information
700 *
701 * \return NCV status code
702 */
703NCV_EXPORTS
704NCVStatus nppiStIntegral_8u32u_C1R(Ncv8u *d_src, Ncv32u srcStep,
705 Ncv32u *d_dst, Ncv32u dstStep, NcvSize32u roiSize,
706 Ncv8u *pBuffer, Ncv32u bufSize, cudaDeviceProp &devProp);
707
708
709/**
710 * Creates an integral image representation for the input image
711 * \see nppiStIntegral_8u32u_C1R
712 */
713NCV_EXPORTS
714NCVStatus nppiStIntegral_32f32f_C1R(Ncv32f *d_src, Ncv32u srcStep,
715 Ncv32f *d_dst, Ncv32u dstStep, NcvSize32u roiSize,
716 Ncv8u *pBuffer, Ncv32u bufSize, cudaDeviceProp &devProp);
717
718
719/**
720 * Creates an integral image representation for the input image. Host implementation
721 *
722 * \param h_src [IN] Source image pointer (Host or pinned memory)
723 * \param srcStep [IN] Source image line step
724 * \param h_dst [OUT] Destination integral image pointer (Host or pinned memory)
725 * \param dstStep [IN] Destination image line step
726 * \param roiSize [IN] Region of interest of the source image
727 *
728 * \return NCV status code
729 */
730NCV_EXPORTS
731NCVStatus nppiStIntegral_8u32u_C1R_host(Ncv8u *h_src, Ncv32u srcStep,
732 Ncv32u *h_dst, Ncv32u dstStep, NcvSize32u roiSize);
733
734
735/**
736 * Creates an integral image representation for the input image. Host implementation
737 * \see nppiStIntegral_8u32u_C1R_host
738 */
739NCV_EXPORTS
740NCVStatus nppiStIntegral_32f32f_C1R_host(Ncv32f *h_src, Ncv32u srcStep,
741 Ncv32f *h_dst, Ncv32u dstStep, NcvSize32u roiSize);
742
743
744/**
745 * Calculates the size of the temporary buffer for squared integral image creation
746 *
747 * \param roiSize [IN] Size of the input image
748 * \param pBufsize [OUT] Pointer to host variable that returns the size of the temporary buffer (in bytes)
749 * \param devProp [IN] CUDA device properties structure, containing texture alignment information
750 *
751 * \return NCV status code
752 */
753NCV_EXPORTS
754NCVStatus nppiStSqrIntegralGetSize_8u64u(NcvSize32u roiSize, Ncv32u *pBufsize, cudaDeviceProp &devProp);
755
756
757/**
758 * Creates a squared integral image representation for the input image
759 *
760 * \param d_src [IN] Source image pointer (CUDA device memory)
761 * \param srcStep [IN] Source image line step
762 * \param d_dst [OUT] Destination squared integral image pointer (CUDA device memory)
763 * \param dstStep [IN] Destination image line step
764 * \param roiSize [IN] Region of interest of the source image
765 * \param pBuffer [IN] Pointer to the pre-allocated temporary buffer (CUDA device memory)
766 * \param bufSize [IN] Size of the pBuffer in bytes
767 * \param devProp [IN] CUDA device properties structure, containing texture alignment information
768 *
769 * \return NCV status code
770 */
771NCV_EXPORTS
772NCVStatus nppiStSqrIntegral_8u64u_C1R(Ncv8u *d_src, Ncv32u srcStep,
773 Ncv64u *d_dst, Ncv32u dstStep, NcvSize32u roiSize,
774 Ncv8u *pBuffer, Ncv32u bufSize, cudaDeviceProp &devProp);
775
776
777/**
778 * Creates a squared integral image representation for the input image. Host implementation
779 *
780 * \param h_src [IN] Source image pointer (Host or pinned memory)
781 * \param srcStep [IN] Source image line step
782 * \param h_dst [OUT] Destination squared integral image pointer (Host or pinned memory)
783 * \param dstStep [IN] Destination image line step
784 * \param roiSize [IN] Region of interest of the source image
785 *
786 * \return NCV status code
787 */
788NCV_EXPORTS
789NCVStatus nppiStSqrIntegral_8u64u_C1R_host(Ncv8u *h_src, Ncv32u srcStep,
790 Ncv64u *h_dst, Ncv32u dstStep, NcvSize32u roiSize);
791
792
793/**@}*/
794
795
796/** \defgroup npps NPPST Signal Processing
797* @{
798*/
799
800
801/**
802 * Calculates the size of the temporary buffer for vector compaction. 32-bit unsigned values
803 *
804 * \param srcLen [IN] Length of the input vector in elements
805 * \param pBufsize [OUT] Pointer to host variable that returns the size of the temporary buffer (in bytes)
806 * \param devProp [IN] CUDA device properties structure, containing texture alignment information
807 *
808 * \return NCV status code
809 */
810NCV_EXPORTS
811NCVStatus nppsStCompactGetSize_32u(Ncv32u srcLen, Ncv32u *pBufsize, cudaDeviceProp &devProp);
812
813
814/**
815 * Calculates the size of the temporary buffer for vector compaction. 32-bit signed values
816 * \see nppsStCompactGetSize_32u
817 */
818NCVStatus nppsStCompactGetSize_32s(Ncv32u srcLen, Ncv32u *pBufsize, cudaDeviceProp &devProp);
819
820
821/**
822 * Calculates the size of the temporary buffer for vector compaction. 32-bit float values
823 * \see nppsStCompactGetSize_32u
824 */
825NCVStatus nppsStCompactGetSize_32f(Ncv32u srcLen, Ncv32u *pBufsize, cudaDeviceProp &devProp);
826
827
828/**
829 * Compacts the input vector by removing elements of specified value. 32-bit unsigned values
830 *
831 * \param d_src [IN] Source vector pointer (CUDA device memory)
832 * \param srcLen [IN] Source vector length
833 * \param d_dst [OUT] Destination vector pointer (CUDA device memory)
834 * \param p_dstLen [OUT] Pointer to the destination vector length (Pinned memory or NULL)
835 * \param elemRemove [IN] The value to be removed
836 * \param pBuffer [IN] Pointer to the pre-allocated temporary buffer (CUDA device memory)
837 * \param bufSize [IN] Size of the pBuffer in bytes
838 * \param devProp [IN] CUDA device properties structure, containing texture alignment information
839 *
840 * \return NCV status code
841 */
842NCV_EXPORTS
843NCVStatus nppsStCompact_32u(Ncv32u *d_src, Ncv32u srcLen,
844 Ncv32u *d_dst, Ncv32u *p_dstLen,
845 Ncv32u elemRemove, Ncv8u *pBuffer,
846 Ncv32u bufSize, cudaDeviceProp &devProp);
847
848
849/**
850 * Compacts the input vector by removing elements of specified value. 32-bit signed values
851 * \see nppsStCompact_32u
852 */
853NCV_EXPORTS
854NCVStatus nppsStCompact_32s(Ncv32s *d_src, Ncv32u srcLen,
855 Ncv32s *d_dst, Ncv32u *p_dstLen,
856 Ncv32s elemRemove, Ncv8u *pBuffer,
857 Ncv32u bufSize, cudaDeviceProp &devProp);
858
859
860/**
861 * Compacts the input vector by removing elements of specified value. 32-bit float values
862 * \see nppsStCompact_32u
863 */
864NCV_EXPORTS
865NCVStatus nppsStCompact_32f(Ncv32f *d_src, Ncv32u srcLen,
866 Ncv32f *d_dst, Ncv32u *p_dstLen,
867 Ncv32f elemRemove, Ncv8u *pBuffer,
868 Ncv32u bufSize, cudaDeviceProp &devProp);
869
870
871/**
872 * Compacts the input vector by removing elements of specified value. 32-bit unsigned values. Host implementation
873 *
874 * \param h_src [IN] Source vector pointer (CUDA device memory)
875 * \param srcLen [IN] Source vector length
876 * \param h_dst [OUT] Destination vector pointer (CUDA device memory)
877 * \param dstLen [OUT] Pointer to the destination vector length (can be NULL)
878 * \param elemRemove [IN] The value to be removed
879 *
880 * \return NCV status code
881 */
882NCV_EXPORTS
883NCVStatus nppsStCompact_32u_host(Ncv32u *h_src, Ncv32u srcLen,
884 Ncv32u *h_dst, Ncv32u *dstLen, Ncv32u elemRemove);
885
886
887/**
888 * Compacts the input vector by removing elements of specified value. 32-bit signed values. Host implementation
889 * \see nppsStCompact_32u_host
890 */
891NCV_EXPORTS
892NCVStatus nppsStCompact_32s_host(Ncv32s *h_src, Ncv32u srcLen,
893 Ncv32s *h_dst, Ncv32u *dstLen, Ncv32s elemRemove);
894
895
896/**
897 * Compacts the input vector by removing elements of specified value. 32-bit float values. Host implementation
898 * \see nppsStCompact_32u_host
899 */
900NCV_EXPORTS
901NCVStatus nppsStCompact_32f_host(Ncv32f *h_src, Ncv32u srcLen,
902 Ncv32f *h_dst, Ncv32u *dstLen, Ncv32f elemRemove);
903
904
905/**@}*/
906
907
908#endif // _npp_staging_hpp_
NCV_EXPORTS cudaStream_t nppStSetActiveCUDAstream(cudaStream_t cudaStream)
Sets an active CUDA stream used by NPPST NOT THREAD SAFE.
NCV_EXPORTS cudaStream_t nppStGetActiveCUDAstream()
Gets an active CUDA stream used by NPPST NOT THREAD SAFE.
NCV_EXPORTS NCVStatus nppiStFilterRowBorder_32f_C1R(const Ncv32f *pSrc, NcvSize32u srcSize, Ncv32u nSrcStep, Ncv32f *pDst, NcvSize32u dstSize, Ncv32u nDstStep, NcvRect32u oROI, NppStBorderType borderType, const Ncv32f *pKernel, Ncv32s nKernelSize, Ncv32s nAnchor, Ncv32f multiplier)
Row linear filter.
NCV_EXPORTS NCVStatus nppiStDecimate_32s_C1R_host(Ncv32s *h_src, Ncv32u srcStep, Ncv32s *h_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStSqrIntegral_8u64u_C1R_host(Ncv8u *h_src, Ncv32u srcStep, Ncv64u *h_dst, Ncv32u dstStep, NcvSize32u roiSize)
Creates a squared integral image representation for the input image.
NCV_EXPORTS NCVStatus nppiStTranspose_64f_C1R(Ncv64f *d_src, Ncv32u srcStride, Ncv64f *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStIntegralGetSize_32f32f(NcvSize32u roiSize, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for integral image creation.
NCV_EXPORTS NCVStatus nppiStTranspose_32u_C1R_host(Ncv32u *h_src, Ncv32u srcStride, Ncv32u *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NppStInterpMode
Filter types for image resizing.
NCV_EXPORTS NCVStatus nppiStDecimate_32u_C1R(Ncv32u *d_src, Ncv32u srcStep, Ncv32u *d_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale, NcvBool readThruTexture)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStTranspose_64u_C1R(Ncv64u *d_src, Ncv32u srcStride, Ncv64u *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStTranspose_32u_C1R(Ncv32u *d_src, Ncv32u srcStride, Ncv32u *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStIntegral_32f32f_C1R(Ncv32f *d_src, Ncv32u srcStep, Ncv32f *d_dst, Ncv32u dstStep, NcvSize32u roiSize, Ncv8u *pBuffer, Ncv32u bufSize, cudaDeviceProp &devProp)
Creates an integral image representation for the input image.
NCV_EXPORTS NCVStatus nppiStTranspose_64s_C1R_host(Ncv64s *h_src, Ncv32u srcStride, Ncv64s *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStTranspose_32s_C1R_host(Ncv32s *h_src, Ncv32u srcStride, Ncv32s *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStVectorWarp_PSF1x1_32f_C1(const Ncv32f *pSrc, NcvSize32u srcSize, Ncv32u nSrcStep, const Ncv32f *pU, const Ncv32f *pV, Ncv32u nVFStep, Ncv32f timeScale, Ncv32f *pDst)
Warp image using provided 2D vector field and 1x1 point spread function.
NCV_EXPORTS NCVStatus nppiStSqrIntegralGetSize_8u64u(NcvSize32u roiSize, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for squared integral image creation.
NCV_EXPORTS NCVStatus nppiStVectorWarpGetBufferSize(NcvSize32u srcSize, Ncv32u nSrcStep, Ncv32u *hpSize)
Size of buffer required for vector image warping.
NCV_EXPORTS NCVStatus nppiStTranspose_64f_C1R_host(Ncv64f *h_src, Ncv32u srcStride, Ncv64f *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStResize_32f_C1R(const Ncv32f *pSrc, NcvSize32u srcSize, Ncv32u nSrcStep, NcvRect32u srcROI, Ncv32f *pDst, NcvSize32u dstSize, Ncv32u nDstStep, NcvRect32u dstROI, Ncv32f xFactor, Ncv32f yFactor, NppStInterpMode interpolation)
Resize.
NCV_EXPORTS NCVStatus nppiStDecimate_64s_C1R_host(Ncv64s *h_src, Ncv32u srcStep, Ncv64s *h_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStRectStdDev_32f_C1R_host(Ncv32u *h_sum, Ncv32u sumStep, Ncv64u *h_sqsum, Ncv32u sqsumStep, Ncv32f *h_norm, Ncv32u normStep, NcvSize32u roi, NcvRect32u rect, Ncv32f scaleArea)
Computes standard deviation for each rectangular region of the input image using integral images.
NCV_EXPORTS NCVStatus nppiStDecimate_32s_C1R(Ncv32s *d_src, Ncv32u srcStep, Ncv32s *d_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale, NcvBool readThruTexture)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStTranspose_128_C1R_host(void *d_src, Ncv32u srcStep, void *d_dst, Ncv32u dstStep, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStIntegral_8u32u_C1R(Ncv8u *d_src, Ncv32u srcStep, Ncv32u *d_dst, Ncv32u dstStep, NcvSize32u roiSize, Ncv8u *pBuffer, Ncv32u bufSize, cudaDeviceProp &devProp)
Creates an integral image representation for the input image.
NCV_EXPORTS NCVStatus nppiStTranspose_128_C1R(void *d_src, Ncv32u srcStep, void *d_dst, Ncv32u dstStep, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStVectorWarp_PSF2x2_32f_C1(const Ncv32f *pSrc, NcvSize32u srcSize, Ncv32u nSrcStep, const Ncv32f *pU, const Ncv32f *pV, Ncv32u nVFStep, Ncv32f *pBuffer, Ncv32f timeScale, Ncv32f *pDst)
Warp image using provided 2D vector field and 2x2 point spread function.
NCV_EXPORTS NCVStatus nppiStTranspose_32s_C1R(Ncv32s *d_src, Ncv32u srcStride, Ncv32s *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStTranspose_32f_C1R_host(Ncv32f *h_src, Ncv32u srcStride, Ncv32f *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStRectStdDev_32f_C1R(Ncv32u *d_sum, Ncv32u sumStep, Ncv64u *d_sqsum, Ncv32u sqsumStep, Ncv32f *d_norm, Ncv32u normStep, NcvSize32u roi, NcvRect32u rect, Ncv32f scaleArea, NcvBool readThruTexture)
Computes standard deviation for each rectangular region of the input image using integral images.
NCV_EXPORTS NCVStatus nppiStTranspose_64u_C1R_host(Ncv64u *h_src, Ncv32u srcStride, Ncv64u *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStDecimate_64s_C1R(Ncv64s *d_src, Ncv32u srcStep, Ncv64s *d_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale, NcvBool readThruTexture)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NppStBorderType
Border type.
NCV_EXPORTS NCVStatus nppiStDecimate_32f_C1R_host(Ncv32f *h_src, Ncv32u srcStep, Ncv32f *h_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStDecimate_64f_C1R_host(Ncv64f *h_src, Ncv32u srcStep, Ncv64f *h_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStDecimate_64u_C1R(Ncv64u *d_src, Ncv32u srcStep, Ncv64u *d_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale, NcvBool readThruTexture)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStDecimate_32u_C1R_host(Ncv32u *h_src, Ncv32u srcStep, Ncv32u *h_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStFilterColumnBorder_32f_C1R(const Ncv32f *pSrc, NcvSize32u srcSize, Ncv32u nSrcStep, Ncv32f *pDst, NcvSize32u dstSize, Ncv32u nDstStep, NcvRect32u oROI, NppStBorderType borderType, const Ncv32f *pKernel, Ncv32s nKernelSize, Ncv32s nAnchor, Ncv32f multiplier)
Column linear filter.
NCV_EXPORTS NCVStatus nppiStInterpolateFrames(const NppStInterpolationState *pState)
Interpolate frames (images) using provided optical flow (displacement field).
NCV_EXPORTS NCVStatus nppiStDecimate_32f_C1R(Ncv32f *d_src, Ncv32u srcStep, Ncv32f *d_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale, NcvBool readThruTexture)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStIntegral_32f32f_C1R_host(Ncv32f *h_src, Ncv32u srcStep, Ncv32f *h_dst, Ncv32u dstStep, NcvSize32u roiSize)
Creates an integral image representation for the input image.
NCV_EXPORTS NCVStatus nppiStDecimate_64u_C1R_host(Ncv64u *h_src, Ncv32u srcStep, Ncv64u *h_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStIntegralGetSize_8u32u(NcvSize32u roiSize, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for integral image creation.
NCV_EXPORTS NCVStatus nppiStSqrIntegral_8u64u_C1R(Ncv8u *d_src, Ncv32u srcStep, Ncv64u *d_dst, Ncv32u dstStep, NcvSize32u roiSize, Ncv8u *pBuffer, Ncv32u bufSize, cudaDeviceProp &devProp)
Creates a squared integral image representation for the input image.
NCV_EXPORTS NCVStatus nppiStTranspose_64s_C1R(Ncv64s *d_src, Ncv32u srcStride, Ncv64s *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStGetInterpolationBufferSize(NcvSize32u srcSize, Ncv32u nStep, Ncv32u *hpSize)
Size of a buffer required for interpolation.
NCV_EXPORTS NCVStatus nppiStTranspose_32f_C1R(Ncv32f *d_src, Ncv32u srcStride, Ncv32f *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NCV_EXPORTS NCVStatus nppiStDecimate_64f_C1R(Ncv64f *d_src, Ncv32u srcStep, Ncv64f *d_dst, Ncv32u dstStep, NcvSize32u srcRoi, Ncv32u scale, NcvBool readThruTexture)
Downsamples (decimates) an image using the nearest neighbor algorithm.
NCV_EXPORTS NCVStatus nppiStIntegral_8u32u_C1R_host(Ncv8u *h_src, Ncv32u srcStep, Ncv32u *h_dst, Ncv32u dstStep, NcvSize32u roiSize)
Creates an integral image representation for the input image.
@ nppStSupersample
Supersampling. For downscaling only.
@ nppStBicubic
Bicubic convolution filter, a = -0.5 (cubic Hermite spline)
@ nppStBorderWrap
Wrap out of range position. Image becomes periodic.
@ nppStBorderMirror
reflect out of range position across borders
@ nppStBorderClamp
Clamp out of range position to borders.
@ nppStBorderNone
There is no need to define additional pixels, image is extended already.
NCV_EXPORTS NCVStatus nppsStCompact_32f_host(Ncv32f *h_src, Ncv32u srcLen, Ncv32f *h_dst, Ncv32u *dstLen, Ncv32f elemRemove)
Compacts the input vector by removing elements of specified value.
NCV_EXPORTS NCVStatus nppsStCompact_32s(Ncv32s *d_src, Ncv32u srcLen, Ncv32s *d_dst, Ncv32u *p_dstLen, Ncv32s elemRemove, Ncv8u *pBuffer, Ncv32u bufSize, cudaDeviceProp &devProp)
Compacts the input vector by removing elements of specified value.
NCV_EXPORTS NCVStatus nppsStCompact_32u_host(Ncv32u *h_src, Ncv32u srcLen, Ncv32u *h_dst, Ncv32u *dstLen, Ncv32u elemRemove)
Compacts the input vector by removing elements of specified value.
NCV_EXPORTS NCVStatus nppsStCompact_32u(Ncv32u *d_src, Ncv32u srcLen, Ncv32u *d_dst, Ncv32u *p_dstLen, Ncv32u elemRemove, Ncv8u *pBuffer, Ncv32u bufSize, cudaDeviceProp &devProp)
Compacts the input vector by removing elements of specified value.
NCV_EXPORTS NCVStatus nppsStCompactGetSize_32u(Ncv32u srcLen, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for vector compaction.
NCVStatus nppsStCompactGetSize_32s(Ncv32u srcLen, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for vector compaction.
NCV_EXPORTS NCVStatus nppsStCompact_32s_host(Ncv32s *h_src, Ncv32u srcLen, Ncv32s *h_dst, Ncv32u *dstLen, Ncv32s elemRemove)
Compacts the input vector by removing elements of specified value.
NCVStatus nppsStCompactGetSize_32f(Ncv32u srcLen, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for vector compaction.
NCV_EXPORTS NCVStatus nppsStCompact_32f(Ncv32f *d_src, Ncv32u srcLen, Ncv32f *d_dst, Ncv32u *p_dstLen, Ncv32f elemRemove, Ncv8u *pBuffer, Ncv32u bufSize, cudaDeviceProp &devProp)
Compacts the input vector by removing elements of specified value.
Frame interpolation state.
Ncv32f pos
new frame position
Ncv32f * pSrcFrame0
frame 0
Ncv32f * pFU
forward horizontal displacement
Ncv32f * pBU
backward horizontal displacement
Ncv32f * pBV
backward vertical displacement
NcvSize32u size
frame size
Ncv32f * ppBuffers[6]
temporary buffers
Ncv32f * pFV
forward vertical displacement
Ncv32f * pNewFrame
new frame
Ncv32f * pSrcFrame1
frame 1