Point Cloud Library (PCL)  1.12.0
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
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
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_
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.
Definition: NPP_staging.hpp:92
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.
Definition: NPP_staging.hpp:95
@ nppStBorderMirror
reflect out of range position across borders
Definition: NPP_staging.hpp:96
@ nppStBorderClamp
Clamp out of range position to borders.
Definition: NPP_staging.hpp:94
@ nppStBorderNone
There is no need to define additional pixels, image is extended already.
Definition: NPP_staging.hpp:93
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