Point Cloud Library (PCL)  1.10.1
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  */
64 NCV_EXPORTS
65 cudaStream_t nppStGetActiveCUDAstream();
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  */
74 NCV_EXPORTS
75 cudaStream_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)
107 };
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  */
143 NCV_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  */
156 NCV_EXPORTS
157 NCVStatus nppiStInterpolateFrames(const NppStInterpolationState *pState);
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  */
179 NCV_EXPORTS
180 NCVStatus 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  */
213 NCV_EXPORTS
214 NCVStatus 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  */
236 NCV_EXPORTS
237 NCVStatus nppiStVectorWarpGetBufferSize(NcvSize32u srcSize,
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  */
262 NCV_EXPORTS
263 NCVStatus 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  */
294 NCV_EXPORTS
295 NCVStatus 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  */
324 NCV_EXPORTS
325 NCVStatus 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  */
351 NCV_EXPORTS
352 NCVStatus 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  */
362 NCV_EXPORTS
363 NCVStatus 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  */
373 NCV_EXPORTS
374 NCVStatus 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 */
384 NCV_EXPORTS
385 NCVStatus 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  */
395 NCV_EXPORTS
396 NCVStatus 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  */
406 NCV_EXPORTS
407 NCVStatus 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  */
425 NCV_EXPORTS
426 NCVStatus 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  */
435 NCV_EXPORTS
436 NCVStatus 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  */
445 NCV_EXPORTS
446 NCVStatus 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  */
455 NCV_EXPORTS
456 NCVStatus 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  */
465 NCV_EXPORTS
466 NCVStatus 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  */
475 NCV_EXPORTS
476 NCVStatus 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  */
497 NCV_EXPORTS
498 NCVStatus 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  */
520 NCV_EXPORTS
521 NCVStatus 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  */
539 NCV_EXPORTS
540 NCVStatus 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  */
548 NCV_EXPORTS
549 NCVStatus 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  */
557 NCV_EXPORTS
558 NCVStatus 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  */
566 NCV_EXPORTS
567 NCVStatus 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  */
575 NCV_EXPORTS
576 NCVStatus 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  */
584 NCV_EXPORTS
585 NCVStatus 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  */
593 NCV_EXPORTS
594 NCVStatus 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  */
609 NCV_EXPORTS
610 NCVStatus 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  */
618 NCV_EXPORTS
619 NCVStatus 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  */
627 NCV_EXPORTS
628 NCVStatus 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  */
636 NCV_EXPORTS
637 NCVStatus 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  */
645 NCV_EXPORTS
646 NCVStatus 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  */
654 NCV_EXPORTS
655 NCVStatus 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  */
663 NCV_EXPORTS
664 NCVStatus 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  */
677 NCV_EXPORTS
678 NCVStatus 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  */
685 NCV_EXPORTS
686 NCVStatus 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  */
703 NCV_EXPORTS
704 NCVStatus 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  */
713 NCV_EXPORTS
714 NCVStatus 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  */
730 NCV_EXPORTS
731 NCVStatus 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  */
739 NCV_EXPORTS
740 NCVStatus 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  */
753 NCV_EXPORTS
754 NCVStatus 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  */
771 NCV_EXPORTS
772 NCVStatus 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  */
788 NCV_EXPORTS
789 NCVStatus 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  */
810 NCV_EXPORTS
811 NCVStatus 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  */
818 NCVStatus 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  */
825 NCVStatus 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  */
842 NCV_EXPORTS
843 NCVStatus 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  */
853 NCV_EXPORTS
854 NCVStatus 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  */
864 NCV_EXPORTS
865 NCVStatus 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  */
882 NCV_EXPORTS
883 NCVStatus 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  */
891 NCV_EXPORTS
892 NCVStatus 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  */
900 NCV_EXPORTS
901 NCVStatus 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_
nppiStTranspose_64f_C1R_host
NCV_EXPORTS NCVStatus nppiStTranspose_64f_C1R_host(Ncv64f *h_src, Ncv32u srcStride, Ncv64f *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
nppiStIntegral_8u32u_C1R
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.
nppiStTranspose_64s_C1R
NCV_EXPORTS NCVStatus nppiStTranspose_64s_C1R(Ncv64s *d_src, Ncv32u srcStride, Ncv64s *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NppStInterpMode
NppStInterpMode
Filter types for image resizing.
Definition: NPP_staging.hpp:103
nppiStTranspose_32s_C1R
NCV_EXPORTS NCVStatus nppiStTranspose_32s_C1R(Ncv32s *d_src, Ncv32u srcStride, Ncv32s *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
nppiStResize_32f_C1R
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.
nppiStTranspose_32u_C1R_host
NCV_EXPORTS NCVStatus nppiStTranspose_32u_C1R_host(Ncv32u *h_src, Ncv32u srcStride, Ncv32u *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
nppStBicubic
Bicubic convolution filter, a = -0.5 (cubic Hermite spline)
Definition: NPP_staging.hpp:106
nppiStRectStdDev_32f_C1R
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.
nppStBorderClamp
Clamp out of range position to borders.
Definition: NPP_staging.hpp:94
nppiStIntegral_32f32f_C1R
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.
nppStBorderWrap
Wrap out of range position. Image becomes periodic.
Definition: NPP_staging.hpp:95
nppStSupersample
Supersampling. For downscaling only.
Definition: NPP_staging.hpp:105
nppsStCompact_32s_host
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.
nppStSetActiveCUDAstream
NCV_EXPORTS cudaStream_t nppStSetActiveCUDAstream(cudaStream_t cudaStream)
Sets an active CUDA stream used by NPPST NOT THREAD SAFE.
nppiStTranspose_128_C1R
NCV_EXPORTS NCVStatus nppiStTranspose_128_C1R(void *d_src, Ncv32u srcStep, void *d_dst, Ncv32u dstStep, NcvSize32u srcRoi)
Transposes an image.
nppiStIntegralGetSize_8u32u
NCV_EXPORTS NCVStatus nppiStIntegralGetSize_8u32u(NcvSize32u roiSize, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for integral image creation.
nppiStDecimate_64s_C1R
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.
nppsStCompact_32f
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.
nppiStTranspose_32f_C1R_host
NCV_EXPORTS NCVStatus nppiStTranspose_32f_C1R_host(Ncv32f *h_src, Ncv32u srcStride, Ncv32f *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NppStInterpolationState::ppBuffers
Ncv32f * ppBuffers[6]
temporary buffers
Definition: NPP_staging.hpp:129
nppiStDecimate_32f_C1R
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.
nppiStDecimate_32u_C1R
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.
nppiStDecimate_64f_C1R_host
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.
nppiStDecimate_64u_C1R
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.
NppStInterpolationState::size
NcvSize32u size
frame size
Definition: NPP_staging.hpp:119
NcvRect32u
Definition: NCV.hpp:148
nppsStCompactGetSize_32u
NCV_EXPORTS NCVStatus nppsStCompactGetSize_32u(Ncv32u srcLen, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for vector compaction.
nppsStCompactGetSize_32s
NCVStatus nppsStCompactGetSize_32s(Ncv32u srcLen, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for vector compaction.
nppiStSqrIntegral_8u64u_C1R
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.
NcvSize32u
Definition: NCV.hpp:166
NppStInterpolationState::pBU
Ncv32f * pBU
backward horizontal displacement
Definition: NPP_staging.hpp:126
nppiStSqrIntegralGetSize_8u64u
NCV_EXPORTS NCVStatus nppiStSqrIntegralGetSize_8u64u(NcvSize32u roiSize, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for squared integral image creation.
nppiStDecimate_32f_C1R_host
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.
NppStInterpolationState::pSrcFrame0
Ncv32f * pSrcFrame0
frame 0
Definition: NPP_staging.hpp:122
NppStInterpolationState::pos
Ncv32f pos
new frame position
Definition: NPP_staging.hpp:121
NppStInterpolationState
Frame interpolation state.
Definition: NPP_staging.hpp:117
nppStBorderMirror
reflect out of range position across borders
Definition: NPP_staging.hpp:96
nppiStDecimate_32s_C1R
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.
nppiStTranspose_64u_C1R_host
NCV_EXPORTS NCVStatus nppiStTranspose_64u_C1R_host(Ncv64u *h_src, Ncv32u srcStride, Ncv64u *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
nppStBorderNone
There is no need to define additional pixels, image is extended already.
Definition: NPP_staging.hpp:93
NppStInterpolationState::pFU
Ncv32f * pFU
forward horizontal displacement
Definition: NPP_staging.hpp:124
nppiStVectorWarp_PSF1x1_32f_C1
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.
nppiStVectorWarp_PSF2x2_32f_C1
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.
nppsStCompact_32u
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.
nppsStCompactGetSize_32f
NCVStatus nppsStCompactGetSize_32f(Ncv32u srcLen, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for vector compaction.
nppsStCompact_32f_host
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.
nppiStInterpolateFrames
NCV_EXPORTS NCVStatus nppiStInterpolateFrames(const NppStInterpolationState *pState)
Interpolate frames (images) using provided optical flow (displacement field).
nppsStCompact_32s
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.
nppiStTranspose_64u_C1R
NCV_EXPORTS NCVStatus nppiStTranspose_64u_C1R(Ncv64u *d_src, Ncv32u srcStride, Ncv64u *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
nppiStTranspose_32f_C1R
NCV_EXPORTS NCVStatus nppiStTranspose_32f_C1R(Ncv32f *d_src, Ncv32u srcStride, Ncv32f *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
nppiStIntegralGetSize_32f32f
NCV_EXPORTS NCVStatus nppiStIntegralGetSize_32f32f(NcvSize32u roiSize, Ncv32u *pBufsize, cudaDeviceProp &devProp)
Calculates the size of the temporary buffer for integral image creation.
nppiStFilterRowBorder_32f_C1R
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.
nppiStDecimate_64s_C1R_host
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.
nppiStFilterColumnBorder_32f_C1R
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.
NppStInterpolationState::pNewFrame
Ncv32f * pNewFrame
new frame
Definition: NPP_staging.hpp:128
nppsStCompact_32u_host
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.
NppStInterpolationState::pBV
Ncv32f * pBV
backward vertical displacement
Definition: NPP_staging.hpp:127
nppiStTranspose_64s_C1R_host
NCV_EXPORTS NCVStatus nppiStTranspose_64s_C1R_host(Ncv64s *h_src, Ncv32u srcStride, Ncv64s *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
nppiStTranspose_32s_C1R_host
NCV_EXPORTS NCVStatus nppiStTranspose_32s_C1R_host(Ncv32s *h_src, Ncv32u srcStride, Ncv32s *h_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
nppiStDecimate_64f_C1R
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.
nppStGetActiveCUDAstream
NCV_EXPORTS cudaStream_t nppStGetActiveCUDAstream()
Gets an active CUDA stream used by NPPST NOT THREAD SAFE.
nppiStTranspose_32u_C1R
NCV_EXPORTS NCVStatus nppiStTranspose_32u_C1R(Ncv32u *d_src, Ncv32u srcStride, Ncv32u *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
nppiStRectStdDev_32f_C1R_host
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.
nppiStVectorWarpGetBufferSize
NCV_EXPORTS NCVStatus nppiStVectorWarpGetBufferSize(NcvSize32u srcSize, Ncv32u nSrcStep, Ncv32u *hpSize)
Size of buffer required for vector image warping.
nppiStIntegral_8u32u_C1R_host
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.
NppStBorderType
NppStBorderType
Border type.
Definition: NPP_staging.hpp:91
nppiStTranspose_64f_C1R
NCV_EXPORTS NCVStatus nppiStTranspose_64f_C1R(Ncv64f *d_src, Ncv32u srcStride, Ncv64f *d_dst, Ncv32u dstStride, NcvSize32u srcRoi)
Transposes an image.
NppStInterpolationState::pSrcFrame1
Ncv32f * pSrcFrame1
frame 1
Definition: NPP_staging.hpp:123
nppiStTranspose_128_C1R_host
NCV_EXPORTS NCVStatus nppiStTranspose_128_C1R_host(void *d_src, Ncv32u srcStep, void *d_dst, Ncv32u dstStep, NcvSize32u srcRoi)
Transposes an image.
nppiStGetInterpolationBufferSize
NCV_EXPORTS NCVStatus nppiStGetInterpolationBufferSize(NcvSize32u srcSize, Ncv32u nStep, Ncv32u *hpSize)
Size of a buffer required for interpolation.
NppStInterpolationState::nStep
Ncv32u nStep
pitch
Definition: NPP_staging.hpp:120
nppiStIntegral_32f32f_C1R_host
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.
nppiStDecimate_64u_C1R_host
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.
NppStInterpolationState::pFV
Ncv32f * pFV
forward vertical displacement
Definition: NPP_staging.hpp:125
nppiStSqrIntegral_8u64u_C1R_host
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.
nppiStDecimate_32u_C1R_host
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.
nppiStDecimate_32s_C1R_host
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.