From 1a9418619586b556e327c231d48b31fc1e96e41b Mon Sep 17 00:00:00 2001
From: Anatoly Baksheev <no@email>
Date: Thu, 13 Jan 2011 13:04:00 +0000
Subject: [PATCH] First version of CascadeClassifier_GPU. Only for VS2008 now.
 Sample for it. new NPP_staging for VS2008 only

---
 .../NPP_staging_static_Windows_32_v1.lib      |  Bin 573356 -> 607300 bytes
 3rdparty/NPP_staging/npp_staging.h            |   42 +-
 modules/gpu/CMakeLists.txt                    |   23 +-
 modules/gpu/include/opencv2/gpu/gpu.hpp       |   92 +-
 modules/gpu/src/arithm.cpp                    |    6 +-
 modules/gpu/src/cascadeclassifier.cpp         |  746 ++++-
 modules/gpu/src/cuda/internal_shared.hpp      |   24 +-
 modules/gpu/src/cuda/surf_key_point.h         |   24 +-
 modules/gpu/src/element_operations.cpp        |   50 +-
 .../FaceDetectionFeed.cpp_NvidiaAPI_sample    |  362 +++
 modules/gpu/src/nvidia/NCV.cpp                |  571 ++++
 modules/gpu/src/nvidia/NCV.hpp                |  837 ++++++
 .../gpu/src/nvidia/NCVHaarObjectDetection.cu  | 2603 +++++++++++++++++
 .../gpu/src/nvidia/NCVHaarObjectDetection.hpp |  501 ++++
 .../gpu/src/nvidia/NCVRuntimeTemplates.hpp    |  174 ++
 modules/gpu/src/precomp.hpp                   |    3 +
 samples/gpu/cascadeclassifier.cpp             |  193 ++
 17 files changed, 6066 insertions(+), 185 deletions(-)
 create mode 100644 modules/gpu/src/nvidia/FaceDetectionFeed.cpp_NvidiaAPI_sample
 create mode 100644 modules/gpu/src/nvidia/NCV.cpp
 create mode 100644 modules/gpu/src/nvidia/NCV.hpp
 create mode 100644 modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
 create mode 100644 modules/gpu/src/nvidia/NCVHaarObjectDetection.hpp
 create mode 100644 modules/gpu/src/nvidia/NCVRuntimeTemplates.hpp
 create mode 100644 samples/gpu/cascadeclassifier.cpp

diff --git a/3rdparty/NPP_staging/NPP_staging_static_Windows_32_v1.lib b/3rdparty/NPP_staging/NPP_staging_static_Windows_32_v1.lib
index 39d29b8b1a46d8b893b9aa2bad19d11d14dbdeb4..98d5c227a1a540dd1ccd14a34215268b7a5ba011 100644
GIT binary patch
delta 124842
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

delta 108600
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
alNErPG(l5d6O^*2x~QUbbXkR*`2QESJd1V!

diff --git a/3rdparty/NPP_staging/npp_staging.h b/3rdparty/NPP_staging/npp_staging.h
index c54af5c032..a9c6607dff 100644
--- a/3rdparty/NPP_staging/npp_staging.h
+++ b/3rdparty/NPP_staging/npp_staging.h
@@ -188,14 +188,14 @@ struct NppStSize32u
 enum NppStStatus
 {
     //already present in NPP
- /*   NPP_SUCCESS                      = 0,   ///< Successful operation (same as NPP_NO_ERROR)
-    NPP_ERROR                        = -1,  ///< Unknown error
-    NPP_CUDA_KERNEL_EXECUTION_ERROR  = -3,  ///< CUDA kernel execution error
-    NPP_NULL_POINTER_ERROR           = -4,  ///< NULL pointer argument error
-    NPP_TEXTURE_BIND_ERROR           = -24, ///< CUDA texture binding error or non-zero offset returned
-    NPP_MEMCPY_ERROR                 = -13, ///< CUDA memory copy error
-    NPP_MEM_ALLOC_ERR                = -12, ///< CUDA memory allocation error
-    NPP_MEMFREE_ERR                  = -15, ///< CUDA memory deallocation error*/
+    //NPP_SUCCESS                      = 0,   ///< Successful operation (same as NPP_NO_ERROR)
+    //NPP_ERROR                        = -1,  ///< Unknown error
+    //NPP_CUDA_KERNEL_EXECUTION_ERROR  = -3,  ///< CUDA kernel execution error
+    //NPP_NULL_POINTER_ERROR           = -4,  ///< NULL pointer argument error
+    //NPP_TEXTURE_BIND_ERROR           = -24, ///< CUDA texture binding error or non-zero offset returned
+    //NPP_MEMCPY_ERROR                 = -13, ///< CUDA memory copy error
+    //NPP_MEM_ALLOC_ERR                = -12, ///< CUDA memory allocation error
+    //NPP_MEMFREE_ERR                  = -15, ///< CUDA memory deallocation error
 
     //to be added
     NPP_INVALID_ROI,                        ///< Invalid region of interest argument
@@ -244,7 +244,7 @@ extern "C" {
 
 /** \defgroup core_npp NPP Core
  * Basic functions for CUDA streams management.
- * WARNING: These functions couldn't be exported from NPP_staging library, so they can't be used
+ * WARNING: These functions couldn't be exported into DLL, so they can be used only with static version of NPP_staging
  * @{
  */
 
@@ -569,6 +569,13 @@ NppStStatus nppiStTranspose_64f_C1R_host(NppSt64f *h_src, NppSt32u srcStride,
 NppStStatus nppiStIntegralGetSize_8u32u(NppStSize32u roiSize, NppSt32u *pBufsize);
 
 
+/**
+ * Calculates the size of the temporary buffer for integral image creation
+ * \see nppiStIntegralGetSize_8u32u
+ */
+NppStStatus nppiStIntegralGetSize_32f32f(NppStSize32u roiSize, NppSt32u *pBufsize);
+
+
 /**
  * Creates an integral image representation for the input image
  *
@@ -587,6 +594,15 @@ NppStStatus nppiStIntegral_8u32u_C1R(NppSt8u *d_src, NppSt32u srcStep,
                                      NppSt8u *pBuffer, NppSt32u bufSize);
 
 
+/**
+ * Creates an integral image representation for the input image
+ * \see nppiStIntegral_8u32u_C1R
+ */
+NppStStatus nppiStIntegral_32f32f_C1R(NppSt32f *d_src, NppSt32u srcStep,
+                                      NppSt32f *d_dst, NppSt32u dstStep, NppStSize32u roiSize,
+                                      NppSt8u *pBuffer, NppSt32u bufSize);
+
+
 /**
  * Creates an integral image representation for the input image. Host implementation
  *
@@ -602,6 +618,14 @@ NppStStatus nppiStIntegral_8u32u_C1R_host(NppSt8u *h_src, NppSt32u srcStep,
                                           NppSt32u *h_dst, NppSt32u dstStep, NppStSize32u roiSize);
 
 
+/**
+ * Creates an integral image representation for the input image. Host implementation
+ * \see nppiStIntegral_8u32u_C1R_host
+ */
+NppStStatus nppiStIntegral_32f32f_C1R_host(NppSt32f *h_src, NppSt32u srcStep,
+                                           NppSt32f *h_dst, NppSt32u dstStep, NppStSize32u roiSize);
+
+
 /**
  * Calculates the size of the temporary buffer for squared integral image creation
  *
diff --git a/modules/gpu/CMakeLists.txt b/modules/gpu/CMakeLists.txt
index 3c10b0ee2b..f25036ac24 100644
--- a/modules/gpu/CMakeLists.txt
+++ b/modules/gpu/CMakeLists.txt
@@ -35,6 +35,13 @@ source_group("Include" FILES ${lib_hdrs})
 file(GLOB lib_device_hdrs "src/opencv2/gpu/device/*.h*")
 source_group("Device" FILES ${lib_device_hdrs})
 
+if (HAVE_CUDA AND MSVC)
+    file(GLOB ncv_srcs "src/nvidia/*.cpp")
+	file(GLOB ncv_hdrs "src/nvidia/*.h*")
+	file(GLOB ncv_cuda "src/nvidia/*.cu")
+	source_group("Src\\NVidia" FILES ${ncv_srcs} ${ncv_hdrs} ${ncv_cuda})
+endif()
+
 if (HAVE_CUDA)		
 	get_filename_component(_path_to_findnpp "${CMAKE_CURRENT_LIST_FILE}" PATH)
 	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${_path_to_findnpp})	
@@ -68,19 +75,16 @@ if (HAVE_CUDA)
 		string(REPLACE "/EHsc-" "/EHs" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
 		string(REPLACE "/EHsc-" "/EHs" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
 	endif()
+   
 
-	CUDA_COMPILE(cuda_objs ${lib_cuda})
+    include(FindNPP_staging.cmake)
+    include_directories(${NPPST_INC})   
+    
+	CUDA_COMPILE(cuda_objs ${lib_cuda} ${ncv_cuda})
 	#CUDA_BUILD_CLEAN_TARGET()
 endif()
 
-
-add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs} ${lib_device_hdrs} ${cuda_objs})
-
-IF (HAVE_CUDA)
-    include(FindNPP_staging.cmake)    
-    include_directories(${NPPST_INC})       
-    target_link_libraries(${the_target} ${NPPST_LIB})
-endif()
+add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs} ${lib_device_hdrs} ${ncv_srcs} ${ncv_hdrs} ${ncv_cuda} ${cuda_objs})
 
 if(PCHSupport_FOUND)
 	set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp)
@@ -114,6 +118,7 @@ target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${DEPS} )
 
 if (HAVE_CUDA)
 	target_link_libraries(${the_target} ${CUDA_LIBRARIES} ${CUDA_NPP_LIBRARIES})
+    target_link_libraries(${the_target} ${NPPST_LIB})
     CUDA_ADD_CUFFT_TO_TARGET(${the_target})
 endif()
 
diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 70a34eee6e..3979d62dd7 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1380,87 +1380,39 @@ namespace cv
             explicit BruteForceMatcher_GPU(L2<T> /*d*/) : BruteForceMatcher_GPU_base(L2Dist) {}
         };
 
-        ////////////////////////////////// CascadeClassifier //////////////////////////////////////////
+        ////////////////////////////////// CascadeClassifier_GPU //////////////////////////////////////////
         // The cascade classifier class for object detection.
-        class CV_EXPORTS CascadeClassifier
+        class CV_EXPORTS CascadeClassifier_GPU
         {
-        public:
-            struct CV_EXPORTS DTreeNode
-            {
-                int featureIdx;
-                float threshold; // for ordered features only
-                int left;
-                int right;
-            };
-
-            struct CV_EXPORTS DTree
-            {
-                int nodeCount;
-            };
-
-            struct CV_EXPORTS Stage
-            {
-                int first;
-                int ntrees;
-                float threshold;
-            };
-
-            enum { BOOST = 0 };
-            enum { DO_CANNY_PRUNING = 1, SCALE_IMAGE = 2,FIND_BIGGEST_OBJECT = 4, DO_ROUGH_SEARCH = 8 };
-
-            CascadeClassifier();
-            CascadeClassifier(const string& filename);
-            ~CascadeClassifier();
+        public:            
+            CascadeClassifier_GPU();
+            CascadeClassifier_GPU(const string& filename);
+            ~CascadeClassifier_GPU();
 
             bool empty() const;
             bool load(const string& filename);
-            bool read(const FileNode& node);
-
-            void detectMultiScale( const Mat& image, vector<Rect>& objects, double scaleFactor=1.1,
-                int minNeighbors=3, int flags=0, Size minSize=Size(), Size maxSize=Size());
-
-            bool setImage( Ptr<FeatureEvaluator>&, const Mat& );
-            int runAt( Ptr<FeatureEvaluator>&, Point );
-
-            bool isStumpBased;
-
-            int stageType;
-            int featureType;
-            int ncategories;
-            Size origWinSize;
-
-            vector<Stage> stages;
-            vector<DTree> classifiers;
-            vector<DTreeNode> nodes;
-            vector<float> leaves;
-            vector<int> subsets;
+            void release();
+            
+            /* returns number of detected objects */
+            int detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size());
+                                    
+            bool findLargestObject;
+            bool visualizeInPlace;
 
-            Ptr<FeatureEvaluator> feval;
-            Ptr<CvHaarClassifierCascade> oldCascade;
+            Size getClassifierSize() const;
+        private:
+            
+            struct CascadeClassifierImpl;                        
+            CascadeClassifierImpl* impl;            
         };
-
+        
         ////////////////////////////////// SURF //////////////////////////////////////////
         
         struct CV_EXPORTS SURFParams_GPU 
         {
-            SURFParams_GPU() :
-                threshold(0.1f), 
-                nOctaves(4),
-                nIntervals(4),
-                initialScale(2.f),
-
-                l1(3.f/1.5f),
-                l2(5.f/1.5f),
-                l3(3.f/1.5f),
-                l4(1.f/1.5f),
-                edgeScale(0.81f),
-                initialStep(1),
-
-                extended(true),
-
-                featuresRatio(0.01f)
-            {
-            }
+            SURFParams_GPU() : threshold(0.1f), nOctaves(4), nIntervals(4), initialScale(2.f), 
+                l1(3.f/1.5f), l2(5.f/1.5f), l3(3.f/1.5f), l4(1.f/1.5f),
+                edgeScale(0.81f), initialStep(1), extended(true), featuresRatio(0.01f) {}
 
             //! The interest operator threshold
             float threshold;
diff --git a/modules/gpu/src/arithm.cpp b/modules/gpu/src/arithm.cpp
index 28acc6a713..968e192d55 100644
--- a/modules/gpu/src/arithm.cpp
+++ b/modules/gpu/src/arithm.cpp
@@ -170,8 +170,7 @@ void cv::gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst)
 
     if (src.type() == CV_8UC1)
     {
-        nppSafeCall( nppiLUT_Linear_8u_C1R(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz,
-            nppLut.ptr<Npp32s>(), lvls.pLevels, 256) );
+        nppSafeCall( nppiLUT_Linear_8u_C1R(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz, nppLut.ptr<Npp32s>(), lvls.pLevels, 256) );
     }
     else
     {
@@ -186,8 +185,7 @@ void cv::gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst)
             pValues3[1] = nppLut3[1].ptr<Npp32s>();
             pValues3[2] = nppLut3[2].ptr<Npp32s>();
         }
-        nppSafeCall( nppiLUT_Linear_8u_C3R(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz,
-            pValues3, lvls.pLevels3, lvls.nValues3) );
+        nppSafeCall( nppiLUT_Linear_8u_C3R(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz, pValues3, lvls.pLevels3, lvls.nValues3) );
     }
 }
 
diff --git a/modules/gpu/src/cascadeclassifier.cpp b/modules/gpu/src/cascadeclassifier.cpp
index e6a4e7295f..3a7d2ca47d 100644
--- a/modules/gpu/src/cascadeclassifier.cpp
+++ b/modules/gpu/src/cascadeclassifier.cpp
@@ -42,69 +42,751 @@
 
 #include "precomp.hpp"
 
-
-
-
 using namespace cv;
 using namespace cv::gpu;
 using namespace std;
 
-#if !defined (HAVE_CUDA)
 
-cv::gpu::CascadeClassifier::CascadeClassifier()  { throw_nogpu(); }
-cv::gpu::CascadeClassifier::CascadeClassifier(const string&)  { throw_nogpu(); }
-cv::gpu::CascadeClassifier::~CascadeClassifier()  { throw_nogpu(); }
+#if !defined (HAVE_CUDA) || (defined(_MSC_VER) && _MSC_VER != 1500) || !defined(_MSC_VER)
 
-bool cv::gpu::CascadeClassifier::empty() const { throw_nogpu(); return true; }
-bool cv::gpu::CascadeClassifier::load(const string& filename)  { throw_nogpu(); return true; }
-bool cv::gpu::CascadeClassifier::read(const FileNode& node)  { throw_nogpu(); return true; }
+cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU()  { throw_nogpu(); }
+cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU(const string&)  { throw_nogpu(); }
+cv::gpu::CascadeClassifier_GPU::~CascadeClassifier_GPU()  { throw_nogpu(); }
 
-void cv::gpu::CascadeClassifier::detectMultiScale( const Mat&, vector<Rect>&, double, int, int, Size, Size) { throw_nogpu(); }
+bool cv::gpu::CascadeClassifier_GPU::empty() const { throw_nogpu(); return true; }
+bool cv::gpu::CascadeClassifier_GPU::load(const string&)  { throw_nogpu(); return true; }
+Size cv::gpu::CascadeClassifier_GPU::getClassifierSize() const { throw_nogpu(); return Size(); }
 
-       
+int cv::gpu::CascadeClassifier_GPU::detectMultiScale( const GpuMat& , GpuMat& , double , int , Size)  { throw_nogpu(); return 0; }
 
+#if defined (HAVE_CUDA)
+	NCVStatus loadFromXML(const string&, HaarClassifierCascadeDescriptor&, vector<HaarStage64>&, 
+						  vector<HaarClassifierNode128>&, vector<HaarFeature64>&) { throw_nogpu(); return NCVStatus(); }
 
+	void groupRectangles(vector<NcvRect32u>&, int, double, vector<Ncv32u>*) { throw_nogpu(); }
+#endif
 
 #else
 
+struct cv::gpu::CascadeClassifier_GPU::CascadeClassifierImpl
+{    
+    CascadeClassifierImpl(const string& filename) : lastAllocatedFrameSize(-1, -1)
+    {
+        ncvSetDebugOutputHandler(NCVDebugOutputHandler);            
+        if (ncvStat != load(filename))
+            CV_Error(CV_GpuApiCallError, "Error in GPU cacade load");
+    }    
+    NCVStatus process(const GpuMat& src, GpuMat& objects, float scaleStep, int minNeighbors, bool findLargestObject, bool visualizeInPlace, NcvSize32u ncvMinSize, /*out*/unsigned int& numDetections)
+    {   
+        calculateMemReqsAndAllocate(src.size());        
 
-cv::gpu::CascadeClassifier::CascadeClassifier()
-{
+        NCVMemPtr src_beg;
+        src_beg.ptr = (void*)src.ptr<Ncv8u>();
+        src_beg.memtype = NCVMemoryTypeDevice;
 
-}
+        NCVMemSegment src_seg;
+        src_seg.begin = src_beg;
+        src_seg.size  = src.step * src.rows;
 
-cv::gpu::CascadeClassifier::CascadeClassifier(const string& filename)
-{
+        NCVMatrixReuse<Ncv8u> d_src(src_seg, devProp.textureAlignment, src.cols, src.rows, src.step, true);        
+        
+        //NCVMatrixAlloc<Ncv8u> d_src(*gpuAllocator, src.cols, src.rows);
+        //ncvAssertReturn(d_src.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
 
-}
+        //NCVMatrixAlloc<Ncv8u> h_src(*cpuAllocator, src.cols, src.rows);
+        //ncvAssertReturn(h_src.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
 
-cv::gpu::CascadeClassifier::~CascadeClassifier()
-{
+        CV_Assert(objects.rows == 1);
+
+        NCVMemPtr objects_beg;
+        objects_beg.ptr = (void*)objects.ptr<NcvRect32u>();
+        objects_beg.memtype = NCVMemoryTypeDevice;
+
+        NCVMemSegment objects_seg;
+        objects_seg.begin = objects_beg;
+        objects_seg.size = objects.step * objects.rows;
+        NCVVectorReuse<NcvRect32u> d_rects(objects_seg, objects.cols);
+        //NCVVectorAlloc<NcvRect32u> d_rects(*gpuAllocator, 100);        
+        //ncvAssertReturn(d_rects.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);        
+            
+        NcvSize32u roi;
+        roi.width = d_src.width();
+        roi.height = d_src.height();
+
+        Ncv32u flags = 0;
+        flags |= findLargestObject? NCVPipeObjDet_FindLargestObject : 0;
+        flags |= visualizeInPlace ? NCVPipeObjDet_VisualizeInPlace  : 0;
+        
+        ncvStat = ncvDetectObjectsMultiScale_device(
+            d_src, roi, d_rects, numDetections, haar, *h_haarStages,
+            *d_haarStages, *d_haarNodes, *d_haarFeatures,
+            ncvMinSize,
+            minNeighbors,
+            scaleStep, 1,
+            flags,
+            *gpuAllocator, *cpuAllocator, devProp.major, devProp.minor,  0);
+        ncvAssertReturnNcvStat(ncvStat);
+        ncvAssertCUDAReturn(cudaStreamSynchronize(0), NCV_CUDA_ERROR);
+                       
+        return NCV_SUCCESS;
+    }
+    ////
     
+    NcvSize32u getClassifierSize() const  { return haar.ClassifierSize; }
+    cv::Size getClassifierCvSize() const { return cv::Size(haar.ClassifierSize.width, haar.ClassifierSize.height); }
+private:
+
+    static void NCVDebugOutputHandler(const char* msg) { CV_Error(CV_GpuApiCallError, msg); }
+
+    NCVStatus load(const string& classifierFile)
+    {        
+        int devId = cv::gpu::getDevice();           
+        ncvAssertCUDAReturn(cudaGetDeviceProperties(&devProp, devId), NCV_CUDA_ERROR);
+
+        // Load the classifier from file (assuming its size is about 1 mb) using a simple allocator
+        gpuCascadeAllocator = new NCVMemNativeAllocator(NCVMemoryTypeDevice);        
+        cpuCascadeAllocator = new NCVMemNativeAllocator(NCVMemoryTypeHostPinned);
+
+        ncvAssertPrintReturn(gpuCascadeAllocator->isInitialized(), "Error creating cascade GPU allocator", NCV_CUDA_ERROR);
+        ncvAssertPrintReturn(cpuCascadeAllocator->isInitialized(), "Error creating cascade CPU allocator", NCV_CUDA_ERROR);
+
+        Ncv32u haarNumStages, haarNumNodes, haarNumFeatures;
+        ncvStat = ncvHaarGetClassifierSize(classifierFile, haarNumStages, haarNumNodes, haarNumFeatures);
+        ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error reading classifier size (check the file)", NCV_FILE_ERROR);
+
+        h_haarStages   = new NCVVectorAlloc<HaarStage64>(*cpuCascadeAllocator, haarNumStages);        
+        h_haarNodes    = new NCVVectorAlloc<HaarClassifierNode128>(*cpuCascadeAllocator, haarNumNodes);
+        h_haarFeatures = new NCVVectorAlloc<HaarFeature64>(*cpuCascadeAllocator, haarNumFeatures);
+
+        ncvAssertPrintReturn(h_haarStages->isMemAllocated(), "Error in cascade CPU allocator", NCV_CUDA_ERROR);
+        ncvAssertPrintReturn(h_haarNodes->isMemAllocated(), "Error in cascade CPU allocator", NCV_CUDA_ERROR);        
+        ncvAssertPrintReturn(h_haarFeatures->isMemAllocated(), "Error in cascade CPU allocator", NCV_CUDA_ERROR);
+
+        ncvStat = ncvHaarLoadFromFile_host(classifierFile, haar, *h_haarStages, *h_haarNodes, *h_haarFeatures);
+        ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error loading classifier", NCV_FILE_ERROR);
+
+        d_haarStages   = new NCVVectorAlloc<HaarStage64>(*gpuCascadeAllocator, haarNumStages);
+        d_haarNodes    = new NCVVectorAlloc<HaarClassifierNode128>(*gpuCascadeAllocator, haarNumNodes);
+        d_haarFeatures = new NCVVectorAlloc<HaarFeature64>(*gpuCascadeAllocator, haarNumFeatures);
+
+        ncvAssertPrintReturn(d_haarStages->isMemAllocated(), "Error in cascade GPU allocator", NCV_CUDA_ERROR);
+        ncvAssertPrintReturn(d_haarNodes->isMemAllocated(), "Error in cascade GPU allocator", NCV_CUDA_ERROR);                        
+        ncvAssertPrintReturn(d_haarFeatures->isMemAllocated(), "Error in cascade GPU allocator", NCV_CUDA_ERROR);
+
+        ncvStat = h_haarStages->copySolid(*d_haarStages, 0);
+        ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error copying cascade to GPU", NCV_CUDA_ERROR);
+        ncvStat = h_haarNodes->copySolid(*d_haarNodes, 0);
+        ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error copying cascade to GPU", NCV_CUDA_ERROR);
+        ncvStat = h_haarFeatures->copySolid(*d_haarFeatures, 0);
+        ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error copying cascade to GPU", NCV_CUDA_ERROR);    
+
+        return NCV_SUCCESS;
+    }
+    ////
+
+    NCVStatus calculateMemReqsAndAllocate(const Size& frameSize)
+    {        
+        if (lastAllocatedFrameSize == frameSize)
+            return NCV_SUCCESS;
+
+        // Calculate memory requirements and create real allocators
+        NCVMemStackAllocator gpuCounter(devProp.textureAlignment);
+        NCVMemStackAllocator cpuCounter(devProp.textureAlignment);
+
+        ncvAssertPrintReturn(gpuCounter.isInitialized(), "Error creating GPU memory counter", NCV_CUDA_ERROR);        
+        ncvAssertPrintReturn(cpuCounter.isInitialized(), "Error creating CPU memory counter", NCV_CUDA_ERROR);
+        
+        NCVMatrixAlloc<Ncv8u> d_src(gpuCounter, frameSize.width, frameSize.height);
+        NCVMatrixAlloc<Ncv8u> h_src(cpuCounter, frameSize.width, frameSize.height);
+
+        ncvAssertReturn(d_src.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);        
+        ncvAssertReturn(h_src.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+        NCVVectorAlloc<NcvRect32u> d_rects(gpuCounter, 100);        
+        ncvAssertReturn(d_rects.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+        NcvSize32u roi;
+        roi.width = d_src.width();
+        roi.height = d_src.height();
+        Ncv32u numDetections;
+        ncvStat = ncvDetectObjectsMultiScale_device(d_src, roi, d_rects, numDetections, haar, *h_haarStages,
+            *d_haarStages, *d_haarNodes, *d_haarFeatures, haar.ClassifierSize, 4, 1.2f, 1, 0, gpuCounter, cpuCounter, devProp.major, devProp.minor, 0);
+
+        ncvAssertReturnNcvStat(ncvStat);
+        ncvAssertCUDAReturn(cudaStreamSynchronize(0), NCV_CUDA_ERROR);
+                      
+        gpuAllocator = new NCVMemStackAllocator(NCVMemoryTypeDevice, gpuCounter.maxSize(), devProp.textureAlignment);        
+        cpuAllocator = new NCVMemStackAllocator(NCVMemoryTypeHostPinned, cpuCounter.maxSize(), devProp.textureAlignment);
+
+        ncvAssertPrintReturn(gpuAllocator->isInitialized(), "Error creating GPU memory allocator", NCV_CUDA_ERROR);
+        ncvAssertPrintReturn(cpuAllocator->isInitialized(), "Error creating CPU memory allocator", NCV_CUDA_ERROR);        
+        return NCV_SUCCESS;
+    }
+    //// 
+
+    cudaDeviceProp devProp;
+    NCVStatus ncvStat;
+
+    Ptr<NCVMemNativeAllocator> gpuCascadeAllocator;        
+    Ptr<NCVMemNativeAllocator> cpuCascadeAllocator;
+
+    Ptr<NCVVectorAlloc<HaarStage64> >           h_haarStages;        
+    Ptr<NCVVectorAlloc<HaarClassifierNode128> > h_haarNodes;
+    Ptr<NCVVectorAlloc<HaarFeature64> >         h_haarFeatures;
+
+    HaarClassifierCascadeDescriptor haar;
+
+    Ptr<NCVVectorAlloc<HaarStage64> >           d_haarStages;
+    Ptr<NCVVectorAlloc<HaarClassifierNode128> > d_haarNodes;
+    Ptr<NCVVectorAlloc<HaarFeature64> >         d_haarFeatures;
+
+    Size lastAllocatedFrameSize;
+
+    Ptr<NCVMemStackAllocator> gpuAllocator;        
+    Ptr<NCVMemStackAllocator> cpuAllocator;
+};
+
+
+
+cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU() : findLargestObject(false), visualizeInPlace(false), impl(0) {}
+cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU(const string& filename) : findLargestObject(false), visualizeInPlace(false), impl(0) { load(filename); }
+cv::gpu::CascadeClassifier_GPU::~CascadeClassifier_GPU() { release(); }
+bool cv::gpu::CascadeClassifier_GPU::empty() const { return impl == 0; }
+
+void cv::gpu::CascadeClassifier_GPU::release() { if (impl) { delete impl; impl = 0; } }
+
+bool cv::gpu::CascadeClassifier_GPU::load(const string& filename)
+{         
+    release();
+    impl = new CascadeClassifierImpl(filename);
+    return !this->empty();    
 }
 
-bool cv::gpu::CascadeClassifier::empty() const
+Size cv::gpu::CascadeClassifier_GPU::getClassifierSize() const
 {
-    int *a = (int*)&nppiStTranspose_32u_C1R;
-    return *a == 0xFFFFF;
-    return true;
+    return this->empty() ? Size() : impl->getClassifierCvSize();
 }
+                            
+int cv::gpu::CascadeClassifier_GPU::detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, double scaleFactor, int minNeighbors, Size minSize)
+{     
+    CV_Assert( scaleFactor > 1 && image.depth() == CV_8U);
+    CV_Assert( !this->empty());
+        
+    const int defaultObjSearchNum = 100;
+    if (objectsBuf.empty())
+        objectsBuf.create(1, defaultObjSearchNum, DataType<Rect>::type);
+    
+    NcvSize32u ncvMinSize = impl->getClassifierSize();
 
-bool cv::gpu::CascadeClassifier::load(const string& filename)
-{
-    return true;
+    if (ncvMinSize.width < (unsigned)minSize.width && ncvMinSize.height < (unsigned)minSize.height)
+    {
+        ncvMinSize.width = minSize.width;
+        ncvMinSize.height = minSize.height;
+    }    
+                
+    unsigned int numDetections;
+    NCVStatus ncvStat = impl->process(image, objectsBuf, (float)scaleFactor, minNeighbors, findLargestObject, visualizeInPlace, ncvMinSize, numDetections);                 
+    if (ncvStat != NCV_SUCCESS)
+        CV_Error(CV_GpuApiCallError, "Error in face detectioln");
+
+    return numDetections;
 }
 
-bool cv::gpu::CascadeClassifier::read(const FileNode& node)
+	struct RectConvert
+	{
+		Rect operator()(const NcvRect32u& nr) const { return Rect(nr.x, nr.y, nr.width, nr.height); }
+		NcvRect32u operator()(const Rect& nr) const 
+		{ 
+			NcvRect32u rect;
+			rect.x = nr.x;
+			rect.y = nr.y;
+			rect.width = nr.width;
+			rect.height = nr.height;
+			return rect; 
+		}
+	};
+
+	void groupRectangles(std::vector<NcvRect32u> &hypotheses, int groupThreshold, double eps, std::vector<Ncv32u> *weights)
+	{
+		vector<Rect> rects(hypotheses.size());    
+		std::transform(hypotheses.begin(), hypotheses.end(), rects.begin(), RectConvert());
+	    
+		if (weights) 
+		{
+			vector<int> weights_int;
+			weights_int.assign(weights->begin(), weights->end());        
+			cv::groupRectangles(rects, weights_int, groupThreshold, eps);
+		}
+		else
+		{   
+			cv::groupRectangles(rects, groupThreshold, eps);
+		}
+		std::transform(rects.begin(), rects.end(), hypotheses.begin(), RectConvert());    
+		hypotheses.resize(rects.size());
+	}
+
+
+#if 1 /* loadFromXML implementation switch */
+
+NCVStatus loadFromXML(const std::string &filename, 
+                      HaarClassifierCascadeDescriptor &haar, 
+                      std::vector<HaarStage64> &haarStages, 
+                      std::vector<HaarClassifierNode128> &haarClassifierNodes, 
+                      std::vector<HaarFeature64> &haarFeatures)
 {
-    return true;
+    NCVStatus ncvStat;
+
+    haar.NumStages = 0;
+    haar.NumClassifierRootNodes = 0;
+    haar.NumClassifierTotalNodes = 0;
+    haar.NumFeatures = 0;
+    haar.ClassifierSize.width = 0;
+    haar.ClassifierSize.height = 0;        
+    haar.bHasStumpsOnly = true;
+    haar.bNeedsTiltedII = false;
+    Ncv32u curMaxTreeDepth;
+
+    std::vector<char> xmlFileCont;   
+
+    std::vector<HaarClassifierNode128> h_TmpClassifierNotRootNodes;
+    haarStages.resize(0);
+    haarClassifierNodes.resize(0);
+    haarFeatures.resize(0);    
+    
+    Ptr<CvHaarClassifierCascade> oldCascade = (CvHaarClassifierCascade*)cvLoad(filename.c_str(), 0, 0, 0);
+    if (oldCascade.empty())
+        return NCV_HAAR_XML_LOADING_EXCEPTION;
+    
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                          
+    haar.ClassifierSize.width = oldCascade->orig_window_size.width;
+    haar.ClassifierSize.height = oldCascade->orig_window_size.height;
+
+    int stagesCound = oldCascade->count;
+    for(int s = 0; s < stagesCound; ++s) // by stages
+    {
+        HaarStage64 curStage;
+        curStage.setStartClassifierRootNodeOffset(haarClassifierNodes.size());
+
+        curStage.setStageThreshold(oldCascade->stage_classifier[s].threshold);
+
+        int treesCount = oldCascade->stage_classifier[s].count;
+        for(int t = 0; t < treesCount; ++t) // bytrees
+        {                                
+            Ncv32u nodeId = 0;
+            CvHaarClassifier* tree = &oldCascade->stage_classifier[s].classifier[t];
+
+            int nodesCount = tree->count;
+            for(int n = 0; n < nodesCount; ++n)  //by features             
+            {   
+                CvHaarFeature* feature = &tree->haar_feature[n];
+
+                HaarClassifierNode128 curNode;                                        
+                curNode.setThreshold(tree->threshold[n]);
+                
+                HaarClassifierNodeDescriptor32 nodeLeft;
+                if ( tree->left[n] <= 0 )
+                {   
+                    Ncv32f leftVal = tree->alpha[-tree->left[n]];
+                    ncvStat = nodeLeft.create(leftVal);
+                    ncvAssertReturn(ncvStat == NCV_SUCCESS, ncvStat);                    
+                }
+                else
+                {   
+                    Ncv32u leftNodeOffset = tree->left[n];                        
+                    nodeLeft.create((Ncv32u)(h_TmpClassifierNotRootNodes.size() + leftNodeOffset - 1));
+                    haar.bHasStumpsOnly = false;
+                }
+                curNode.setLeftNodeDesc(nodeLeft);
+                
+                HaarClassifierNodeDescriptor32 nodeRight;
+                if ( tree->right[n] <= 0 )
+                {                                         
+                    Ncv32f rightVal = tree->alpha[-tree->right[n]];                        
+                    ncvStat = nodeRight.create(rightVal);
+                    ncvAssertReturn(ncvStat == NCV_SUCCESS, ncvStat);
+                }
+                else
+                {                                               
+                    Ncv32u rightNodeOffset = tree->right[n];                        
+                    nodeRight.create((Ncv32u)(h_TmpClassifierNotRootNodes.size() + rightNodeOffset - 1));
+                    haar.bHasStumpsOnly = false;
+                }
+                curNode.setRightNodeDesc(nodeRight);                    
+
+                Ncv32u tiltedVal = feature->tilted;
+                haar.bNeedsTiltedII = (tiltedVal != 0);                
+
+                Ncv32u featureId = 0;                    
+                for(int l = 0; l < CV_HAAR_FEATURE_MAX; ++l) //by rects
+                {                        
+                    Ncv32u rectX = feature->rect[l].r.x; 
+                    Ncv32u rectY = feature->rect[l].r.y;
+                    Ncv32u rectWidth = feature->rect[l].r.width;
+                    Ncv32u rectHeight = feature->rect[l].r.height;
+
+                    Ncv32f rectWeight = feature->rect[l].weight;
+
+                    if (rectWeight == 0/* && rectX == 0 &&rectY == 0 && rectWidth == 0 && rectHeight == 0*/)
+                        break;
+
+                    HaarFeature64 curFeature;
+                    ncvStat = curFeature.setRect(rectX, rectY, rectWidth, rectHeight, haar.ClassifierSize.width, haar.ClassifierSize.height);
+                    curFeature.setWeight(rectWeight);
+                    ncvAssertReturn(NCV_SUCCESS == ncvStat, ncvStat);
+                    haarFeatures.push_back(curFeature);
+
+                    featureId++;
+                }
+
+                HaarFeatureDescriptor32 tmpFeatureDesc;
+                ncvStat = tmpFeatureDesc.create(haar.bNeedsTiltedII, featureId, haarFeatures.size() - featureId);
+                ncvAssertReturn(NCV_SUCCESS == ncvStat, ncvStat);
+                curNode.setFeatureDesc(tmpFeatureDesc);
+
+                if (!nodeId)
+                {
+                    //root node
+                    haarClassifierNodes.push_back(curNode);
+                    curMaxTreeDepth = 1;
+                }
+                else
+                {
+                    //other node
+                    h_TmpClassifierNotRootNodes.push_back(curNode);
+                    curMaxTreeDepth++;
+                }
+
+                nodeId++;
+            }               
+        }
+
+        curStage.setNumClassifierRootNodes(treesCount);
+        haarStages.push_back(curStage);            
+    }
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+    //fill in cascade stats
+    haar.NumStages = haarStages.size();
+    haar.NumClassifierRootNodes = haarClassifierNodes.size();
+    haar.NumClassifierTotalNodes = haar.NumClassifierRootNodes + h_TmpClassifierNotRootNodes.size();
+    haar.NumFeatures = haarFeatures.size();
+
+    //merge root and leaf nodes in one classifiers array
+    Ncv32u offsetRoot = haarClassifierNodes.size();
+    for (Ncv32u i=0; i<haarClassifierNodes.size(); i++)
+    {
+        HaarClassifierNodeDescriptor32 nodeLeft = haarClassifierNodes[i].getLeftNodeDesc();
+        if (!nodeLeft.isLeaf())
+        {
+            Ncv32u newOffset = nodeLeft.getNextNodeOffset() + offsetRoot;
+            nodeLeft.create(newOffset);
+        }
+        haarClassifierNodes[i].setLeftNodeDesc(nodeLeft);
+
+        HaarClassifierNodeDescriptor32 nodeRight = haarClassifierNodes[i].getRightNodeDesc();
+        if (!nodeRight.isLeaf())
+        {
+            Ncv32u newOffset = nodeRight.getNextNodeOffset() + offsetRoot;
+            nodeRight.create(newOffset);
+        }
+        haarClassifierNodes[i].setRightNodeDesc(nodeRight);
+    }
+    for (Ncv32u i=0; i<h_TmpClassifierNotRootNodes.size(); i++)
+    {
+        HaarClassifierNodeDescriptor32 nodeLeft = h_TmpClassifierNotRootNodes[i].getLeftNodeDesc();
+        if (!nodeLeft.isLeaf())
+        {
+            Ncv32u newOffset = nodeLeft.getNextNodeOffset() + offsetRoot;
+            nodeLeft.create(newOffset);
+        }
+        h_TmpClassifierNotRootNodes[i].setLeftNodeDesc(nodeLeft);
+
+        HaarClassifierNodeDescriptor32 nodeRight = h_TmpClassifierNotRootNodes[i].getRightNodeDesc();
+        if (!nodeRight.isLeaf())
+        {
+            Ncv32u newOffset = nodeRight.getNextNodeOffset() + offsetRoot;
+            nodeRight.create(newOffset);
+        }
+        h_TmpClassifierNotRootNodes[i].setRightNodeDesc(nodeRight);
+
+        haarClassifierNodes.push_back(h_TmpClassifierNotRootNodes[i]);
+    }
+
+    return NCV_SUCCESS;
 }
 
-void cv::gpu::CascadeClassifier::detectMultiScale( const Mat& image, vector<Rect>& objects, double scaleFactor, 
-    int minNeighbors, int flags, Size minSize, Size maxSize)
+////
+
+#else /* loadFromXML implementation switch */
 
+#include "e:/devNPP-OpenCV/src/external/_rapidxml-1.13/rapidxml.hpp"
+
+NCVStatus loadFromXML(const std::string &filename,
+                      HaarClassifierCascadeDescriptor &haar,
+                      std::vector<HaarStage64> &haarStages,
+                      std::vector<HaarClassifierNode128> &haarClassifierNodes,
+                      std::vector<HaarFeature64> &haarFeatures)
 {
+    NCVStatus ncvStat;
+
+    haar.NumStages = 0;
+    haar.NumClassifierRootNodes = 0;
+    haar.NumClassifierTotalNodes = 0;
+    haar.NumFeatures = 0;
+    haar.ClassifierSize.width = 0;
+    haar.ClassifierSize.height = 0;
+    haar.bNeedsTiltedII = false;
+    haar.bHasStumpsOnly = false;
+
+    FILE *fp;
+    fopen_s(&fp, filename.c_str(), "r");
+    ncvAssertReturn(fp != NULL, NCV_FILE_ERROR);
+
+    //get file size
+    fseek(fp, 0, SEEK_END);
+    Ncv32u xmlSize = ftell(fp);
+    fseek(fp, 0, SEEK_SET);
+
+    //load file to vector
+    std::vector<char> xmlFileCont;
+    xmlFileCont.resize(xmlSize+1);
+    memset(&xmlFileCont[0], 0, xmlSize+1);
+    fread_s(&xmlFileCont[0], xmlSize, 1, xmlSize, fp);
+    fclose(fp);
+
+    haar.bHasStumpsOnly = true;
+    haar.bNeedsTiltedII = false;
+    Ncv32u curMaxTreeDepth;
+
+    std::vector<HaarClassifierNode128> h_TmpClassifierNotRootNodes;
+    haarStages.resize(0);
+    haarClassifierNodes.resize(0);
+    haarFeatures.resize(0);
+
+    //XML loading and OpenCV XML classifier syntax verification
+    try
+    {
+        rapidxml::xml_document<> doc;
+        doc.parse<0>(&xmlFileCont[0]);
+
+        //opencv_storage
+        rapidxml::xml_node<> *parserGlobal = doc.first_node();
+        ncvAssertReturn(!strcmp(parserGlobal->name(), "opencv_storage"), NCV_HAAR_XML_LOADING_EXCEPTION);
+
+        //classifier type
+        parserGlobal = parserGlobal->first_node();
+        ncvAssertReturn(parserGlobal, NCV_HAAR_XML_LOADING_EXCEPTION);
+        rapidxml::xml_attribute<> *attr = parserGlobal->first_attribute("type_id");
+        ncvAssertReturn(!strcmp(attr->value(), "opencv-haar-classifier"), NCV_HAAR_XML_LOADING_EXCEPTION);
 
+        //classifier size
+        parserGlobal = parserGlobal->first_node("size");
+        ncvAssertReturn(parserGlobal, NCV_HAAR_XML_LOADING_EXCEPTION);
+        sscanf_s(parserGlobal->value(), "%d %d", &(haar.ClassifierSize.width), &(haar.ClassifierSize.height));
+
+        //parse stages
+        parserGlobal = parserGlobal->next_sibling("stages");
+        ncvAssertReturn(parserGlobal, NCV_HAAR_XML_LOADING_EXCEPTION);
+        parserGlobal = parserGlobal->first_node("_");
+        ncvAssertReturn(parserGlobal, NCV_HAAR_XML_LOADING_EXCEPTION);
+
+        while (parserGlobal)
+        {
+            HaarStage64 curStage;
+            curStage.setStartClassifierRootNodeOffset(haarClassifierNodes.size());
+            Ncv32u tmpNumClassifierRootNodes = 0;
+
+            rapidxml::xml_node<> *parserStageThreshold = parserGlobal->first_node("stage_threshold");
+            ncvAssertReturn(parserStageThreshold, NCV_HAAR_XML_LOADING_EXCEPTION);
+            Ncv32f tmpStageThreshold;
+            sscanf_s(parserStageThreshold->value(), "%f", &tmpStageThreshold);
+            curStage.setStageThreshold(tmpStageThreshold);
+
+            //parse trees
+            rapidxml::xml_node<> *parserTree;
+            parserTree = parserGlobal->first_node("trees");
+            ncvAssertReturn(parserTree, NCV_HAAR_XML_LOADING_EXCEPTION);
+            parserTree = parserTree->first_node("_");
+            ncvAssertReturn(parserTree, NCV_HAAR_XML_LOADING_EXCEPTION);
+
+            while (parserTree)
+            {
+                rapidxml::xml_node<> *parserNode;
+                parserNode = parserTree->first_node("_");
+                ncvAssertReturn(parserNode, NCV_HAAR_XML_LOADING_EXCEPTION);
+                Ncv32u nodeId = 0;
+
+                while (parserNode)
+                {
+                    HaarClassifierNode128 curNode;
+
+                    rapidxml::xml_node<> *parserNodeThreshold = parserNode->first_node("threshold");
+                    ncvAssertReturn(parserNodeThreshold, NCV_HAAR_XML_LOADING_EXCEPTION);
+                    Ncv32f tmpThreshold;
+                    sscanf_s(parserNodeThreshold->value(), "%f", &tmpThreshold);
+                    curNode.setThreshold(tmpThreshold);
+
+                    rapidxml::xml_node<> *parserNodeLeft = parserNode->first_node("left_val");
+                    HaarClassifierNodeDescriptor32 nodeLeft;
+                    if (parserNodeLeft)
+                    {
+                        Ncv32f leftVal;
+                        sscanf_s(parserNodeLeft->value(), "%f", &leftVal);
+                        ncvStat = nodeLeft.create(leftVal);
+                        ncvAssertReturn(ncvStat == NCV_SUCCESS, ncvStat);
+                    }
+                    else
+                    {
+                        parserNodeLeft = parserNode->first_node("left_node");
+                        ncvAssertReturn(parserNodeLeft, NCV_HAAR_XML_LOADING_EXCEPTION);
+                        Ncv32u leftNodeOffset;
+                        sscanf_s(parserNodeLeft->value(), "%d", &leftNodeOffset);
+                        nodeLeft.create(h_TmpClassifierNotRootNodes.size() + leftNodeOffset - 1);
+                        haar.bHasStumpsOnly = false;
+                    }
+                    curNode.setLeftNodeDesc(nodeLeft);
+
+                    rapidxml::xml_node<> *parserNodeRight = parserNode->first_node("right_val");
+                    HaarClassifierNodeDescriptor32 nodeRight;
+                    if (parserNodeRight)
+                    {
+                        Ncv32f rightVal;
+                        sscanf_s(parserNodeRight->value(), "%f", &rightVal);
+                        ncvStat = nodeRight.create(rightVal);
+                        ncvAssertReturn(ncvStat == NCV_SUCCESS, ncvStat);
+                    }
+                    else
+                    {
+                        parserNodeRight = parserNode->first_node("right_node");
+                        ncvAssertReturn(parserNodeRight, NCV_HAAR_XML_LOADING_EXCEPTION);
+                        Ncv32u rightNodeOffset;
+                        sscanf_s(parserNodeRight->value(), "%d", &rightNodeOffset);
+                        nodeRight.create(h_TmpClassifierNotRootNodes.size() + rightNodeOffset - 1);
+                        haar.bHasStumpsOnly = false;
+                    }
+                    curNode.setRightNodeDesc(nodeRight);
+
+                    rapidxml::xml_node<> *parserNodeFeatures = parserNode->first_node("feature");
+                    ncvAssertReturn(parserNodeFeatures, NCV_HAAR_XML_LOADING_EXCEPTION);
+
+                    rapidxml::xml_node<> *parserNodeFeaturesTilted = parserNodeFeatures->first_node("tilted");
+                    ncvAssertReturn(parserNodeFeaturesTilted, NCV_HAAR_XML_LOADING_EXCEPTION);
+                    Ncv32u tiltedVal;
+                    sscanf_s(parserNodeFeaturesTilted->value(), "%d", &tiltedVal);
+                    haar.bNeedsTiltedII = (tiltedVal != 0);
+
+                    rapidxml::xml_node<> *parserNodeFeaturesRects = parserNodeFeatures->first_node("rects");
+                    ncvAssertReturn(parserNodeFeaturesRects, NCV_HAAR_XML_LOADING_EXCEPTION);
+                    parserNodeFeaturesRects = parserNodeFeaturesRects->first_node("_");
+                    ncvAssertReturn(parserNodeFeaturesRects, NCV_HAAR_XML_LOADING_EXCEPTION);
+                    Ncv32u featureId = 0;
+
+                    while (parserNodeFeaturesRects)
+                    {
+                        Ncv32u rectX, rectY, rectWidth, rectHeight;
+                        Ncv32f rectWeight;
+                        sscanf_s(parserNodeFeaturesRects->value(), "%d %d %d %d %f", &rectX, &rectY, &rectWidth, &rectHeight, &rectWeight);
+                        HaarFeature64 curFeature;
+                        ncvStat = curFeature.setRect(rectX, rectY, rectWidth, rectHeight, haar.ClassifierSize.width, haar.ClassifierSize.height);
+                        curFeature.setWeight(rectWeight);
+                        ncvAssertReturn(NCV_SUCCESS == ncvStat, ncvStat);
+                        haarFeatures.push_back(curFeature);
+
+                        parserNodeFeaturesRects = parserNodeFeaturesRects->next_sibling("_");
+                        featureId++;
+                    }
+
+                    HaarFeatureDescriptor32 tmpFeatureDesc;
+                    ncvStat = tmpFeatureDesc.create(haar.bNeedsTiltedII, featureId, haarFeatures.size() - featureId);
+                    ncvAssertReturn(NCV_SUCCESS == ncvStat, ncvStat);
+                    curNode.setFeatureDesc(tmpFeatureDesc);
+
+                    if (!nodeId)
+                    {
+                        //root node
+                        haarClassifierNodes.push_back(curNode);
+                        curMaxTreeDepth = 1;
+                    }
+                    else
+                    {
+                        //other node
+                        h_TmpClassifierNotRootNodes.push_back(curNode);
+                        curMaxTreeDepth++;
+                    }
+
+                    parserNode = parserNode->next_sibling("_");
+                    nodeId++;
+                }
+
+                parserTree = parserTree->next_sibling("_");
+                tmpNumClassifierRootNodes++;
+            }
+
+            curStage.setNumClassifierRootNodes(tmpNumClassifierRootNodes);
+            haarStages.push_back(curStage);
+
+            parserGlobal = parserGlobal->next_sibling("_");
+        }
+    }
+    catch (...)
+    {
+        return NCV_HAAR_XML_LOADING_EXCEPTION;
+    }
+
+    //fill in cascade stats
+    haar.NumStages = haarStages.size();
+    haar.NumClassifierRootNodes = haarClassifierNodes.size();
+    haar.NumClassifierTotalNodes = haar.NumClassifierRootNodes + h_TmpClassifierNotRootNodes.size();
+    haar.NumFeatures = haarFeatures.size();
+
+    //merge root and leaf nodes in one classifiers array
+    Ncv32u offsetRoot = haarClassifierNodes.size();
+    for (Ncv32u i=0; i<haarClassifierNodes.size(); i++)
+    {
+        HaarClassifierNodeDescriptor32 nodeLeft = haarClassifierNodes[i].getLeftNodeDesc();
+        if (!nodeLeft.isLeaf())
+        {
+            Ncv32u newOffset = nodeLeft.getNextNodeOffset() + offsetRoot;
+            nodeLeft.create(newOffset);
+        }
+        haarClassifierNodes[i].setLeftNodeDesc(nodeLeft);
+
+        HaarClassifierNodeDescriptor32 nodeRight = haarClassifierNodes[i].getRightNodeDesc();
+        if (!nodeRight.isLeaf())
+        {
+            Ncv32u newOffset = nodeRight.getNextNodeOffset() + offsetRoot;
+            nodeRight.create(newOffset);
+        }
+        haarClassifierNodes[i].setRightNodeDesc(nodeRight);
+    }
+    for (Ncv32u i=0; i<h_TmpClassifierNotRootNodes.size(); i++)
+    {
+        HaarClassifierNodeDescriptor32 nodeLeft = h_TmpClassifierNotRootNodes[i].getLeftNodeDesc();
+        if (!nodeLeft.isLeaf())
+        {
+            Ncv32u newOffset = nodeLeft.getNextNodeOffset() + offsetRoot;
+            nodeLeft.create(newOffset);
+        }
+        h_TmpClassifierNotRootNodes[i].setLeftNodeDesc(nodeLeft);
+
+        HaarClassifierNodeDescriptor32 nodeRight = h_TmpClassifierNotRootNodes[i].getRightNodeDesc();
+        if (!nodeRight.isLeaf())
+        {
+            Ncv32u newOffset = nodeRight.getNextNodeOffset() + offsetRoot;
+            nodeRight.create(newOffset);
+        }
+        h_TmpClassifierNotRootNodes[i].setRightNodeDesc(nodeRight);
+
+        haarClassifierNodes.push_back(h_TmpClassifierNotRootNodes[i]);
+    }
+
+    return NCV_SUCCESS;
 }
 
-#endif
\ No newline at end of file
+#endif /* loadFromXML implementation switch */
+
+#endif /* HAVE_CUDA */
+
+
diff --git a/modules/gpu/src/cuda/internal_shared.hpp b/modules/gpu/src/cuda/internal_shared.hpp
index 6bf060d396..e82700ed9c 100644
--- a/modules/gpu/src/cuda/internal_shared.hpp
+++ b/modules/gpu/src/cuda/internal_shared.hpp
@@ -62,7 +62,7 @@ namespace cv
             BORDER_REPLICATE_GPU,
             BORDER_CONSTANT_GPU
         };
-        
+                
         // Converts CPU border extrapolation mode into GPU internal analogue.
         // Returns true if the GPU analogue exists, false otherwise.
         bool tryConvertToGpuBorderType(int cpuBorderType, int& gpuBorderType);
@@ -105,8 +105,28 @@ namespace cv
             const textureReference* tex; 
             cudaSafeCall( cudaGetTextureReference(&tex, name) ); 
             cudaSafeCall( cudaUnbindTexture(tex) );
-        }        
+        }    
+
+        struct KeyPoint_GPU
+        {
+            float x;
+            float y;
+            float size;
+            float response;
+            float angle;
+            float octave;
+        };
 
+        enum KeypointLayout 
+        {
+            SF_X,
+            SF_Y,
+            SF_SIZE,
+            SF_RESPONSE,
+            SF_ANGLE,
+            SF_OCTAVE,
+            SF_FEATURE_STRIDE
+        };
     }
 }
 
diff --git a/modules/gpu/src/cuda/surf_key_point.h b/modules/gpu/src/cuda/surf_key_point.h
index aa3612e186..31370042ee 100644
--- a/modules/gpu/src/cuda/surf_key_point.h
+++ b/modules/gpu/src/cuda/surf_key_point.h
@@ -47,29 +47,7 @@ namespace cv
 {
     namespace gpu
     {
-        namespace surf
-        {
-            struct KeyPoint_GPU
-            {
-                float x;
-                float y;
-                float size;
-                float response;
-                float angle;
-                float octave;
-            };
-
-            enum KeypointLayout 
-            {
-                SF_X,
-                SF_Y,
-                SF_SIZE,
-                SF_RESPONSE,
-                SF_ANGLE,
-                SF_OCTAVE,
-                SF_FEATURE_STRIDE
-            };
-        }
+       
     }
 }
 
diff --git a/modules/gpu/src/element_operations.cpp b/modules/gpu/src/element_operations.cpp
index 78c9b6d484..4d61cc3532 100644
--- a/modules/gpu/src/element_operations.cpp
+++ b/modules/gpu/src/element_operations.cpp
@@ -82,21 +82,16 @@ void cv::gpu::max(const GpuMat&, double, GpuMat&, const Stream&) { throw_nogpu()
 
 namespace
 {
-    typedef NppStatus (*npp_arithm_8u_t)(const Npp8u* pSrc1, int nSrc1Step, const Npp8u* pSrc2, int nSrc2Step, Npp8u* pDst, int nDstStep,
-                                         NppiSize oSizeROI, int nScaleFactor);
-    typedef NppStatus (*npp_arithm_32s_t)(const Npp32s* pSrc1, int nSrc1Step, const Npp32s* pSrc2, int nSrc2Step, Npp32s* pDst,
-                                          int nDstStep, NppiSize oSizeROI);
-    typedef NppStatus (*npp_arithm_32f_t)(const Npp32f* pSrc1, int nSrc1Step, const Npp32f* pSrc2, int nSrc2Step, Npp32f* pDst,
-                                          int nDstStep, NppiSize oSizeROI);
+    typedef NppStatus (*npp_arithm_8u_t)(const Npp8u* pSrc1, int nSrc1Step, const Npp8u* pSrc2, int nSrc2Step, Npp8u* pDst, int nDstStep, NppiSize oSizeROI, int nScaleFactor);
+    typedef NppStatus (*npp_arithm_32s_t)(const Npp32s* pSrc1, int nSrc1Step, const Npp32s* pSrc2, int nSrc2Step, Npp32s* pDst, int nDstStep, NppiSize oSizeROI);
+    typedef NppStatus (*npp_arithm_32f_t)(const Npp32f* pSrc1, int nSrc1Step, const Npp32f* pSrc2, int nSrc2Step, Npp32f* pDst, int nDstStep, NppiSize oSizeROI);
 
     void nppArithmCaller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst,
                          npp_arithm_8u_t npp_func_8uc1, npp_arithm_8u_t npp_func_8uc4,
                          npp_arithm_32s_t npp_func_32sc1, npp_arithm_32f_t npp_func_32fc1)
     {
         CV_DbgAssert(src1.size() == src2.size() && src1.type() == src2.type());
-
         CV_Assert(src1.type() == CV_8UC1 || src1.type() == CV_8UC4 || src1.type() == CV_32SC1 || src1.type() == CV_32FC1);
-
         dst.create( src1.size(), src1.type() );
 
         NppiSize sz;
@@ -106,24 +101,16 @@ namespace
         switch (src1.type())
         {
         case CV_8UC1:
-            nppSafeCall( npp_func_8uc1(src1.ptr<Npp8u>(), src1.step,
-                src2.ptr<Npp8u>(), src2.step,
-                dst.ptr<Npp8u>(), dst.step, sz, 0) );
+            nppSafeCall( npp_func_8uc1(src1.ptr<Npp8u>(), src1.step, src2.ptr<Npp8u>(), src2.step, dst.ptr<Npp8u>(), dst.step, sz, 0) );
             break;
         case CV_8UC4:
-            nppSafeCall( npp_func_8uc4(src1.ptr<Npp8u>(), src1.step,
-                src2.ptr<Npp8u>(), src2.step,
-                dst.ptr<Npp8u>(), dst.step, sz, 0) );
+            nppSafeCall( npp_func_8uc4(src1.ptr<Npp8u>(), src1.step, src2.ptr<Npp8u>(), src2.step, dst.ptr<Npp8u>(), dst.step, sz, 0) );
             break;
         case CV_32SC1:
-            nppSafeCall( npp_func_32sc1(src1.ptr<Npp32s>(), src1.step,
-                src2.ptr<Npp32s>(), src2.step,
-                dst.ptr<Npp32s>(), dst.step, sz) );
+            nppSafeCall( npp_func_32sc1(src1.ptr<Npp32s>(), src1.step, src2.ptr<Npp32s>(), src2.step, dst.ptr<Npp32s>(), dst.step, sz) );
             break;
         case CV_32FC1:
-            nppSafeCall( npp_func_32fc1(src1.ptr<Npp32f>(), src1.step,
-                src2.ptr<Npp32f>(), src2.step,
-                dst.ptr<Npp32f>(), dst.step, sz) );
+            nppSafeCall( npp_func_32fc1(src1.ptr<Npp32f>(), src1.step, src2.ptr<Npp32f>(), src2.step, dst.ptr<Npp32f>(), dst.step, sz) );
             break;
         default:
             CV_Assert(!"Unsupported source type");
@@ -133,16 +120,15 @@ namespace
     template<int SCN> struct NppArithmScalarFunc;
     template<> struct NppArithmScalarFunc<1>
     {
-        typedef NppStatus (*func_ptr)(const Npp32f *pSrc, int nSrcStep, Npp32f nValue, Npp32f *pDst,
-                                      int nDstStep, NppiSize oSizeROI);
+        typedef NppStatus (*func_ptr)(const Npp32f *pSrc, int nSrcStep, Npp32f nValue, Npp32f *pDst, int nDstStep, NppiSize oSizeROI);
     };
     template<> struct NppArithmScalarFunc<2>
     {
-        typedef NppStatus (*func_ptr)(const Npp32fc *pSrc, int nSrcStep, Npp32fc nValue, Npp32fc *pDst,
-                                      int nDstStep, NppiSize oSizeROI);
+        typedef NppStatus (*func_ptr)(const Npp32fc *pSrc, int nSrcStep, Npp32fc nValue, Npp32fc *pDst, int nDstStep, NppiSize oSizeROI);
     };
 
     template<int SCN, typename NppArithmScalarFunc<SCN>::func_ptr func> struct NppArithmScalar;
+
     template<typename NppArithmScalarFunc<1>::func_ptr func> struct NppArithmScalar<1, func>
     {
         static void calc(const GpuMat& src, const Scalar& sc, GpuMat& dst)
@@ -254,24 +240,16 @@ void cv::gpu::absdiff(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
     switch (src1.type())
     {
     case CV_8UC1:
-        nppSafeCall( nppiAbsDiff_8u_C1R(src1.ptr<Npp8u>(), src1.step,
-            src2.ptr<Npp8u>(), src2.step,
-            dst.ptr<Npp8u>(), dst.step, sz) );
+        nppSafeCall( nppiAbsDiff_8u_C1R(src1.ptr<Npp8u>(), src1.step, src2.ptr<Npp8u>(), src2.step, dst.ptr<Npp8u>(), dst.step, sz) );
         break;
     case CV_8UC4:
-        nppSafeCall( nppiAbsDiff_8u_C4R(src1.ptr<Npp8u>(), src1.step,
-            src2.ptr<Npp8u>(), src2.step,
-            dst.ptr<Npp8u>(), dst.step, sz) );
+        nppSafeCall( nppiAbsDiff_8u_C4R(src1.ptr<Npp8u>(), src1.step, src2.ptr<Npp8u>(), src2.step, dst.ptr<Npp8u>(), dst.step, sz) );
         break;
     case CV_32SC1:
-        nppSafeCall( nppiAbsDiff_32s_C1R(src1.ptr<Npp32s>(), src1.step,
-            src2.ptr<Npp32s>(), src2.step,
-            dst.ptr<Npp32s>(), dst.step, sz) );
+        nppSafeCall( nppiAbsDiff_32s_C1R(src1.ptr<Npp32s>(), src1.step, src2.ptr<Npp32s>(), src2.step, dst.ptr<Npp32s>(), dst.step, sz) );
         break;
     case CV_32FC1:
-        nppSafeCall( nppiAbsDiff_32f_C1R(src1.ptr<Npp32f>(), src1.step,
-            src2.ptr<Npp32f>(), src2.step,
-            dst.ptr<Npp32f>(), dst.step, sz) );
+        nppSafeCall( nppiAbsDiff_32f_C1R(src1.ptr<Npp32f>(), src1.step, src2.ptr<Npp32f>(), src2.step, dst.ptr<Npp32f>(), dst.step, sz) );
         break;
     default:
         CV_Assert(!"Unsupported source type");
diff --git a/modules/gpu/src/nvidia/FaceDetectionFeed.cpp_NvidiaAPI_sample b/modules/gpu/src/nvidia/FaceDetectionFeed.cpp_NvidiaAPI_sample
new file mode 100644
index 0000000000..c1926a38c2
--- /dev/null
+++ b/modules/gpu/src/nvidia/FaceDetectionFeed.cpp_NvidiaAPI_sample
@@ -0,0 +1,362 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 
+// 
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2009-2010, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <cstdio>
+#include <cuda_runtime.h>
+
+#define CV_NO_BACKWARD_COMPATIBILITY
+
+#include "opencv2/opencv.hpp"
+
+#include "NCVHaarObjectDetection.hpp"
+
+using namespace cv;
+using namespace std;
+
+const Size preferredVideoFrameSize(640, 480);
+
+string preferredClassifier = "haarcascade_frontalface_alt.xml";
+string wndTitle = "NVIDIA Computer Vision SDK :: Face Detection in Video Feed";
+
+
+void printSyntax(void)
+{
+    printf("Syntax: FaceDetectionFeed.exe [-c cameranum | -v filename] classifier.xml\n");
+}
+
+
+void imagePrintf(Mat& img, int lineOffsY, Scalar color, const char *format, ...)
+{    
+    int fontFace = CV_FONT_HERSHEY_PLAIN;
+    double fontScale = 1;       
+    
+    int baseline;
+    Size textSize = cv::getTextSize("T", fontFace, fontScale, 1, &baseline);
+
+    va_list arg_ptr;
+    va_start(arg_ptr, format);
+    int len = _vscprintf(format, arg_ptr) + 1;
+    
+    vector<char> strBuf(len);    
+    vsprintf_s(&strBuf[0], len, format, arg_ptr);
+
+    Point org(1, 3 * textSize.height * (lineOffsY + 1) / 2);    
+    putText(img, &strBuf[0], org, fontFace, fontScale, color);
+    va_end(arg_ptr);    
+}
+
+
+NCVStatus process(Mat *srcdst,
+                  Ncv32u width, Ncv32u height,
+                  NcvBool bShowAllHypotheses, NcvBool bLargestFace,
+                  HaarClassifierCascadeDescriptor &haar,
+                  NCVVector<HaarStage64> &d_haarStages, NCVVector<HaarClassifierNode128> &d_haarNodes,
+                  NCVVector<HaarFeature64> &d_haarFeatures, NCVVector<HaarStage64> &h_haarStages,
+                  INCVMemAllocator &gpuAllocator,
+                  INCVMemAllocator &cpuAllocator,
+                  cudaDeviceProp &devProp)
+{
+    ncvAssertReturn(!((srcdst == NULL) ^ gpuAllocator.isCounting()), NCV_NULL_PTR);
+
+    NCVStatus ncvStat;
+
+    NCV_SET_SKIP_COND(gpuAllocator.isCounting());
+
+    NCVMatrixAlloc<Ncv8u> d_src(gpuAllocator, width, height);
+    ncvAssertReturn(d_src.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    NCVMatrixAlloc<Ncv8u> h_src(cpuAllocator, width, height);
+    ncvAssertReturn(h_src.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    NCVVectorAlloc<NcvRect32u> d_rects(gpuAllocator, 100);        
+    ncvAssertReturn(d_rects.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    Mat h_src_hdr(Size(width, height), CV_8U, h_src.ptr(), h_src.stride());
+
+    NCV_SKIP_COND_BEGIN        
+    
+    (*srcdst).copyTo(h_src_hdr);
+    
+    ncvStat = h_src.copySolid(d_src, 0);
+    ncvAssertReturnNcvStat(ncvStat);
+    ncvAssertCUDAReturn(cudaStreamSynchronize(0), NCV_CUDA_ERROR);
+
+    NCV_SKIP_COND_END
+
+    NcvSize32u roi;
+    roi.width = d_src.width();
+    roi.height = d_src.height();
+
+    Ncv32u numDetections;
+    ncvStat = ncvDetectObjectsMultiScale_device(
+        d_src, roi, d_rects, numDetections, haar, h_haarStages,
+        d_haarStages, d_haarNodes, d_haarFeatures,
+        haar.ClassifierSize,
+        bShowAllHypotheses ? 0 : 4,
+        1.2f, 1,
+        (bLargestFace ? NCVPipeObjDet_FindLargestObject : 0) | NCVPipeObjDet_VisualizeInPlace,
+        gpuAllocator, cpuAllocator, devProp.major, devProp.minor, 0);
+    ncvAssertReturnNcvStat(ncvStat);
+    ncvAssertCUDAReturn(cudaStreamSynchronize(0), NCV_CUDA_ERROR);
+
+    NCV_SKIP_COND_BEGIN
+
+    ncvStat = d_src.copySolid(h_src, 0);
+    ncvAssertReturnNcvStat(ncvStat);
+    ncvAssertCUDAReturn(cudaStreamSynchronize(0), NCV_CUDA_ERROR);
+
+    h_src_hdr.copyTo(*srcdst);
+    
+    NCV_SKIP_COND_END
+
+    return NCV_SUCCESS;
+}
+
+
+int main( int argc, const char** argv )
+{
+    NCVStatus ncvStat;
+
+    printf("NVIDIA Computer Vision SDK\n");
+    printf("Face Detection in video and live feed\n");
+    printf("=========================================\n");
+    printf("  Esc   - Quit\n");
+    printf("  Space - Switch between NCV and OpenCV\n");
+    printf("  L     - Switch between FullSearch and LargestFace modes\n");
+    printf("  U     - Toggle unfiltered hypotheses visualization in FullSearch\n");
+    
+    if (argc != 4 && argc != 1)
+        return printSyntax(), -1;
+
+    VideoCapture capture;    
+    Size frameSize;
+
+    if (argc == 1 || strcmp(argv[1], "-c") == 0)
+    {
+        // Camera input is specified
+        int camIdx = (argc == 3) ? atoi(argv[2]) : 0;
+        if(!capture.open(camIdx))        
+            return printf("Error opening camera\n"), -1;        
+            
+        capture.set(CV_CAP_PROP_FRAME_WIDTH, preferredVideoFrameSize.width);
+        capture.set(CV_CAP_PROP_FRAME_HEIGHT, preferredVideoFrameSize.height);
+        capture.set(CV_CAP_PROP_FPS, 25);
+        frameSize = preferredVideoFrameSize;
+    }
+    else if (strcmp(argv[1], "-v") == 0)
+    {
+        // Video file input (avi)
+        if(!capture.open(argv[2]))
+            return printf("Error opening video file\n"), -1;
+
+        frameSize.width  = (int)capture.get(CV_CAP_PROP_FRAME_WIDTH);
+        frameSize.height = (int)capture.get(CV_CAP_PROP_FRAME_HEIGHT);
+    }
+    else
+        return printSyntax(), -1;
+
+    NcvBool bUseOpenCV = true;
+    NcvBool bLargestFace = true;
+    NcvBool bShowAllHypotheses = false;    
+
+    string classifierFile = (argc == 1) ? preferredClassifier : argv[3];
+    
+    CascadeClassifier classifierOpenCV;
+    if (!classifierOpenCV.load(classifierFile))
+        return printf("Error (in OpenCV) opening classifier\n"), printSyntax(), -1;
+
+    int devId;
+    ncvAssertCUDAReturn(cudaGetDevice(&devId), -1);
+    cudaDeviceProp devProp;
+    ncvAssertCUDAReturn(cudaGetDeviceProperties(&devProp, devId), -1);
+    printf("Using GPU %d %s, arch=%d.%d\n", devId, devProp.name, devProp.major, devProp.minor);
+
+    //==============================================================================
+    //
+    // Load the classifier from file (assuming its size is about 1 mb)
+    // using a simple allocator
+    //
+    //==============================================================================
+
+    NCVMemNativeAllocator gpuCascadeAllocator(NCVMemoryTypeDevice);
+    ncvAssertPrintReturn(gpuCascadeAllocator.isInitialized(), "Error creating cascade GPU allocator", -1);
+    NCVMemNativeAllocator cpuCascadeAllocator(NCVMemoryTypeHostPinned);
+    ncvAssertPrintReturn(cpuCascadeAllocator.isInitialized(), "Error creating cascade CPU allocator", -1);
+
+    Ncv32u haarNumStages, haarNumNodes, haarNumFeatures;
+    ncvStat = ncvHaarGetClassifierSize(classifierFile, haarNumStages, haarNumNodes, haarNumFeatures);
+    ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error reading classifier size (check the file)", -1);
+
+    NCVVectorAlloc<HaarStage64> h_haarStages(cpuCascadeAllocator, haarNumStages);
+    ncvAssertPrintReturn(h_haarStages.isMemAllocated(), "Error in cascade CPU allocator", -1);
+    NCVVectorAlloc<HaarClassifierNode128> h_haarNodes(cpuCascadeAllocator, haarNumNodes);
+    ncvAssertPrintReturn(h_haarNodes.isMemAllocated(), "Error in cascade CPU allocator", -1);
+    NCVVectorAlloc<HaarFeature64> h_haarFeatures(cpuCascadeAllocator, haarNumFeatures);
+    ncvAssertPrintReturn(h_haarFeatures.isMemAllocated(), "Error in cascade CPU allocator", -1);
+
+    HaarClassifierCascadeDescriptor haar;
+    ncvStat = ncvHaarLoadFromFile_host(classifierFile, haar, h_haarStages, h_haarNodes, h_haarFeatures);
+    ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error loading classifier", -1);
+
+    NCVVectorAlloc<HaarStage64> d_haarStages(gpuCascadeAllocator, haarNumStages);
+    ncvAssertPrintReturn(d_haarStages.isMemAllocated(), "Error in cascade GPU allocator", -1);
+    NCVVectorAlloc<HaarClassifierNode128> d_haarNodes(gpuCascadeAllocator, haarNumNodes);
+    ncvAssertPrintReturn(d_haarNodes.isMemAllocated(), "Error in cascade GPU allocator", -1);
+    NCVVectorAlloc<HaarFeature64> d_haarFeatures(gpuCascadeAllocator, haarNumFeatures);
+    ncvAssertPrintReturn(d_haarFeatures.isMemAllocated(), "Error in cascade GPU allocator", -1);
+
+    ncvStat = h_haarStages.copySolid(d_haarStages, 0);
+    ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error copying cascade to GPU", -1);
+    ncvStat = h_haarNodes.copySolid(d_haarNodes, 0);
+    ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error copying cascade to GPU", -1);
+    ncvStat = h_haarFeatures.copySolid(d_haarFeatures, 0);
+    ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error copying cascade to GPU", -1);
+
+    //==============================================================================
+    //
+    // Calculate memory requirements and create real allocators
+    //
+    //==============================================================================
+
+    NCVMemStackAllocator gpuCounter(devProp.textureAlignment);
+    ncvAssertPrintReturn(gpuCounter.isInitialized(), "Error creating GPU memory counter", -1);
+    NCVMemStackAllocator cpuCounter(devProp.textureAlignment);
+    ncvAssertPrintReturn(cpuCounter.isInitialized(), "Error creating CPU memory counter", -1);
+
+    ncvStat = process(NULL, frameSize.width, frameSize.height,
+                      false, false, haar,
+                      d_haarStages, d_haarNodes,
+                      d_haarFeatures, h_haarStages,
+                      gpuCounter, cpuCounter, devProp);
+    ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error in memory counting pass", -1);
+
+    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, gpuCounter.maxSize(), devProp.textureAlignment);
+    ncvAssertPrintReturn(gpuAllocator.isInitialized(), "Error creating GPU memory allocator", -1);
+    NCVMemStackAllocator cpuAllocator(NCVMemoryTypeHostPinned, cpuCounter.maxSize(), devProp.textureAlignment);
+    ncvAssertPrintReturn(cpuAllocator.isInitialized(), "Error creating CPU memory allocator", -1);
+
+    printf("Initialized for frame size [%dx%d]\n", frameSize.width, frameSize.height);
+
+    //==============================================================================
+    //
+    // Main processing loop
+    //
+    //==============================================================================
+    
+    namedWindow(wndTitle, 1);
+
+    Mat frame, gray, frameDisp;
+
+    for(;;)
+    {
+        // For camera and video file, capture the next image                
+        capture >> frame;
+        if (frame.empty())
+            break;
+                
+        cvtColor(frame, gray, CV_BGR2GRAY);
+
+        // process
+        NcvSize32u minSize = haar.ClassifierSize;
+        if (bLargestFace)
+        {
+            Ncv32u ratioX = preferredVideoFrameSize.width / minSize.width;
+            Ncv32u ratioY = preferredVideoFrameSize.height / minSize.height;
+            Ncv32u ratioSmallest = std::min(ratioX, ratioY);
+            ratioSmallest = (Ncv32u)std::max(ratioSmallest / 2.5f, 1.f);
+            minSize.width *= ratioSmallest;
+            minSize.height *= ratioSmallest;
+        }
+        
+        NcvTimer timer = ncvStartTimer();
+
+        if (!bUseOpenCV)
+        {
+            ncvStat = process(&gray, frameSize.width, frameSize.height,
+                              bShowAllHypotheses, bLargestFace, haar,
+                              d_haarStages, d_haarNodes,
+                              d_haarFeatures, h_haarStages,
+                              gpuAllocator, cpuAllocator, devProp);
+            ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error in memory counting pass", -1);
+        }
+        else
+        {
+            vector<Rect> rectsOpenCV;
+
+            classifierOpenCV.detectMultiScale(
+                gray,
+                rectsOpenCV,
+                1.2f,
+                bShowAllHypotheses && !bLargestFace ? 0 : 4,
+                (bLargestFace ? CV_HAAR_FIND_BIGGEST_OBJECT : 0) | CV_HAAR_SCALE_IMAGE,
+                Size(minSize.width, minSize.height));
+
+            for (size_t rt = 0; rt < rectsOpenCV.size(); ++rt)
+                rectangle(gray, rectsOpenCV[rt], Scalar(255));
+        }
+
+        Ncv32f avgTime = (Ncv32f)ncvEndQueryTimerMs(timer);
+        
+        cvtColor(gray, frameDisp, CV_GRAY2BGR);
+
+        imagePrintf(frameDisp, 0, CV_RGB(255,  0,0), "Space - Switch NCV%s / OpenCV%s", bUseOpenCV?"":" (ON)", bUseOpenCV?" (ON)":"");
+        imagePrintf(frameDisp, 1, CV_RGB(255,  0,0), "L - Switch FullSearch%s / LargestFace%s modes", bLargestFace?"":" (ON)", bLargestFace?" (ON)":"");
+        imagePrintf(frameDisp, 2, CV_RGB(255,  0,0), "U - Toggle unfiltered hypotheses visualization in FullSearch %s", bShowAllHypotheses?"(ON)":"(OFF)");
+        imagePrintf(frameDisp, 3, CV_RGB(118,185,0), "   Running at %f FPS on %s", 1000.0f / avgTime, bUseOpenCV?"CPU":"GPU");
+
+        cv::imshow(wndTitle, frameDisp);
+
+        switch (cvWaitKey(1))
+        {
+        case ' ':
+            bUseOpenCV = !bUseOpenCV;
+            break;
+        case 'L':case 'l':
+            bLargestFace = !bLargestFace;
+            break;
+        case 'U':case 'u':
+            bShowAllHypotheses = !bShowAllHypotheses;
+            break;
+        case 27:
+            return 0;            
+        }
+    }
+        
+    return 0;
+}
diff --git a/modules/gpu/src/nvidia/NCV.cpp b/modules/gpu/src/nvidia/NCV.cpp
new file mode 100644
index 0000000000..fef9c08f5b
--- /dev/null
+++ b/modules/gpu/src/nvidia/NCV.cpp
@@ -0,0 +1,571 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 
+// 
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2009-2010, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#include <precomp.hpp>
+
+
+#if !defined (HAVE_CUDA)
+
+
+#else /* !defined (HAVE_CUDA) */
+
+
+#include <stdarg.h>
+#include "NCV.hpp"
+
+
+//==============================================================================
+//
+// Error handling helpers
+//
+//==============================================================================
+
+
+static void stdioDebugOutput(const char *msg)
+{
+    printf("%s", msg);
+}
+
+
+static NCVDebugOutputHandler *debugOutputHandler = stdioDebugOutput;
+
+
+void ncvDebugOutput(const char *msg, ...)
+{
+    const int K_DEBUG_STRING_MAXLEN = 1024;
+    char buffer[K_DEBUG_STRING_MAXLEN];
+    va_list args;
+    va_start(args, msg);
+    vsnprintf_s(buffer, K_DEBUG_STRING_MAXLEN, K_DEBUG_STRING_MAXLEN-1, msg, args);
+    va_end (args);
+    debugOutputHandler(buffer);
+}
+
+
+void ncvSetDebugOutputHandler(NCVDebugOutputHandler *func)
+{
+    debugOutputHandler = func;
+}
+
+
+//==============================================================================
+//
+// Memory wrappers and helpers
+//
+//==============================================================================
+
+
+NCVStatus GPUAlignmentValue(Ncv32u &alignment)
+{
+    int curDev;
+    cudaDeviceProp curProp;
+    ncvAssertCUDAReturn(cudaGetDevice(&curDev), NCV_CUDA_ERROR);
+    ncvAssertCUDAReturn(cudaGetDeviceProperties(&curProp, curDev), NCV_CUDA_ERROR);
+    alignment = curProp.textureAlignment; //GPUAlignmentValue(curProp.major);
+    return NCV_SUCCESS;
+}
+
+
+Ncv32u alignUp(Ncv32u what, Ncv32u alignment)
+{
+    Ncv32u alignMask = alignment-1;
+    Ncv32u inverseAlignMask = ~alignMask;
+    Ncv32u res = (what + alignMask) & inverseAlignMask;
+    return res;
+}
+
+
+void NCVMemPtr::clear()
+{
+    ptr = NULL;
+    memtype = NCVMemoryTypeNone;
+}
+
+
+void NCVMemSegment::clear()
+{
+    begin.clear();
+    size = 0;
+}
+
+
+NCVStatus memSegCopyHelper(void *dst, NCVMemoryType dstType, const void *src, NCVMemoryType srcType, size_t sz, cudaStream_t cuStream)
+{
+    NCVStatus ncvStat;
+    switch (dstType)
+    {
+    case NCVMemoryTypeHostPageable:
+    case NCVMemoryTypeHostPinned:
+        switch (srcType)
+        {
+        case NCVMemoryTypeHostPageable:
+        case NCVMemoryTypeHostPinned:
+            memcpy(dst, src, sz);
+            ncvStat = NCV_SUCCESS;
+            break;
+        case NCVMemoryTypeDevice:
+            if (cuStream != 0)
+            {
+                ncvAssertCUDAReturn(cudaMemcpyAsync(dst, src, sz, cudaMemcpyDeviceToHost, cuStream), NCV_CUDA_ERROR);
+            }
+            else
+            {
+                ncvAssertCUDAReturn(cudaMemcpy(dst, src, sz, cudaMemcpyDeviceToHost), NCV_CUDA_ERROR);
+            }
+            ncvStat = NCV_SUCCESS;
+            break;
+        default:
+            ncvStat = NCV_MEM_RESIDENCE_ERROR;
+        }
+        break;
+    case NCVMemoryTypeDevice:
+        switch (srcType)
+        {
+        case NCVMemoryTypeHostPageable:
+        case NCVMemoryTypeHostPinned:
+            if (cuStream != 0)
+            {
+                ncvAssertCUDAReturn(cudaMemcpyAsync(dst, src, sz, cudaMemcpyHostToDevice, cuStream), NCV_CUDA_ERROR);
+            }
+            else
+            {
+                ncvAssertCUDAReturn(cudaMemcpy(dst, src, sz, cudaMemcpyHostToDevice), NCV_CUDA_ERROR);
+            }
+            ncvStat = NCV_SUCCESS;
+            break;
+        case NCVMemoryTypeDevice:
+            if (cuStream != 0)
+            {
+                ncvAssertCUDAReturn(cudaMemcpyAsync(dst, src, sz, cudaMemcpyDeviceToDevice, cuStream), NCV_CUDA_ERROR);
+            }
+            else
+            {
+                ncvAssertCUDAReturn(cudaMemcpy(dst, src, sz, cudaMemcpyDeviceToDevice), NCV_CUDA_ERROR);
+            }
+            ncvStat = NCV_SUCCESS;
+            break;
+        default:
+            ncvStat = NCV_MEM_RESIDENCE_ERROR;
+        }
+        break;
+    default:
+        ncvStat = NCV_MEM_RESIDENCE_ERROR;
+    }
+
+    return ncvStat;
+}
+
+
+//===================================================================
+//
+// NCVMemStackAllocator class members implementation
+//
+//===================================================================
+
+
+NCVMemStackAllocator::NCVMemStackAllocator(Ncv32u alignment)
+    :
+    currentSize(0),
+    _maxSize(0),
+    allocBegin(NULL),
+    begin(NULL),
+    _memType(NCVMemoryTypeNone),
+    _alignment(alignment)
+{
+    NcvBool bProperAlignment = (alignment & (alignment-1)) == 0;
+    ncvAssertPrintCheck(bProperAlignment, "NCVMemStackAllocator ctor:: alignment not power of 2");
+}
+
+
+NCVMemStackAllocator::NCVMemStackAllocator(NCVMemoryType memT, size_t capacity, Ncv32u alignment)
+    :
+    currentSize(0),
+    _maxSize(0),
+    allocBegin(NULL),
+    _memType(memT),
+    _alignment(alignment)
+{
+    NcvBool bProperAlignment = (alignment & (alignment-1)) == 0;
+    ncvAssertPrintCheck(bProperAlignment, "NCVMemStackAllocator ctor:: _alignment not power of 2");
+
+    allocBegin = NULL;
+
+    switch (memT)
+    {
+    case NCVMemoryTypeDevice:
+        ncvAssertCUDAReturn(cudaMalloc(&allocBegin, capacity), );
+        break;
+    case NCVMemoryTypeHostPinned:
+        ncvAssertCUDAReturn(cudaMallocHost(&allocBegin, capacity), );
+        break;
+    case NCVMemoryTypeHostPageable:
+        allocBegin = (Ncv8u *)malloc(capacity);
+        break;
+    }
+
+    if (capacity == 0)
+    {
+        allocBegin = (Ncv8u *)(0x1);
+    }
+
+    if (!isCounting())
+    {
+        begin = allocBegin;
+        end = begin + capacity;
+    }
+}
+
+
+NCVMemStackAllocator::~NCVMemStackAllocator()
+{
+    if (allocBegin != NULL)
+    {
+        ncvAssertPrintCheck(currentSize == 0, "NCVMemStackAllocator dtor:: not all objects were deallocated properly, forcing destruction");
+        switch (_memType)
+        {
+        case NCVMemoryTypeDevice:
+            ncvAssertCUDAReturn(cudaFree(allocBegin), );
+            break;
+        case NCVMemoryTypeHostPinned:
+            ncvAssertCUDAReturn(cudaFreeHost(allocBegin), );
+            break;
+        case NCVMemoryTypeHostPageable:
+            free(allocBegin);
+            break;
+        }
+        allocBegin = NULL;
+    }
+}
+
+
+NCVStatus NCVMemStackAllocator::alloc(NCVMemSegment &seg, size_t size)
+{
+    seg.clear();
+    ncvAssertReturn(isInitialized(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    size = alignUp(size, this->_alignment);
+    this->currentSize += size;
+    this->_maxSize = std::max(this->_maxSize, this->currentSize);
+
+    if (!isCounting())
+    {
+        size_t availSize = end - begin;
+        ncvAssertReturn(size <= availSize, NCV_ALLOCATOR_INSUFFICIENT_CAPACITY);
+    }
+
+    seg.begin.ptr = begin;
+    seg.begin.memtype = this->_memType;
+    seg.size = size;
+    begin += size;
+
+    return NCV_SUCCESS;
+}
+
+
+NCVStatus NCVMemStackAllocator::dealloc(NCVMemSegment &seg)
+{
+    ncvAssertReturn(isInitialized(), NCV_ALLOCATOR_BAD_ALLOC);
+    ncvAssertReturn(seg.begin.memtype == this->_memType, NCV_ALLOCATOR_BAD_DEALLOC);
+    ncvAssertReturn(seg.begin.ptr != NULL || isCounting(), NCV_ALLOCATOR_BAD_DEALLOC);
+    ncvAssertReturn(seg.begin.ptr == begin - seg.size, NCV_ALLOCATOR_DEALLOC_ORDER);
+
+    currentSize -= seg.size;
+    begin -= seg.size;
+
+    seg.clear();
+
+    ncvAssertReturn(allocBegin <= begin, NCV_ALLOCATOR_BAD_DEALLOC);
+
+    return NCV_SUCCESS;
+}
+
+
+NcvBool NCVMemStackAllocator::isInitialized(void) const
+{
+    return ((this->_alignment & (this->_alignment-1)) == 0) && isCounting() || this->allocBegin != NULL;
+}
+
+
+NcvBool NCVMemStackAllocator::isCounting(void) const
+{
+    return this->_memType == NCVMemoryTypeNone;
+}
+
+
+NCVMemoryType NCVMemStackAllocator::memType(void) const
+{
+    return this->_memType;
+}
+
+
+Ncv32u NCVMemStackAllocator::alignment(void) const
+{
+    return this->_alignment;
+}
+
+
+size_t NCVMemStackAllocator::maxSize(void) const
+{
+    return this->_maxSize;
+}
+
+
+//===================================================================
+//
+// NCVMemNativeAllocator class members implementation
+//
+//===================================================================
+
+
+NCVMemNativeAllocator::NCVMemNativeAllocator(NCVMemoryType memT)
+    :
+    currentSize(0),
+    _maxSize(0),
+    _memType(memT)
+{
+    ncvAssertPrintReturn(memT != NCVMemoryTypeNone, "NCVMemNativeAllocator ctor:: counting not permitted for this allocator type", );
+    ncvAssertPrintReturn(NCV_SUCCESS == GPUAlignmentValue(this->_alignment), "NCVMemNativeAllocator ctor:: couldn't get device _alignment", );
+}
+
+
+NCVMemNativeAllocator::~NCVMemNativeAllocator()
+{
+    ncvAssertPrintCheck(currentSize == 0, "NCVMemNativeAllocator dtor:: detected memory leak");
+}
+
+
+NCVStatus NCVMemNativeAllocator::alloc(NCVMemSegment &seg, size_t size)
+{
+    seg.clear();
+    ncvAssertReturn(isInitialized(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    switch (this->_memType)
+    {
+    case NCVMemoryTypeDevice:
+        ncvAssertCUDAReturn(cudaMalloc(&seg.begin.ptr, size), NCV_CUDA_ERROR);
+        break;
+    case NCVMemoryTypeHostPinned:
+        ncvAssertCUDAReturn(cudaMallocHost(&seg.begin.ptr, size), NCV_CUDA_ERROR);
+        break;
+    case NCVMemoryTypeHostPageable:
+        seg.begin.ptr = (Ncv8u *)malloc(size);
+        break;
+    }
+
+    this->currentSize += alignUp(size, this->_alignment);
+    this->_maxSize = std::max(this->_maxSize, this->currentSize);
+
+    seg.begin.memtype = this->_memType;
+    seg.size = size;
+
+    return NCV_SUCCESS;
+}
+
+
+NCVStatus NCVMemNativeAllocator::dealloc(NCVMemSegment &seg)
+{
+    ncvAssertReturn(isInitialized(), NCV_ALLOCATOR_BAD_ALLOC);
+    ncvAssertReturn(seg.begin.memtype == this->_memType, NCV_ALLOCATOR_BAD_DEALLOC);
+    ncvAssertReturn(seg.begin.ptr != NULL, NCV_ALLOCATOR_BAD_DEALLOC);
+
+    ncvAssertReturn(currentSize >= alignUp(seg.size, this->_alignment), NCV_ALLOCATOR_BAD_DEALLOC);
+    currentSize -= alignUp(seg.size, this->_alignment);
+
+    switch (this->_memType)
+    {
+    case NCVMemoryTypeDevice:
+        ncvAssertCUDAReturn(cudaFree(seg.begin.ptr), NCV_CUDA_ERROR);
+        break;
+    case NCVMemoryTypeHostPinned:
+        ncvAssertCUDAReturn(cudaFreeHost(seg.begin.ptr), NCV_CUDA_ERROR);
+        break;
+    case NCVMemoryTypeHostPageable:
+        free(seg.begin.ptr);
+        break;
+    }
+
+    seg.clear();
+
+    return NCV_SUCCESS;
+}
+
+
+NcvBool NCVMemNativeAllocator::isInitialized(void) const
+{
+    return (this->_alignment != 0);
+}
+
+
+NcvBool NCVMemNativeAllocator::isCounting(void) const
+{
+    return false;
+}
+
+
+NCVMemoryType NCVMemNativeAllocator::memType(void) const
+{
+    return this->_memType;
+}
+
+
+Ncv32u NCVMemNativeAllocator::alignment(void) const
+{
+    return this->_alignment;
+}
+
+
+size_t NCVMemNativeAllocator::maxSize(void) const
+{
+    return this->_maxSize;
+}
+
+
+//===================================================================
+//
+// Time and timer routines
+//
+//===================================================================
+
+
+typedef struct _NcvTimeMoment NcvTimeMoment;
+
+#if defined(_WIN32) || defined(_WIN64)
+
+    #include <Windows.h>
+
+    typedef struct _NcvTimeMoment
+    {
+        LONGLONG moment, freq;
+    } NcvTimeMoment;
+
+
+    static void _ncvQueryMoment(NcvTimeMoment *t)
+    {
+        QueryPerformanceFrequency((LARGE_INTEGER *)&(t->freq));
+        QueryPerformanceCounter((LARGE_INTEGER *)&(t->moment));
+    }
+
+
+    double _ncvMomentToMicroseconds(NcvTimeMoment *t)
+    {
+        return 1000000.0 * t->moment / t->freq;
+    }
+
+
+    double _ncvMomentsDiffToMicroseconds(NcvTimeMoment *t1, NcvTimeMoment *t2)
+    {
+        return 1000000.0 * 2 * ((t2->moment) - (t1->moment)) / (t1->freq + t2->freq);
+    }
+
+
+    double _ncvMomentsDiffToMilliseconds(NcvTimeMoment *t1, NcvTimeMoment *t2)
+    {
+        return 1000.0 * 2 * ((t2->moment) - (t1->moment)) / (t1->freq + t2->freq);
+    }
+
+#elif defined(__unix__)
+
+    #include <sys/time.h>
+
+    typedef struct _NcvTimeMoment
+    {
+        struct timeval tv; 
+        struct timezone tz;
+    } NcvTimeMoment;
+
+
+    void _ncvQueryMoment(NcvTimeMoment *t)
+    {
+        gettimeofday(& t->tv, & t->tz);
+    }
+
+
+    double _ncvMomentToMicroseconds(NcvTimeMoment *t)
+    {
+        return 1000000.0 * t->tv.tv_sec + (double)t->tv.tv_usec;
+    }
+
+
+    double _ncvMomentsDiffToMicroseconds(NcvTimeMoment *t1, NcvTimeMoment *t2)
+    {
+        return (((double)t2->tv.tv_sec - (double)t1->tv.tv_sec) * 1000000 + (double)t2->tv.tv_usec - (double)t1->tv.tv_usec);
+    }
+
+
+#endif //#if defined(_WIN32) || defined(_WIN64)
+
+
+struct _NcvTimer
+{
+    NcvTimeMoment t1, t2;
+};
+
+
+NcvTimer ncvStartTimer(void)
+{
+    struct _NcvTimer *t;
+    t = (struct _NcvTimer *)malloc(sizeof(struct _NcvTimer));
+    _ncvQueryMoment(&t->t1);
+    return t;
+}
+
+
+double ncvEndQueryTimerUs(NcvTimer t)
+{
+    double res;
+    _ncvQueryMoment(&t->t2);
+    res = _ncvMomentsDiffToMicroseconds(&t->t1, &t->t2);
+    free(t);
+    return res;
+}
+
+
+double ncvEndQueryTimerMs(NcvTimer t)
+{
+    double res;
+    _ncvQueryMoment(&t->t2);
+    res = _ncvMomentsDiffToMilliseconds(&t->t1, &t->t2);
+    free(t);
+    return res;
+}
+
+#endif /* !defined (HAVE_CUDA) */
\ No newline at end of file
diff --git a/modules/gpu/src/nvidia/NCV.hpp b/modules/gpu/src/nvidia/NCV.hpp
new file mode 100644
index 0000000000..a71f650252
--- /dev/null
+++ b/modules/gpu/src/nvidia/NCV.hpp
@@ -0,0 +1,837 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 
+// 
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2009-2010, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef _ncv_hpp_
+#define _ncv_hpp_
+
+#include <cuda_runtime.h>
+#include "npp_staging.h"
+
+
+//==============================================================================
+//
+// Alignment macros
+//
+//==============================================================================
+
+
+#if !defined(__align__) && !defined(__CUDACC__)
+    #if defined(_WIN32) || defined(_WIN64)
+        #define __align__(n)         __declspec(align(n))
+    #elif defined(__unix__)
+        #define __align__(n)         __attribute__((__aligned__(n)))
+    #endif
+#endif
+
+
+//==============================================================================
+//
+// Integral and compound types of guaranteed size
+//
+//==============================================================================
+
+
+typedef               bool NcvBool;
+typedef          long long Ncv64s;
+typedef unsigned long long Ncv64u;
+typedef                int Ncv32s;
+typedef       unsigned int Ncv32u;
+typedef              short Ncv16s;
+typedef     unsigned short Ncv16u;
+typedef               char Ncv8s;
+typedef      unsigned char Ncv8u;
+typedef              float Ncv32f;
+typedef             double Ncv64f;
+
+
+typedef struct
+{
+    Ncv8u x;
+    Ncv8u y;
+    Ncv8u width;
+    Ncv8u height;
+} NcvRect8u;
+
+
+typedef struct
+{
+    Ncv32s x;          ///< x-coordinate of upper left corner.
+    Ncv32s y;          ///< y-coordinate of upper left corner.
+    Ncv32s width;      ///< Rectangle width.
+    Ncv32s height;     ///< Rectangle height.
+} NcvRect32s;
+
+
+typedef struct
+{
+    Ncv32u x;          ///< x-coordinate of upper left corner.
+    Ncv32u y;          ///< y-coordinate of upper left corner.
+    Ncv32u width;      ///< Rectangle width.
+    Ncv32u height;     ///< Rectangle height.
+} NcvRect32u;
+
+
+typedef struct 
+{
+    Ncv32s width;  ///< Rectangle width.
+    Ncv32s height; ///< Rectangle height.
+} NcvSize32s;
+
+
+typedef struct 
+{
+    Ncv32u width;  ///< Rectangle width.
+    Ncv32u height; ///< Rectangle height.
+} NcvSize32u;
+
+
+NPPST_CT_ASSERT(sizeof(NcvBool) <= 4);
+NPPST_CT_ASSERT(sizeof(Ncv64s) == 8);
+NPPST_CT_ASSERT(sizeof(Ncv64u) == 8);
+NPPST_CT_ASSERT(sizeof(Ncv32s) == 4);
+NPPST_CT_ASSERT(sizeof(Ncv32u) == 4);
+NPPST_CT_ASSERT(sizeof(Ncv16s) == 2);
+NPPST_CT_ASSERT(sizeof(Ncv16u) == 2);
+NPPST_CT_ASSERT(sizeof(Ncv8s) == 1);
+NPPST_CT_ASSERT(sizeof(Ncv8u) == 1);
+NPPST_CT_ASSERT(sizeof(Ncv32f) == 4);
+NPPST_CT_ASSERT(sizeof(Ncv64f) == 8);
+NPPST_CT_ASSERT(sizeof(NcvRect8u) == sizeof(Ncv32u));
+NPPST_CT_ASSERT(sizeof(NcvRect32s) == 4 * sizeof(Ncv32s));
+NPPST_CT_ASSERT(sizeof(NcvRect32u) == 4 * sizeof(Ncv32u));
+NPPST_CT_ASSERT(sizeof(NcvSize32u) == 2 * sizeof(Ncv32u));
+
+
+//==============================================================================
+//
+// Persistent constants
+//
+//==============================================================================
+
+
+const Ncv32u K_WARP_SIZE = 32;
+const Ncv32u K_LOG2_WARP_SIZE = 5;
+
+
+//==============================================================================
+//
+// Error handling
+//
+//==============================================================================
+
+
+#define NCV_CT_PREP_STRINGIZE_AUX(x)    #x
+#define NCV_CT_PREP_STRINGIZE(x)        NCV_CT_PREP_STRINGIZE_AUX(x)
+
+
+void ncvDebugOutput(const char *msg, ...);
+
+
+typedef void NCVDebugOutputHandler(const char* msg);
+
+
+void ncvSetDebugOutputHandler(NCVDebugOutputHandler* func);
+
+
+#define ncvAssertPrintCheck(pred, msg) \
+    ((pred) ? true : (ncvDebugOutput("\n%s\n", \
+    "NCV Assertion Failed: " msg ", file=" __FILE__ ", line=" NCV_CT_PREP_STRINGIZE(__LINE__) \
+    ), false))
+
+
+#define ncvAssertPrintReturn(pred, msg, err) \
+    if (ncvAssertPrintCheck(pred, msg)) ; else return err
+
+
+#define ncvAssertReturn(pred, err) \
+    do \
+    { \
+        if (!(pred)) \
+        { \
+            ncvDebugOutput("\n%s%d%s\n", "NCV Assertion Failed: retcode=", (int)err, ", file=" __FILE__ ", line=" NCV_CT_PREP_STRINGIZE(__LINE__)); \
+            return err; \
+        } \
+    } while (0)
+
+
+#define ncvAssertReturnNcvStat(ncvOp) \
+    do \
+    { \
+        NCVStatus _ncvStat = ncvOp; \
+        if (NCV_SUCCESS != _ncvStat) \
+        { \
+            ncvDebugOutput("\n%s%d%s\n", "NCV Assertion Failed: NcvStat=", (int)_ncvStat, ", file=" __FILE__ ", line=" NCV_CT_PREP_STRINGIZE(__LINE__)); \
+            return _ncvStat; \
+        } \
+    } while (0)
+
+
+#define ncvAssertCUDAReturn(cudacall, errCode) \
+    do \
+    { \
+        cudaError_t resCall = cudacall; \
+        cudaError_t resGLE = cudaGetLastError(); \
+        if (cudaSuccess != resCall || cudaSuccess != resGLE) \
+        { \
+            ncvDebugOutput("\n%s%d%s\n", "NCV CUDA Assertion Failed: cudaError_t=", (int)(resCall | resGLE), ", file=" __FILE__ ", line=" NCV_CT_PREP_STRINGIZE(__LINE__)); \
+            return errCode; \
+        } \
+    } while (0)
+
+
+/**
+* Return-codes for status notification, errors and warnings
+*/
+enum NCVStatus
+{
+    NCV_SUCCESS,
+
+    NCV_CUDA_ERROR,
+    NCV_NPP_ERROR,
+    NCV_FILE_ERROR,
+
+    NCV_NULL_PTR,
+    NCV_INCONSISTENT_INPUT,
+    NCV_TEXTURE_BIND_ERROR,
+    NCV_DIMENSIONS_INVALID,
+
+    NCV_INVALID_ROI,
+    NCV_INVALID_STEP,
+    NCV_INVALID_SCALE,
+
+    NCV_ALLOCATOR_NOT_INITIALIZED,
+    NCV_ALLOCATOR_BAD_ALLOC,
+    NCV_ALLOCATOR_BAD_DEALLOC,
+    NCV_ALLOCATOR_INSUFFICIENT_CAPACITY,
+    NCV_ALLOCATOR_DEALLOC_ORDER,
+    NCV_ALLOCATOR_BAD_REUSE,
+
+    NCV_MEM_COPY_ERROR,
+    NCV_MEM_RESIDENCE_ERROR,
+    NCV_MEM_INSUFFICIENT_CAPACITY,
+
+    NCV_HAAR_INVALID_PIXEL_STEP,
+    NCV_HAAR_TOO_MANY_FEATURES_IN_CLASSIFIER,
+    NCV_HAAR_TOO_MANY_FEATURES_IN_CASCADE,
+    NCV_HAAR_TOO_LARGE_FEATURES,
+    NCV_HAAR_XML_LOADING_EXCEPTION,
+
+    NCV_NOIMPL_HAAR_TILTED_FEATURES,
+
+    NCV_WARNING_HAAR_DETECTIONS_VECTOR_OVERFLOW,
+};
+
+
+#define NCV_SET_SKIP_COND(x) \
+    bool __ncv_skip_cond = x
+
+
+#define NCV_RESET_SKIP_COND(x) \
+    __ncv_skip_cond = x
+
+
+#define NCV_SKIP_COND_BEGIN \
+    if (!__ncv_skip_cond) {
+
+
+#define NCV_SKIP_COND_END \
+    }
+
+
+//==============================================================================
+//
+// Timer
+//
+//==============================================================================
+
+
+typedef struct _NcvTimer *NcvTimer;
+
+NcvTimer ncvStartTimer(void);
+
+double ncvEndQueryTimerUs(NcvTimer t);
+
+double ncvEndQueryTimerMs(NcvTimer t);
+
+
+//==============================================================================
+//
+// Memory management classes template compound types
+//
+//==============================================================================
+
+
+/**
+* Alignment of GPU memory chunks in bytes
+*/
+NCVStatus GPUAlignmentValue(Ncv32u &alignment);
+
+
+/**
+* Calculates the aligned top bound value
+*/
+Ncv32u alignUp(Ncv32u what, Ncv32u alignment);
+
+
+/**
+* NCVMemoryType
+*/
+enum NCVMemoryType
+{
+    NCVMemoryTypeNone,
+    NCVMemoryTypeHostPageable,
+    NCVMemoryTypeHostPinned,
+    NCVMemoryTypeDevice
+};
+
+
+/**
+* NCVMemPtr
+*/
+struct NCVMemPtr
+{
+    void *ptr;
+    NCVMemoryType memtype;
+    void clear();
+};
+
+
+/**
+* NCVMemSegment
+*/
+struct NCVMemSegment
+{
+    NCVMemPtr begin;
+    size_t size;
+    void clear();
+};
+
+
+/**
+* INCVMemAllocator (Interface)
+*/
+class INCVMemAllocator
+{
+public:
+    virtual ~INCVMemAllocator() = 0;
+
+    virtual NCVStatus alloc(NCVMemSegment &seg, size_t size) = 0;
+    virtual NCVStatus dealloc(NCVMemSegment &seg) = 0;
+
+    virtual NcvBool isInitialized(void) const = 0;
+    virtual NcvBool isCounting(void) const = 0;
+    
+    virtual NCVMemoryType memType(void) const = 0;
+    virtual Ncv32u alignment(void) const = 0;
+    virtual size_t maxSize(void) const = 0;
+};
+
+inline INCVMemAllocator::~INCVMemAllocator() {}
+
+
+/**
+* NCVMemStackAllocator
+*/
+class NCVMemStackAllocator : public INCVMemAllocator
+{
+    NCVMemStackAllocator();
+    NCVMemStackAllocator(const NCVMemStackAllocator &);
+
+public:
+
+    explicit NCVMemStackAllocator(Ncv32u alignment);
+    NCVMemStackAllocator(NCVMemoryType memT, size_t capacity, Ncv32u alignment);
+    virtual ~NCVMemStackAllocator();
+
+    virtual NCVStatus alloc(NCVMemSegment &seg, size_t size);
+    virtual NCVStatus dealloc(NCVMemSegment &seg);
+
+    virtual NcvBool isInitialized(void) const;
+    virtual NcvBool isCounting(void) const;
+
+    virtual NCVMemoryType memType(void) const;
+    virtual Ncv32u alignment(void) const;
+    virtual size_t maxSize(void) const;
+
+private:
+
+    NCVMemoryType _memType;
+    Ncv32u _alignment;
+    Ncv8u *allocBegin;
+    Ncv8u *begin;
+    Ncv8u *end;
+    size_t currentSize;
+    size_t _maxSize;
+};
+
+
+/**
+* NCVMemNativeAllocator
+*/
+class NCVMemNativeAllocator : public INCVMemAllocator
+{
+public:
+
+    NCVMemNativeAllocator(NCVMemoryType memT);
+    virtual ~NCVMemNativeAllocator();
+
+    virtual NCVStatus alloc(NCVMemSegment &seg, size_t size);
+    virtual NCVStatus dealloc(NCVMemSegment &seg);
+
+    virtual NcvBool isInitialized(void) const;
+    virtual NcvBool isCounting(void) const;
+
+    virtual NCVMemoryType memType(void) const;
+    virtual Ncv32u alignment(void) const;
+    virtual size_t maxSize(void) const;
+
+private:
+
+    NCVMemNativeAllocator();
+    NCVMemNativeAllocator(const NCVMemNativeAllocator &);
+
+    NCVMemoryType _memType;
+    Ncv32u _alignment;
+    size_t currentSize;
+    size_t _maxSize;
+};
+
+
+/**
+* Copy dispatcher
+*/
+NCVStatus memSegCopyHelper(void *dst, NCVMemoryType dstType,
+                           const void *src, NCVMemoryType srcType,
+                           size_t sz, cudaStream_t cuStream);
+
+
+/**
+* NCVVector (1D)
+*/
+template <class T>
+class NCVVector
+{
+    NCVVector(const NCVVector &);
+
+public:
+
+    NCVVector()
+    {
+        clear();
+    }
+
+	virtual ~NCVVector() {}
+
+    void clear()
+    {
+        _ptr = NULL;
+        _length = 0;
+        _memtype = NCVMemoryTypeNone;
+    }
+
+    NCVStatus copySolid(NCVVector<T> &dst, cudaStream_t cuStream, size_t howMuch=0)
+    {
+        if (howMuch == 0)
+        {
+            ncvAssertReturn(dst._length == this->_length, NCV_MEM_COPY_ERROR);
+            howMuch = this->_length * sizeof(T);
+        }
+        else
+        {
+            ncvAssertReturn(dst._length * sizeof(T) >= howMuch && 
+                this->_length * sizeof(T) >= howMuch &&
+                howMuch > 0, NCV_MEM_COPY_ERROR);
+        }
+        ncvAssertReturn((this->_ptr != NULL || this->_memtype == NCVMemoryTypeNone) && 
+                        (dst._ptr != NULL || dst._memtype == NCVMemoryTypeNone), NCV_NULL_PTR);
+
+        NCVStatus ncvStat = NCV_SUCCESS;
+        if (this->_memtype != NCVMemoryTypeNone)
+        {
+            ncvStat = memSegCopyHelper(dst._ptr, dst._memtype,
+                                       this->_ptr, this->_memtype,
+                                       howMuch, cuStream);
+        }
+
+        return ncvStat;
+    }
+
+    T *ptr() const {return this->_ptr;}
+    size_t length() const {return this->_length;}
+    NCVMemoryType memType() const {return this->_memtype;}
+
+protected:
+
+    T *_ptr;
+    size_t _length;
+    NCVMemoryType _memtype;
+};
+
+
+/**
+* NCVVectorAlloc
+*/
+template <class T>
+class NCVVectorAlloc : public NCVVector<T>
+{
+    NCVVectorAlloc();
+    NCVVectorAlloc(const NCVVectorAlloc &);
+
+public:
+
+    NCVVectorAlloc(INCVMemAllocator &allocator, Ncv32u length)
+        :
+        allocator(allocator)
+    {
+        NCVStatus ncvStat;
+
+        this->clear();
+        this->allocatedMem.clear();
+
+        ncvStat = allocator.alloc(this->allocatedMem, length * sizeof(T));
+        ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "NCVVectorAlloc ctor:: alloc failed", );
+
+        this->_ptr = (T *)this->allocatedMem.begin.ptr;
+        this->_length = length;
+        this->_memtype = this->allocatedMem.begin.memtype;
+    }
+
+
+    ~NCVVectorAlloc()
+    {
+        NCVStatus ncvStat;
+
+        ncvStat = allocator.dealloc(this->allocatedMem);
+        ncvAssertPrintCheck(ncvStat == NCV_SUCCESS, "NCVVectorAlloc dtor:: dealloc failed");
+
+        this->clear();
+    }
+
+
+    NcvBool isMemAllocated() const
+    {
+        return (this->allocatedMem.begin.ptr != NULL) || (this->allocator.isCounting());
+    }
+
+
+    Ncv32u getAllocatorsAlignment() const
+    {
+        return allocator.alignment();
+    }
+
+
+    NCVMemSegment getSegment() const
+    {
+        return allocatedMem;
+    }
+
+private:
+
+    INCVMemAllocator &allocator;
+    NCVMemSegment allocatedMem;
+};
+
+
+/**
+* NCVVectorReuse
+*/
+template <class T>
+class NCVVectorReuse : public NCVVector<T>
+{
+    NCVVectorReuse();
+    NCVVectorReuse(const NCVVectorReuse &);
+
+public:
+
+    explicit NCVVectorReuse(const NCVMemSegment &memSegment)
+    {
+        this->bReused = false;
+        this->clear();
+
+        this->_length = memSegment.size / sizeof(T);
+        this->_ptr = (T *)memSegment.begin.ptr;
+        this->_memtype = memSegment.begin.memtype;
+
+        this->bReused = true;
+    }
+
+
+    NCVVectorReuse(const NCVMemSegment &memSegment, Ncv32u length)
+    {
+        this->bReused = false;
+        this->clear();
+
+        ncvAssertPrintReturn(length * sizeof(T) <= memSegment.size, \
+            "NCVVectorReuse ctor:: memory binding failed due to size mismatch", );
+
+        this->_length = length;
+        this->_ptr = (T *)memSegment.begin.ptr;
+        this->_memtype = memSegment.begin.memtype;
+
+        this->bReused = true;
+    }
+
+
+    NcvBool isMemReused() const
+    {
+        return this->bReused;
+    }
+
+private:
+
+    NcvBool bReused;
+};
+
+
+/**
+* NCVMatrix (2D)
+*/
+template <class T>
+class NCVMatrix
+{
+    NCVMatrix(const NCVMatrix &);
+
+public:
+
+    NCVMatrix()
+    {
+        clear();
+    }
+
+	virtual ~NCVMatrix() {}
+
+
+    void clear()
+    {
+        _ptr = NULL;
+        _pitch = 0;
+        _width = 0;
+        _height = 0;
+        _memtype = NCVMemoryTypeNone;
+    }
+
+
+    Ncv32u stride() const
+    {
+        return _pitch / sizeof(T);
+    }
+
+
+    NCVStatus copySolid(NCVMatrix<T> &dst, cudaStream_t cuStream, size_t howMuch=0)
+    {
+        if (howMuch == 0)
+        {
+            ncvAssertReturn(dst._pitch == this->_pitch &&
+                            dst._height == this->_height, NCV_MEM_COPY_ERROR);
+            howMuch = this->_pitch * this->_height;
+        }
+        else
+        {
+            ncvAssertReturn(dst._pitch * dst._height >= howMuch && 
+                            this->_pitch * this->_height >= howMuch &&
+                            howMuch > 0, NCV_MEM_COPY_ERROR);
+        }
+        ncvAssertReturn((this->_ptr != NULL || this->_memtype == NCVMemoryTypeNone) && 
+                        (dst._ptr != NULL || dst._memtype == NCVMemoryTypeNone), NCV_NULL_PTR);
+
+        NCVStatus ncvStat = NCV_SUCCESS;
+        if (this->_memtype != NCVMemoryTypeNone)
+        {
+            ncvStat = memSegCopyHelper(dst._ptr, dst._memtype, 
+                                       this->_ptr, this->_memtype, 
+                                       howMuch, cuStream);
+        }
+
+        return ncvStat;
+    }
+
+    T *ptr() const {return this->_ptr;}
+    Ncv32u width() const {return this->_width;}
+    Ncv32u height() const {return this->_height;}
+    Ncv32u pitch() const {return this->_pitch;}
+    NCVMemoryType memType() const {return this->_memtype;}
+
+protected:
+
+    T *_ptr;
+    Ncv32u _width;
+    Ncv32u _height;
+    Ncv32u _pitch;
+    NCVMemoryType _memtype;
+};
+
+
+/**
+* NCVMatrixAlloc
+*/
+template <class T>
+class NCVMatrixAlloc : public NCVMatrix<T>
+{
+    NCVMatrixAlloc();
+    NCVMatrixAlloc(const NCVMatrixAlloc &);
+
+public:
+
+    NCVMatrixAlloc(INCVMemAllocator &allocator, Ncv32u width, Ncv32u height, Ncv32u pitch=0)
+        :
+        allocator(allocator)
+    {
+        NCVStatus ncvStat;
+
+        this->clear();
+        this->allocatedMem.clear();
+
+        Ncv32u widthBytes = width * sizeof(T);
+        Ncv32u pitchBytes = alignUp(widthBytes, allocator.alignment());
+
+        if (pitch != 0)
+        {
+            ncvAssertPrintReturn(pitch >= pitchBytes &&
+                (pitch & (allocator.alignment() - 1)) == 0,
+                "NCVMatrixAlloc ctor:: incorrect pitch passed", );
+            pitchBytes = pitch;
+        }
+
+        Ncv32u requiredAllocSize = pitchBytes * height;
+
+        ncvStat = allocator.alloc(this->allocatedMem, requiredAllocSize);
+        ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "NCVMatrixAlloc ctor:: alloc failed", );
+
+        this->_ptr = (T *)this->allocatedMem.begin.ptr;
+        this->_width = width;
+        this->_height = height;
+        this->_pitch = pitchBytes;
+        this->_memtype = this->allocatedMem.begin.memtype;
+    }
+
+    ~NCVMatrixAlloc()
+    {
+        NCVStatus ncvStat;
+
+        ncvStat = allocator.dealloc(this->allocatedMem);
+        ncvAssertPrintCheck(ncvStat == NCV_SUCCESS, "NCVMatrixAlloc dtor:: dealloc failed");
+
+        this->clear();
+    }
+
+
+    NcvBool isMemAllocated() const
+    {
+        return (this->allocatedMem.begin.ptr != NULL) || (this->allocator.isCounting());
+    }
+
+
+    Ncv32u getAllocatorsAlignment() const
+    {
+        return allocator.alignment();
+    }
+
+
+    NCVMemSegment getSegment() const
+    {
+        return allocatedMem;
+    }
+
+private:
+
+    INCVMemAllocator &allocator;
+    NCVMemSegment allocatedMem;
+};
+
+
+/**
+* NCVMatrixReuse
+*/
+template <class T>
+class NCVMatrixReuse : public NCVMatrix<T>
+{
+    NCVMatrixReuse();
+    NCVMatrixReuse(const NCVMatrixReuse &);
+
+public:
+
+    NCVMatrixReuse(const NCVMemSegment &memSegment, Ncv32u alignment, Ncv32u width, Ncv32u height, Ncv32u pitch=0, NcvBool bSkipPitchCheck=false)
+    {
+        this->bReused = false;
+        this->clear();
+
+        Ncv32u widthBytes = width * sizeof(T);
+        Ncv32u pitchBytes = alignUp(widthBytes, alignment);
+
+        if (pitch != 0)
+        {
+            if (!bSkipPitchCheck)
+            {
+                ncvAssertPrintReturn(pitch >= pitchBytes &&
+                    (pitch & (alignment - 1)) == 0,
+                    "NCVMatrixReuse ctor:: incorrect pitch passed", );
+            }
+            else
+            {
+                ncvAssertPrintReturn(pitch >= widthBytes, "NCVMatrixReuse ctor:: incorrect pitch passed", );
+            }
+            pitchBytes = pitch;
+        }
+
+        ncvAssertPrintReturn(pitchBytes * height <= memSegment.size, \
+            "NCVMatrixReuse ctor:: memory binding failed due to size mismatch", );
+
+        this->_width = width;
+        this->_height = height;
+        this->_pitch = pitchBytes;
+        this->_ptr = (T *)memSegment.begin.ptr;
+        this->_memtype = memSegment.begin.memtype;
+
+        this->bReused = true;
+    }
+
+
+    NcvBool isMemReused() const
+    {
+        return this->bReused;
+    }
+
+private:
+
+    NcvBool bReused;
+};
+
+#endif // _ncv_hpp_
diff --git a/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu b/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
new file mode 100644
index 0000000000..a501d6525e
--- /dev/null
+++ b/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
@@ -0,0 +1,2603 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 
+// 
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2009-2010, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// NVIDIA CUDA implementation of Viola-Jones Object Detection Framework
+//
+// The algorithm and code are explained in the upcoming GPU Computing Gems
+// chapter in detail:
+//
+//   Anton Obukhov, "Haar Classifiers for Object Detection with CUDA"
+//   PDF URL placeholder
+//   email: aobukhov@nvidia.com, devsupport@nvidia.com
+//
+// Credits for help with the code to:
+// Alexey Mendelenko, Cyril Crassin, and Mikhail Smirnov.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include <algorithm>
+
+#include "npp.h"
+#include "NCV.hpp"
+#include "NCVRuntimeTemplates.hpp"
+#include "NCVHaarObjectDetection.hpp"
+
+void groupRectangles(std::vector<NcvRect32u> &hypotheses, int groupThreshold, double eps, std::vector<Ncv32u> *weights);
+
+
+//==============================================================================
+//
+// BlockScan file
+//
+//==============================================================================
+
+
+//Almost the same as naive scan1Inclusive, but doesn't need __syncthreads()
+//assuming size <= WARP_SIZE and size is power of 2
+template <class T>
+inline __device__ T warpScanInclusive(T idata, volatile T *s_Data)
+{
+    Ncv32u pos = 2 * threadIdx.x - (threadIdx.x & (K_WARP_SIZE - 1));
+    s_Data[pos] = 0;
+    pos += K_WARP_SIZE;
+    s_Data[pos] = idata;
+
+    for(Ncv32u offset = 1; offset < K_WARP_SIZE; offset <<= 1)
+    {
+        s_Data[pos] += s_Data[pos - offset];
+    }
+
+    return s_Data[pos];
+}
+
+
+template <class T>
+inline __device__ T warpScanExclusive(T idata, volatile T *s_Data)
+{
+    return warpScanInclusive(idata, s_Data) - idata;
+}
+
+
+template <class T, Ncv32u tiNumScanThreads>
+inline __device__ T blockScanInclusive(T idata, volatile T *s_Data)
+{
+    if (tiNumScanThreads > K_WARP_SIZE)
+    {
+        //Bottom-level inclusive warp scan
+        T warpResult = warpScanInclusive(idata, s_Data);
+
+        //Save top elements of each warp for exclusive warp scan
+        //sync to wait for warp scans to complete (because s_Data is being overwritten)
+        __syncthreads();
+        if( (threadIdx.x & (K_WARP_SIZE - 1)) == (K_WARP_SIZE - 1) )
+        {
+            s_Data[threadIdx.x >> K_LOG2_WARP_SIZE] = warpResult;
+        }
+
+        //wait for warp scans to complete
+        __syncthreads();
+
+        if( threadIdx.x < (tiNumScanThreads / K_WARP_SIZE) )
+        {
+            //grab top warp elements
+            T val = s_Data[threadIdx.x];
+            //calculate exclusive scan and write back to shared memory
+            s_Data[threadIdx.x] = warpScanExclusive(val, s_Data);
+        }
+
+        //return updated warp scans with exclusive scan results
+        __syncthreads();
+        return warpResult + s_Data[threadIdx.x >> K_LOG2_WARP_SIZE];
+    }
+    else
+    {
+        return warpScanInclusive(idata, s_Data);
+    }
+}
+
+
+//==============================================================================
+//
+// HaarClassifierCascade file
+//
+//==============================================================================
+
+
+const Ncv32u MAX_GRID_DIM = 65535;
+
+
+const Ncv32u NUM_THREADS_ANCHORSPARALLEL = 64;
+
+
+#define NUM_THREADS_CLASSIFIERPARALLEL_LOG2     6
+#define NUM_THREADS_CLASSIFIERPARALLEL          (1 << NUM_THREADS_CLASSIFIERPARALLEL_LOG2)
+
+
+/** \internal
+* Haar features solid array.
+*/
+texture<uint2, 1, cudaReadModeElementType> texHaarFeatures;
+
+
+/** \internal
+* Haar classifiers flattened trees container.
+* Two parts: first contains root nodes, second - nodes that are referred by root nodes.
+* Drawback: breaks tree locality (might cause more cache misses
+* Advantage: No need to introduce additional 32-bit field to index root nodes offsets
+*/
+texture<uint4, 1, cudaReadModeElementType> texHaarClassifierNodes;
+
+
+texture<Ncv32u, 1, cudaReadModeElementType> texIImage;
+
+
+__device__ HaarStage64 getStage(Ncv32u iStage, HaarStage64 *d_Stages)
+{
+    return d_Stages[iStage];
+}
+
+
+template <NcvBool tbCacheTextureCascade>
+__device__ HaarClassifierNode128 getClassifierNode(Ncv32u iNode, HaarClassifierNode128 *d_ClassifierNodes)
+{
+    HaarClassifierNode128 tmpNode;
+    if (tbCacheTextureCascade)
+    {
+        tmpNode._ui4 = tex1Dfetch(texHaarClassifierNodes, iNode);
+    }
+    else
+    {
+        tmpNode = d_ClassifierNodes[iNode];
+    }
+    return tmpNode;
+}
+
+
+template <NcvBool tbCacheTextureCascade>
+__device__ void getFeature(Ncv32u iFeature, HaarFeature64 *d_Features, 
+                           Ncv32f *weight,
+                           Ncv32u *rectX, Ncv32u *rectY, Ncv32u *rectWidth, Ncv32u *rectHeight)
+{
+    HaarFeature64 feature;
+    if (tbCacheTextureCascade)
+    {
+        feature._ui2 = tex1Dfetch(texHaarFeatures, iFeature);
+    }
+    else
+    {
+        feature = d_Features[iFeature];
+    }
+    feature.getRect(rectX, rectY, rectWidth, rectHeight);
+    *weight = feature.getWeight();
+}
+
+
+template <NcvBool tbCacheTextureIImg>
+__device__ Ncv32u getElemIImg(Ncv32u x, Ncv32u *d_IImg)
+{
+    if (tbCacheTextureIImg)
+    {
+        return tex1Dfetch(texIImage, x);
+    }
+    else
+    {
+        return d_IImg[x];
+    }
+}
+
+
+__device__ Ncv32f reduceSpecialization(Ncv32f partialSum)
+{
+    __shared__ volatile Ncv32f reductor[NUM_THREADS_CLASSIFIERPARALLEL];
+    reductor[threadIdx.x] = partialSum;
+    __syncthreads();
+
+#if defined CPU_FP_COMPLIANCE
+    if (!threadIdx.x)
+    {
+        Ncv32f sum = 0.0f;
+        for (int i=0; i<NUM_THREADS_CLASSIFIERPARALLEL; i++)
+        {
+            sum += reductor[i];
+        }
+        reductor[0] = sum;
+    }
+#else
+
+#if NUM_THREADS_CLASSIFIERPARALLEL_LOG2 >= 8
+    if (threadIdx.x < 128)
+    {
+        reductor[threadIdx.x] += reductor[threadIdx.x + 128]; 
+    }
+    __syncthreads();
+#endif
+#if NUM_THREADS_CLASSIFIERPARALLEL_LOG2 >= 7
+    if (threadIdx.x < 64)
+    {
+        reductor[threadIdx.x] += reductor[threadIdx.x + 64]; 
+    }
+    __syncthreads();
+#endif
+
+    if (threadIdx.x < 32)
+    {
+#if NUM_THREADS_CLASSIFIERPARALLEL_LOG2 >= 6
+        reductor[threadIdx.x] += reductor[threadIdx.x + 32];
+#endif
+#if NUM_THREADS_CLASSIFIERPARALLEL_LOG2 >= 5
+        reductor[threadIdx.x] += reductor[threadIdx.x + 16];
+#endif
+        reductor[threadIdx.x] += reductor[threadIdx.x + 8];
+        reductor[threadIdx.x] += reductor[threadIdx.x + 4];
+        reductor[threadIdx.x] += reductor[threadIdx.x + 2];
+        reductor[threadIdx.x] += reductor[threadIdx.x + 1];
+    }
+#endif
+
+    __syncthreads();
+
+    return reductor[0];
+}
+
+
+__device__ Ncv32u d_outMaskPosition;
+
+
+__inline __device__ void compactBlockWriteOutAnchorParallel(NcvBool threadPassFlag,
+                                                            Ncv32u threadElem,
+                                                            Ncv32u *vectorOut)
+{
+#if __CUDA_ARCH__ >= 110
+    Ncv32u passMaskElem = threadPassFlag ? 1 : 0;
+    __shared__ Ncv32u shmem[NUM_THREADS_ANCHORSPARALLEL * 2];
+    Ncv32u incScan = blockScanInclusive<Ncv32u, NUM_THREADS_ANCHORSPARALLEL>(passMaskElem, shmem);
+    __syncthreads();
+    Ncv32u excScan = incScan - passMaskElem;
+
+    __shared__ Ncv32u numPassed;
+    __shared__ Ncv32u outMaskOffset;
+    if (threadIdx.x == NUM_THREADS_ANCHORSPARALLEL-1)
+    {
+        numPassed = incScan;
+        outMaskOffset = atomicAdd(&d_outMaskPosition, incScan);
+    }
+    __syncthreads();
+
+    if (threadPassFlag)
+    {
+        shmem[excScan] = threadElem;
+    }
+    __syncthreads();
+
+    if (threadIdx.x < numPassed)
+    {
+        vectorOut[outMaskOffset + threadIdx.x] = shmem[threadIdx.x];
+    }
+#endif
+}
+
+
+template <NcvBool tbInitMaskPositively,
+          NcvBool tbCacheTextureIImg,
+          NcvBool tbCacheTextureCascade,
+          NcvBool tbReadPixelIndexFromVector,
+          NcvBool tbDoAtomicCompaction>
+__global__ void applyHaarClassifierAnchorParallel(Ncv32u *d_IImg, Ncv32u IImgStride,
+                                                  Ncv32f *d_weights, Ncv32u weightsStride,
+                                                  HaarFeature64 *d_Features, HaarClassifierNode128 *d_ClassifierNodes, HaarStage64 *d_Stages,
+                                                  Ncv32u *d_inMask, Ncv32u *d_outMask,
+                                                  Ncv32u mask1Dlen, Ncv32u mask2Dstride,
+                                                  NcvSize32u anchorsRoi, Ncv32u startStageInc, Ncv32u endStageExc, Ncv32f scaleArea)
+{
+    Ncv32u y_offs;
+    Ncv32u x_offs;
+    Ncv32u maskOffset;
+    Ncv32u outMaskVal;
+
+    NcvBool bInactiveThread = false;
+
+    if (tbReadPixelIndexFromVector)
+    {
+        maskOffset = (MAX_GRID_DIM * blockIdx.y + blockIdx.x) * NUM_THREADS_ANCHORSPARALLEL + threadIdx.x;
+
+        if (maskOffset >= mask1Dlen)
+        {
+            if (tbDoAtomicCompaction) bInactiveThread = true; else return;
+        }
+
+        if (!tbDoAtomicCompaction || tbDoAtomicCompaction && !bInactiveThread)
+        {
+            outMaskVal = d_inMask[maskOffset];
+            y_offs = outMaskVal >> 16;
+            x_offs = outMaskVal & 0xFFFF;
+        }
+    }
+    else
+    {
+        y_offs = blockIdx.y;
+        x_offs = blockIdx.x * NUM_THREADS_ANCHORSPARALLEL + threadIdx.x;
+
+        if (x_offs >= mask2Dstride)
+        {
+            if (tbDoAtomicCompaction) bInactiveThread = true; else return;
+        }
+
+        if (!tbDoAtomicCompaction || tbDoAtomicCompaction && !bInactiveThread)
+        {
+            maskOffset = y_offs * mask2Dstride + x_offs;
+
+            if ((x_offs >= anchorsRoi.width) ||
+                (!tbInitMaskPositively &&
+                 d_inMask != d_outMask &&
+                 d_inMask[maskOffset] == OBJDET_MASK_ELEMENT_INVALID_32U))
+            {
+                if (tbDoAtomicCompaction) 
+                {
+                    bInactiveThread = true; 
+                }
+                else
+                {
+                    d_outMask[maskOffset] = OBJDET_MASK_ELEMENT_INVALID_32U;
+                    return;
+                }
+            }
+
+            outMaskVal = (y_offs << 16) | x_offs;
+        }
+    }
+
+    NcvBool bPass = true;
+
+    if (!tbDoAtomicCompaction || tbDoAtomicCompaction && !bInactiveThread)
+    {
+        Ncv32f pixelStdDev = d_weights[y_offs * weightsStride + x_offs];
+
+        for (Ncv32u iStage = startStageInc; iStage<endStageExc; iStage++)
+        {
+            Ncv32f curStageSum = 0.0f;
+
+            HaarStage64 curStage = getStage(iStage, d_Stages);
+            Ncv32u numRootNodesInStage = curStage.getNumClassifierRootNodes();
+            Ncv32u curRootNodeOffset = curStage.getStartClassifierRootNodeOffset();
+            Ncv32f stageThreshold = curStage.getStageThreshold();
+
+            while (numRootNodesInStage--)
+            {
+                NcvBool bMoreNodesToTraverse = true;
+                Ncv32u iNode = curRootNodeOffset;
+
+                while (bMoreNodesToTraverse)
+                {
+                    HaarClassifierNode128 curNode = getClassifierNode<tbCacheTextureCascade>(iNode, d_ClassifierNodes);
+                    HaarFeatureDescriptor32 featuresDesc = curNode.getFeatureDesc();
+                    Ncv32u curNodeFeaturesNum = featuresDesc.getNumFeatures();
+                    Ncv32u iFeature = featuresDesc.getFeaturesOffset();
+
+                    Ncv32f curNodeVal = 0.0f;
+
+                    for (Ncv32u iRect=0; iRect<curNodeFeaturesNum; iRect++)
+                    {
+                        Ncv32f rectWeight;
+                        Ncv32u rectX, rectY, rectWidth, rectHeight;
+                        getFeature<tbCacheTextureCascade>
+                            (iFeature + iRect, d_Features,
+                            &rectWeight, &rectX, &rectY, &rectWidth, &rectHeight);
+
+                        Ncv32u iioffsTL = (y_offs + rectY) * IImgStride + (x_offs + rectX);
+                        Ncv32u iioffsTR = iioffsTL + rectWidth;
+                        Ncv32u iioffsBL = iioffsTL + rectHeight * IImgStride;
+                        Ncv32u iioffsBR = iioffsBL + rectWidth;
+
+                        Ncv32u rectSum = getElemIImg<tbCacheTextureIImg>(iioffsBR, d_IImg) -
+                                         getElemIImg<tbCacheTextureIImg>(iioffsBL, d_IImg) +
+                                         getElemIImg<tbCacheTextureIImg>(iioffsTL, d_IImg) -
+                                         getElemIImg<tbCacheTextureIImg>(iioffsTR, d_IImg);
+
+#if defined CPU_FP_COMPLIANCE || defined DISABLE_MAD_SELECTIVELY
+                    curNodeVal += __fmul_rn((Ncv32f)rectSum, rectWeight);
+#else
+                    curNodeVal += (Ncv32f)rectSum * rectWeight;
+#endif
+                    }
+
+                    HaarClassifierNodeDescriptor32 nodeLeft = curNode.getLeftNodeDesc();
+                    HaarClassifierNodeDescriptor32 nodeRight = curNode.getRightNodeDesc();
+                    Ncv32f nodeThreshold = curNode.getThreshold();
+                    HaarClassifierNodeDescriptor32 nextNodeDescriptor;
+                    nextNodeDescriptor = (curNodeVal < scaleArea * pixelStdDev * nodeThreshold) ? nodeLeft : nodeRight;
+
+                    if (nextNodeDescriptor.isLeaf())
+                    {
+                        Ncv32f tmpLeafValue = nextNodeDescriptor.getLeafValue();
+                        curStageSum += tmpLeafValue;
+                        bMoreNodesToTraverse = false;
+                    }
+                    else
+                    {
+                        iNode = nextNodeDescriptor.getNextNodeOffset();
+                    }
+                }
+
+                __syncthreads();
+                curRootNodeOffset++;
+            }
+
+            if (curStageSum < stageThreshold)
+            {
+                bPass = false;
+                outMaskVal = OBJDET_MASK_ELEMENT_INVALID_32U;
+                break;
+            }
+        }
+    }
+
+    __syncthreads();
+
+    if (!tbDoAtomicCompaction)
+    {
+        if (!tbReadPixelIndexFromVector ||
+            (tbReadPixelIndexFromVector && (!bPass || d_inMask != d_outMask)))
+        {
+            d_outMask[maskOffset] = outMaskVal;
+        }
+    }
+    else
+    {
+        compactBlockWriteOutAnchorParallel(bPass && !bInactiveThread,
+                                           outMaskVal,
+                                           d_outMask);
+    }
+}
+
+
+template <NcvBool tbCacheTextureIImg,
+          NcvBool tbCacheTextureCascade,
+          NcvBool tbDoAtomicCompaction>
+__global__ void applyHaarClassifierClassifierParallel(Ncv32u *d_IImg, Ncv32u IImgStride,
+                                                      Ncv32f *d_weights, Ncv32u weightsStride,
+                                                      HaarFeature64 *d_Features, HaarClassifierNode128 *d_ClassifierNodes, HaarStage64 *d_Stages,
+                                                      Ncv32u *d_inMask, Ncv32u *d_outMask,
+                                                      Ncv32u mask1Dlen, Ncv32u mask2Dstride,
+                                                      NcvSize32u anchorsRoi, Ncv32u startStageInc, Ncv32u endStageExc, Ncv32f scaleArea)
+{
+    Ncv32u maskOffset = MAX_GRID_DIM * blockIdx.y + blockIdx.x;
+
+    if (maskOffset >= mask1Dlen)
+    {
+        return;
+    }
+
+    Ncv32u outMaskVal = d_inMask[maskOffset];
+    Ncv32u y_offs = outMaskVal >> 16;
+    Ncv32u x_offs = outMaskVal & 0xFFFF;
+
+    Ncv32f pixelStdDev = d_weights[y_offs * weightsStride + x_offs];
+    NcvBool bPass = true;
+
+    for (Ncv32u iStage = startStageInc; iStage<endStageExc; iStage++)
+    {
+        //this variable is subject to reduction
+        Ncv32f curStageSum = 0.0f;
+
+        HaarStage64 curStage = getStage(iStage, d_Stages);
+        Ncv32s numRootNodesInStage = curStage.getNumClassifierRootNodes();
+        Ncv32u curRootNodeOffset = curStage.getStartClassifierRootNodeOffset() + threadIdx.x;
+        Ncv32f stageThreshold = curStage.getStageThreshold();
+
+        Ncv32u numRootChunks = (numRootNodesInStage + NUM_THREADS_CLASSIFIERPARALLEL - 1) >> NUM_THREADS_CLASSIFIERPARALLEL_LOG2;
+
+        for (Ncv32u chunkId=0; chunkId<numRootChunks; chunkId++)
+        {
+            NcvBool bMoreNodesToTraverse = true;
+
+            if (chunkId * NUM_THREADS_CLASSIFIERPARALLEL + threadIdx.x < numRootNodesInStage)
+            {
+                Ncv32u iNode = curRootNodeOffset;
+
+                while (bMoreNodesToTraverse)
+                {
+                    HaarClassifierNode128 curNode = getClassifierNode<tbCacheTextureCascade>(iNode, d_ClassifierNodes);
+                    HaarFeatureDescriptor32 featuresDesc = curNode.getFeatureDesc();
+                    Ncv32u curNodeFeaturesNum = featuresDesc.getNumFeatures();
+                    Ncv32u iFeature = featuresDesc.getFeaturesOffset();
+
+                    Ncv32f curNodeVal = 0.0f;
+                    //TODO: fetch into shmem if size suffices. Shmem can be shared with reduce
+                    for (Ncv32u iRect=0; iRect<curNodeFeaturesNum; iRect++)
+                    {
+                        Ncv32f rectWeight;
+                        Ncv32u rectX, rectY, rectWidth, rectHeight;
+                        getFeature<tbCacheTextureCascade>
+                            (iFeature + iRect, d_Features,
+                            &rectWeight, &rectX, &rectY, &rectWidth, &rectHeight);
+
+                        Ncv32u iioffsTL = (y_offs + rectY) * IImgStride + (x_offs + rectX);
+                        Ncv32u iioffsTR = iioffsTL + rectWidth;
+                        Ncv32u iioffsBL = iioffsTL + rectHeight * IImgStride;
+                        Ncv32u iioffsBR = iioffsBL + rectWidth;
+
+                        Ncv32u rectSum = getElemIImg<tbCacheTextureIImg>(iioffsBR, d_IImg) -
+                                         getElemIImg<tbCacheTextureIImg>(iioffsBL, d_IImg) +
+                                         getElemIImg<tbCacheTextureIImg>(iioffsTL, d_IImg) -
+                                         getElemIImg<tbCacheTextureIImg>(iioffsTR, d_IImg);
+
+#if defined CPU_FP_COMPLIANCE || defined DISABLE_MAD_SELECTIVELY
+                        curNodeVal += __fmul_rn((Ncv32f)rectSum, rectWeight);
+#else
+                        curNodeVal += (Ncv32f)rectSum * rectWeight;
+#endif
+                    }
+
+                    HaarClassifierNodeDescriptor32 nodeLeft = curNode.getLeftNodeDesc();
+                    HaarClassifierNodeDescriptor32 nodeRight = curNode.getRightNodeDesc();
+                    Ncv32f nodeThreshold = curNode.getThreshold();
+                    HaarClassifierNodeDescriptor32 nextNodeDescriptor;
+                    nextNodeDescriptor = (curNodeVal < scaleArea * pixelStdDev * nodeThreshold) ? nodeLeft : nodeRight;
+
+                    if (nextNodeDescriptor.isLeaf())
+                    {
+                        Ncv32f tmpLeafValue = nextNodeDescriptor.getLeafValue();
+                        curStageSum += tmpLeafValue;
+                        bMoreNodesToTraverse = false;
+                    }
+                    else
+                    {
+                        iNode = nextNodeDescriptor.getNextNodeOffset();
+                    }
+                }
+            }
+            __syncthreads();
+
+            curRootNodeOffset += NUM_THREADS_CLASSIFIERPARALLEL;
+        }
+
+        Ncv32f finalStageSum = reduceSpecialization(curStageSum);
+
+        if (finalStageSum < stageThreshold)
+        {
+            bPass = false;
+            outMaskVal = OBJDET_MASK_ELEMENT_INVALID_32U;
+            break;
+        }
+    }
+
+    if (!tbDoAtomicCompaction)
+    {
+        if (!bPass || d_inMask != d_outMask)
+        {
+            if (!threadIdx.x)
+            {
+                d_outMask[maskOffset] = outMaskVal;
+            }
+        }
+    }
+    else
+    {
+#if __CUDA_ARCH__ >= 110
+        if (bPass && !threadIdx.x)
+        {
+            Ncv32u outMaskOffset = atomicAdd(&d_outMaskPosition, 1);
+            d_outMask[outMaskOffset] = outMaskVal;
+        }
+#endif
+    }
+}
+
+
+template <NcvBool tbMaskByInmask,
+          NcvBool tbDoAtomicCompaction>
+__global__ void initializeMaskVector(Ncv32u *d_inMask, Ncv32u *d_outMask,
+                                     Ncv32u mask1Dlen, Ncv32u mask2Dstride,
+                                     NcvSize32u anchorsRoi, Ncv32u step)
+{
+    Ncv32u y_offs = blockIdx.y;
+    Ncv32u x_offs = blockIdx.x * NUM_THREADS_ANCHORSPARALLEL + threadIdx.x;
+    Ncv32u outMaskOffset = y_offs * gridDim.x * blockDim.x + x_offs;
+
+    Ncv32u y_offs_upsc = step * y_offs;
+    Ncv32u x_offs_upsc = step * x_offs;
+    Ncv32u inMaskOffset = y_offs_upsc * mask2Dstride + x_offs_upsc;
+
+    Ncv32u outElem = OBJDET_MASK_ELEMENT_INVALID_32U;
+
+    if (x_offs_upsc < anchorsRoi.width &&
+        (!tbMaskByInmask || d_inMask[inMaskOffset] != OBJDET_MASK_ELEMENT_INVALID_32U))
+    {
+        outElem = (y_offs_upsc << 16) | x_offs_upsc;
+    }
+
+    if (!tbDoAtomicCompaction)
+    {
+        d_outMask[outMaskOffset] = outElem;
+    }
+    else
+    {
+        compactBlockWriteOutAnchorParallel(outElem != OBJDET_MASK_ELEMENT_INVALID_32U,
+                                           outElem,
+                                           d_outMask);
+    }
+}
+
+
+struct applyHaarClassifierAnchorParallelFunctor
+{
+    dim3 gridConf, blockConf;
+    cudaStream_t cuStream;
+
+    //Kernel arguments are stored as members;
+    Ncv32u *d_IImg;
+    Ncv32u IImgStride;
+    Ncv32f *d_weights;
+    Ncv32u weightsStride;
+    HaarFeature64 *d_Features;
+    HaarClassifierNode128 *d_ClassifierNodes;
+    HaarStage64 *d_Stages;
+    Ncv32u *d_inMask;
+    Ncv32u *d_outMask;
+    Ncv32u mask1Dlen;
+    Ncv32u mask2Dstride;
+    NcvSize32u anchorsRoi;
+    Ncv32u startStageInc;
+    Ncv32u endStageExc;
+    Ncv32f scaleArea;
+
+    //Arguments are passed through the constructor
+    applyHaarClassifierAnchorParallelFunctor(dim3 _gridConf, dim3 _blockConf, cudaStream_t _cuStream,
+                                             Ncv32u *_d_IImg, Ncv32u _IImgStride,
+                                             Ncv32f *_d_weights, Ncv32u _weightsStride,
+                                             HaarFeature64 *_d_Features, HaarClassifierNode128 *_d_ClassifierNodes, HaarStage64 *_d_Stages,
+                                             Ncv32u *_d_inMask, Ncv32u *_d_outMask,
+                                             Ncv32u _mask1Dlen, Ncv32u _mask2Dstride,
+                                             NcvSize32u _anchorsRoi, Ncv32u _startStageInc,
+                                             Ncv32u _endStageExc, Ncv32f _scaleArea) :
+    gridConf(_gridConf),
+    blockConf(_blockConf),
+    cuStream(_cuStream),
+    d_IImg(_d_IImg),
+    IImgStride(_IImgStride),
+    d_weights(_d_weights),
+    weightsStride(_weightsStride),
+    d_Features(_d_Features),
+    d_ClassifierNodes(_d_ClassifierNodes),
+    d_Stages(_d_Stages),
+    d_inMask(_d_inMask),
+    d_outMask(_d_outMask),
+    mask1Dlen(_mask1Dlen),
+    mask2Dstride(_mask2Dstride),
+    anchorsRoi(_anchorsRoi),
+    startStageInc(_startStageInc),
+    endStageExc(_endStageExc),
+    scaleArea(_scaleArea)
+    {}
+
+    template<class TList>
+    void call(TList tl)
+    {
+        applyHaarClassifierAnchorParallel <
+            Loki::TL::TypeAt<TList, 0>::Result::value,
+            Loki::TL::TypeAt<TList, 1>::Result::value,
+            Loki::TL::TypeAt<TList, 2>::Result::value,
+            Loki::TL::TypeAt<TList, 3>::Result::value,
+            Loki::TL::TypeAt<TList, 4>::Result::value >
+            <<<gridConf, blockConf, 0, cuStream>>>
+            (d_IImg, IImgStride,
+            d_weights, weightsStride,
+            d_Features, d_ClassifierNodes, d_Stages,
+            d_inMask, d_outMask,
+            mask1Dlen, mask2Dstride,
+            anchorsRoi, startStageInc,
+            endStageExc, scaleArea);
+    }
+};
+
+
+void applyHaarClassifierAnchorParallelDynTemplate(NcvBool tbInitMaskPositively,
+                                                  NcvBool tbCacheTextureIImg,
+                                                  NcvBool tbCacheTextureCascade,
+                                                  NcvBool tbReadPixelIndexFromVector,
+                                                  NcvBool tbDoAtomicCompaction,
+
+                                                  dim3 gridConf, dim3 blockConf, cudaStream_t cuStream,
+
+                                                  Ncv32u *d_IImg, Ncv32u IImgStride,
+                                                  Ncv32f *d_weights, Ncv32u weightsStride,
+                                                  HaarFeature64 *d_Features, HaarClassifierNode128 *d_ClassifierNodes, HaarStage64 *d_Stages,
+                                                  Ncv32u *d_inMask, Ncv32u *d_outMask,
+                                                  Ncv32u mask1Dlen, Ncv32u mask2Dstride,
+                                                  NcvSize32u anchorsRoi, Ncv32u startStageInc,
+                                                  Ncv32u endStageExc, Ncv32f scaleArea)
+{
+    //Second parameter is the number of "dynamic" template parameters
+    NCVRuntimeTemplateBool::KernelCaller<Loki::NullType, 5, applyHaarClassifierAnchorParallelFunctor>
+        ::call( applyHaarClassifierAnchorParallelFunctor(gridConf, blockConf, cuStream,
+                                                         d_IImg, IImgStride,
+                                                         d_weights, weightsStride,
+                                                         d_Features, d_ClassifierNodes, d_Stages,
+                                                         d_inMask, d_outMask,
+                                                         mask1Dlen, mask2Dstride,
+                                                         anchorsRoi, startStageInc,
+                                                         endStageExc, scaleArea),
+        0xC001C0DE, //this is dummy int for the va_args C compatibility
+        tbInitMaskPositively,
+        tbCacheTextureIImg,
+        tbCacheTextureCascade,
+        tbReadPixelIndexFromVector,
+        tbDoAtomicCompaction);
+}
+
+
+struct applyHaarClassifierClassifierParallelFunctor
+{
+    dim3 gridConf, blockConf;
+    cudaStream_t cuStream;
+
+    //Kernel arguments are stored as members;
+    Ncv32u *d_IImg;
+    Ncv32u IImgStride;
+    Ncv32f *d_weights;
+    Ncv32u weightsStride;
+    HaarFeature64 *d_Features;
+    HaarClassifierNode128 *d_ClassifierNodes;
+    HaarStage64 *d_Stages;
+    Ncv32u *d_inMask;
+    Ncv32u *d_outMask;
+    Ncv32u mask1Dlen;
+    Ncv32u mask2Dstride;
+    NcvSize32u anchorsRoi;
+    Ncv32u startStageInc;
+    Ncv32u endStageExc;
+    Ncv32f scaleArea;
+
+    //Arguments are passed through the constructor
+    applyHaarClassifierClassifierParallelFunctor(dim3 _gridConf, dim3 _blockConf, cudaStream_t _cuStream,
+                                                 Ncv32u *_d_IImg, Ncv32u _IImgStride,
+                                                 Ncv32f *_d_weights, Ncv32u _weightsStride,
+                                                 HaarFeature64 *_d_Features, HaarClassifierNode128 *_d_ClassifierNodes, HaarStage64 *_d_Stages,
+                                                 Ncv32u *_d_inMask, Ncv32u *_d_outMask,
+                                                 Ncv32u _mask1Dlen, Ncv32u _mask2Dstride,
+                                                 NcvSize32u _anchorsRoi, Ncv32u _startStageInc,
+                                                 Ncv32u _endStageExc, Ncv32f _scaleArea) :
+    gridConf(_gridConf),
+    blockConf(_blockConf),
+    cuStream(_cuStream),
+    d_IImg(_d_IImg),
+    IImgStride(_IImgStride),
+    d_weights(_d_weights),
+    weightsStride(_weightsStride),
+    d_Features(_d_Features),
+    d_ClassifierNodes(_d_ClassifierNodes),
+    d_Stages(_d_Stages),
+    d_inMask(_d_inMask),
+    d_outMask(_d_outMask),
+    mask1Dlen(_mask1Dlen),
+    mask2Dstride(_mask2Dstride),
+    anchorsRoi(_anchorsRoi),
+    startStageInc(_startStageInc),
+    endStageExc(_endStageExc),
+    scaleArea(_scaleArea)
+    {}
+
+    template<class TList>
+    void call(TList tl)
+    {
+        applyHaarClassifierClassifierParallel <
+            Loki::TL::TypeAt<TList, 0>::Result::value,
+            Loki::TL::TypeAt<TList, 1>::Result::value,
+            Loki::TL::TypeAt<TList, 2>::Result::value >
+            <<<gridConf, blockConf, 0, cuStream>>>
+            (d_IImg, IImgStride,
+            d_weights, weightsStride,
+            d_Features, d_ClassifierNodes, d_Stages,
+            d_inMask, d_outMask,
+            mask1Dlen, mask2Dstride,
+            anchorsRoi, startStageInc,
+            endStageExc, scaleArea);
+    }
+};
+
+
+void applyHaarClassifierClassifierParallelDynTemplate(NcvBool tbCacheTextureIImg,
+                                                      NcvBool tbCacheTextureCascade,
+                                                      NcvBool tbDoAtomicCompaction,
+
+                                                      dim3 gridConf, dim3 blockConf, cudaStream_t cuStream,
+
+                                                      Ncv32u *d_IImg, Ncv32u IImgStride,
+                                                      Ncv32f *d_weights, Ncv32u weightsStride,
+                                                      HaarFeature64 *d_Features, HaarClassifierNode128 *d_ClassifierNodes, HaarStage64 *d_Stages,
+                                                      Ncv32u *d_inMask, Ncv32u *d_outMask,
+                                                      Ncv32u mask1Dlen, Ncv32u mask2Dstride,
+                                                      NcvSize32u anchorsRoi, Ncv32u startStageInc,
+                                                      Ncv32u endStageExc, Ncv32f scaleArea)
+{
+    //Second parameter is the number of "dynamic" template parameters
+    NCVRuntimeTemplateBool::KernelCaller<Loki::NullType, 3, applyHaarClassifierClassifierParallelFunctor>
+        ::call( applyHaarClassifierClassifierParallelFunctor(gridConf, blockConf, cuStream,
+                                                             d_IImg, IImgStride,
+                                                             d_weights, weightsStride,
+                                                             d_Features, d_ClassifierNodes, d_Stages,
+                                                             d_inMask, d_outMask,
+                                                             mask1Dlen, mask2Dstride,
+                                                             anchorsRoi, startStageInc,
+                                                             endStageExc, scaleArea),
+        0xC001C0DE, //this is dummy int for the va_args C compatibility
+        tbCacheTextureIImg,
+        tbCacheTextureCascade,
+        tbDoAtomicCompaction);
+}
+
+
+struct initializeMaskVectorFunctor
+{
+    dim3 gridConf, blockConf;
+    cudaStream_t cuStream;
+
+    //Kernel arguments are stored as members;
+    Ncv32u *d_inMask;
+    Ncv32u *d_outMask;
+    Ncv32u mask1Dlen;
+    Ncv32u mask2Dstride;
+    NcvSize32u anchorsRoi;
+    Ncv32u step;
+
+    //Arguments are passed through the constructor
+    initializeMaskVectorFunctor(dim3 _gridConf, dim3 _blockConf, cudaStream_t _cuStream,
+                                Ncv32u *_d_inMask, Ncv32u *_d_outMask,
+                                Ncv32u _mask1Dlen, Ncv32u _mask2Dstride,
+                                NcvSize32u _anchorsRoi, Ncv32u _step) :
+    gridConf(_gridConf),
+    blockConf(_blockConf),
+    cuStream(_cuStream),
+    d_inMask(_d_inMask),
+    d_outMask(_d_outMask),
+    mask1Dlen(_mask1Dlen),
+    mask2Dstride(_mask2Dstride),
+    anchorsRoi(_anchorsRoi),
+    step(_step)
+    {}
+
+    template<class TList>
+    void call(TList tl)
+    {
+        initializeMaskVector <
+            Loki::TL::TypeAt<TList, 0>::Result::value,
+            Loki::TL::TypeAt<TList, 1>::Result::value >
+            <<<gridConf, blockConf, 0, cuStream>>>
+            (d_inMask, d_outMask,
+             mask1Dlen, mask2Dstride,
+             anchorsRoi, step);
+    }
+};
+
+
+void initializeMaskVectorDynTemplate(NcvBool tbMaskByInmask,
+                                     NcvBool tbDoAtomicCompaction,
+
+                                     dim3 gridConf, dim3 blockConf, cudaStream_t cuStream,
+
+                                     Ncv32u *d_inMask, Ncv32u *d_outMask,
+                                     Ncv32u mask1Dlen, Ncv32u mask2Dstride,
+                                     NcvSize32u anchorsRoi, Ncv32u step)
+{
+    //Second parameter is the number of "dynamic" template parameters
+    NCVRuntimeTemplateBool::KernelCaller<Loki::NullType, 2, initializeMaskVectorFunctor>
+        ::call( initializeMaskVectorFunctor(gridConf, blockConf, cuStream,
+                                            d_inMask, d_outMask,
+                                            mask1Dlen, mask2Dstride,
+                                            anchorsRoi, step),
+        0xC001C0DE, //this is dummy int for the va_args C compatibility
+        tbMaskByInmask,
+        tbDoAtomicCompaction);
+}
+
+
+Ncv32u getStageNumWithNotLessThanNclassifiers(Ncv32u N, HaarClassifierCascadeDescriptor &haar,
+                                              NCVVector<HaarStage64> &h_HaarStages)
+{
+    Ncv32u i = 0;
+    for (; i<haar.NumStages; i++)
+    {
+        if (h_HaarStages.ptr()[i].getNumClassifierRootNodes() >= N)
+        {
+            break;
+        }
+    }
+    return i;
+}
+
+
+template <class T>
+void swap(T &p1, T &p2)
+{
+    T tmp = p1;
+    p1 = p2;
+    p2 = tmp;
+}
+
+
+NCVStatus ncvApplyHaarClassifierCascade_device(NCVMatrix<Ncv32u> &d_integralImage,
+                                               NCVMatrix<Ncv32f> &d_weights,
+                                               NCVMatrixAlloc<Ncv32u> &d_pixelMask,
+                                               Ncv32u &numDetections,
+                                               HaarClassifierCascadeDescriptor &haar,
+                                               NCVVector<HaarStage64> &h_HaarStages,
+                                               NCVVector<HaarStage64> &d_HaarStages,
+                                               NCVVector<HaarClassifierNode128> &d_HaarNodes,
+                                               NCVVector<HaarFeature64> &d_HaarFeatures,
+                                               NcvBool bMaskElements,
+                                               NcvSize32u anchorsRoi,
+                                               Ncv32u pixelStep,
+                                               Ncv32f scaleArea,
+                                               INCVMemAllocator &gpuAllocator,
+                                               INCVMemAllocator &cpuAllocator,
+                                               Ncv32u devPropMajor,
+                                               Ncv32u devPropMinor,
+                                               cudaStream_t cuStream)
+{
+    ncvAssertReturn(d_integralImage.memType() == d_weights.memType() &&
+                    d_integralImage.memType() == d_pixelMask.memType() &&
+                    d_integralImage.memType() == gpuAllocator.memType() &&
+                     (d_integralImage.memType() == NCVMemoryTypeDevice ||
+                      d_integralImage.memType() == NCVMemoryTypeNone), NCV_MEM_RESIDENCE_ERROR);
+    ncvAssertReturn(d_HaarStages.memType() == d_HaarNodes.memType() &&
+                    d_HaarStages.memType() == d_HaarFeatures.memType() &&
+                     (d_HaarStages.memType() == NCVMemoryTypeDevice ||
+                      d_HaarStages.memType() == NCVMemoryTypeNone), NCV_MEM_RESIDENCE_ERROR);
+    ncvAssertReturn(h_HaarStages.memType() != NCVMemoryTypeDevice, NCV_MEM_RESIDENCE_ERROR);
+    ncvAssertReturn(gpuAllocator.isInitialized() && cpuAllocator.isInitialized(), NCV_ALLOCATOR_NOT_INITIALIZED);
+    ncvAssertReturn((d_integralImage.ptr() != NULL && d_weights.ptr() != NULL && d_pixelMask.ptr() != NULL &&
+                     h_HaarStages.ptr() != NULL && d_HaarStages.ptr() != NULL && d_HaarNodes.ptr() != NULL &&
+                     d_HaarFeatures.ptr() != NULL) || gpuAllocator.isCounting(), NCV_NULL_PTR);
+    ncvAssertReturn(anchorsRoi.width > 0 && anchorsRoi.height > 0 &&
+                    d_pixelMask.width() >= anchorsRoi.width && d_pixelMask.height() >= anchorsRoi.height &&
+                    d_weights.width() >= anchorsRoi.width && d_weights.height() >= anchorsRoi.height &&
+                    d_integralImage.width() >= anchorsRoi.width + haar.ClassifierSize.width &&
+                    d_integralImage.height() >= anchorsRoi.height + haar.ClassifierSize.height, NCV_DIMENSIONS_INVALID);
+    ncvAssertReturn(scaleArea > 0, NCV_INVALID_SCALE);
+    ncvAssertReturn(d_HaarStages.length() >= haar.NumStages &&
+                    d_HaarNodes.length() >= haar.NumClassifierTotalNodes &&
+                    d_HaarFeatures.length() >= haar.NumFeatures &&
+                    d_HaarStages.length() == h_HaarStages.length() &&
+                    haar.NumClassifierRootNodes <= haar.NumClassifierTotalNodes, NCV_DIMENSIONS_INVALID);
+    ncvAssertReturn(haar.bNeedsTiltedII == false || gpuAllocator.isCounting(), NCV_NOIMPL_HAAR_TILTED_FEATURES);
+    ncvAssertReturn(pixelStep == 1 || pixelStep == 2, NCV_HAAR_INVALID_PIXEL_STEP);
+
+    NCV_SET_SKIP_COND(gpuAllocator.isCounting());
+
+#if defined _SELF_TEST_
+
+    NCVStatus ncvStat;
+
+    NCVMatrixAlloc<Ncv32u> h_integralImage(cpuAllocator, d_integralImage.width, d_integralImage.height, d_integralImage.pitch);
+    ncvAssertReturn(h_integralImage.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    NCVMatrixAlloc<Ncv32f> h_weights(cpuAllocator, d_weights.width, d_weights.height, d_weights.pitch);
+    ncvAssertReturn(h_weights.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    NCVMatrixAlloc<Ncv32u> h_pixelMask(cpuAllocator, d_pixelMask.width, d_pixelMask.height, d_pixelMask.pitch);
+    ncvAssertReturn(h_pixelMask.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    NCVVectorAlloc<HaarClassifierNode128> h_HaarNodes(cpuAllocator, d_HaarNodes.length);
+    ncvAssertReturn(h_HaarNodes.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    NCVVectorAlloc<HaarFeature64> h_HaarFeatures(cpuAllocator, d_HaarFeatures.length);
+    ncvAssertReturn(h_HaarFeatures.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    NCVMatrixAlloc<Ncv32u> h_pixelMask_d(cpuAllocator, d_pixelMask.width, d_pixelMask.height, d_pixelMask.pitch);
+    ncvAssertReturn(h_pixelMask_d.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    NCV_SKIP_COND_BEGIN
+
+    ncvStat = d_pixelMask.copySolid(h_pixelMask, 0);
+    ncvAssertReturnNcvStat(ncvStat);
+    ncvStat = d_integralImage.copySolid(h_integralImage, 0);
+    ncvAssertReturnNcvStat(ncvStat);
+    ncvStat = d_weights.copySolid(h_weights, 0);
+    ncvAssertReturnNcvStat(ncvStat);
+    ncvStat = d_HaarNodes.copySolid(h_HaarNodes, 0);
+    ncvAssertReturnNcvStat(ncvStat);
+    ncvStat = d_HaarFeatures.copySolid(h_HaarFeatures, 0);
+    ncvAssertReturnNcvStat(ncvStat);
+    ncvAssertCUDAReturn(cudaStreamSynchronize(0), NCV_CUDA_ERROR);
+
+    for (Ncv32u i=0; i<(Ncv32u)anchorsRoi.height; i++)
+    {
+        for (Ncv32u j=0; j<d_pixelMask.stride(); j++)
+        {
+            if ((i%pixelStep==0) && (j%pixelStep==0) && (j<(Ncv32u)anchorsRoi.width))
+            {
+                if (!bMaskElements || h_pixelMask.ptr[i*d_pixelMask.stride()+j] != OBJDET_MASK_ELEMENT_INVALID_32U)
+                {
+                    h_pixelMask.ptr[i*d_pixelMask.stride()+j] = (i << 16) | j;
+                }
+            }
+            else
+            {
+                h_pixelMask.ptr[i*d_pixelMask.stride()+j] = OBJDET_MASK_ELEMENT_INVALID_32U;
+            }
+        }
+    }
+
+    NCV_SKIP_COND_END
+
+#endif
+
+    NCVVectorReuse<Ncv32u> d_vecPixelMask(d_pixelMask.getSegment(), anchorsRoi.height * d_pixelMask.stride());
+    ncvAssertReturn(d_vecPixelMask.isMemReused(), NCV_ALLOCATOR_BAD_REUSE);
+
+    NCVVectorAlloc<Ncv32u> d_vecPixelMaskTmp(gpuAllocator, d_vecPixelMask.length());
+    ncvAssertReturn(d_vecPixelMaskTmp.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    NCVVectorAlloc<Ncv32u> hp_pool32u(cpuAllocator, 2);
+    ncvAssertReturn(hp_pool32u.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    Ncv32u *hp_zero = &hp_pool32u.ptr()[0];
+    Ncv32u *hp_numDet = &hp_pool32u.ptr()[1];
+
+    NCV_SKIP_COND_BEGIN
+    *hp_zero = 0;
+    *hp_numDet = 0;
+    NCV_SKIP_COND_END
+
+    Ncv32f scaleAreaPixels = scaleArea * ((haar.ClassifierSize.width - 2*HAAR_STDDEV_BORDER) *
+                                          (haar.ClassifierSize.height - 2*HAAR_STDDEV_BORDER));
+
+    NcvBool bTexCacheCascade = devPropMajor < 2;
+    NcvBool bTexCacheIImg = true; //this works better even on Fermi so far
+    NcvBool bDoAtomicCompaction = devPropMajor >= 2 || (devPropMajor == 1 && devPropMinor >= 3);
+
+    NCVVector<Ncv32u> *d_ptrNowData = &d_vecPixelMask;
+    NCVVector<Ncv32u> *d_ptrNowTmp = &d_vecPixelMaskTmp;
+
+    Ncv32u szNppCompactTmpBuf;
+    nppsStCompactGetSize_32u(d_vecPixelMask.length(), &szNppCompactTmpBuf);
+    if (bDoAtomicCompaction)
+    {
+        szNppCompactTmpBuf = 0;
+    }
+    NCVVectorAlloc<Ncv8u> d_tmpBufCompact(gpuAllocator, szNppCompactTmpBuf);
+
+    NCV_SKIP_COND_BEGIN
+
+    if (bTexCacheIImg)
+    {
+        cudaChannelFormatDesc cfdTexIImage;
+        cfdTexIImage = cudaCreateChannelDesc<Ncv32u>();
+
+        size_t alignmentOffset;
+        ncvAssertCUDAReturn(cudaBindTexture(&alignmentOffset, texIImage, d_integralImage.ptr(), cfdTexIImage,
+            (anchorsRoi.height + haar.ClassifierSize.height) * d_integralImage.pitch()), NCV_CUDA_ERROR);
+        ncvAssertReturn(alignmentOffset==0, NCV_TEXTURE_BIND_ERROR);
+    }
+
+    if (bTexCacheCascade)
+    {
+        cudaChannelFormatDesc cfdTexHaarFeatures;
+        cudaChannelFormatDesc cfdTexHaarClassifierNodes;
+        cfdTexHaarFeatures = cudaCreateChannelDesc<uint2>();
+        cfdTexHaarClassifierNodes = cudaCreateChannelDesc<uint4>();
+
+        size_t alignmentOffset;
+        ncvAssertCUDAReturn(cudaBindTexture(&alignmentOffset, texHaarFeatures,
+            d_HaarFeatures.ptr(), cfdTexHaarFeatures,sizeof(HaarFeature64) * haar.NumFeatures), NCV_CUDA_ERROR);
+        ncvAssertReturn(alignmentOffset==0, NCV_TEXTURE_BIND_ERROR);
+        ncvAssertCUDAReturn(cudaBindTexture(&alignmentOffset, texHaarClassifierNodes,
+            d_HaarNodes.ptr(), cfdTexHaarClassifierNodes, sizeof(HaarClassifierNode128) * haar.NumClassifierTotalNodes), NCV_CUDA_ERROR);
+        ncvAssertReturn(alignmentOffset==0, NCV_TEXTURE_BIND_ERROR);
+    }
+
+    Ncv32u stageStartAnchorParallel = 0;
+    Ncv32u stageMiddleSwitch = getStageNumWithNotLessThanNclassifiers(NUM_THREADS_CLASSIFIERPARALLEL,
+        haar, h_HaarStages);
+    Ncv32u stageEndClassifierParallel = haar.NumStages;
+    if (stageMiddleSwitch == 0)
+    {
+        stageMiddleSwitch = 1;
+    }
+
+    //create stages subdivision for pixel-parallel processing
+    const Ncv32u compactEveryNstage = bDoAtomicCompaction ? 7 : 1;
+    Ncv32u curStop = stageStartAnchorParallel;
+    std::vector<Ncv32u> pixParallelStageStops;
+    while (curStop < stageMiddleSwitch)
+    {
+        pixParallelStageStops.push_back(curStop);
+        curStop += compactEveryNstage;
+    }
+    if (curStop > compactEveryNstage && curStop - stageMiddleSwitch > compactEveryNstage / 2)
+    {
+        pixParallelStageStops[pixParallelStageStops.size()-1] = 
+            (stageMiddleSwitch - (curStop - 2 * compactEveryNstage)) / 2;
+    }
+    pixParallelStageStops.push_back(stageMiddleSwitch);
+    Ncv32u pixParallelStageStopsIndex = 0;
+
+    if (pixelStep != 1 || bMaskElements)
+    {
+        if (bDoAtomicCompaction)
+        {
+            ncvAssertCUDAReturn(cudaMemcpyToSymbolAsync(d_outMaskPosition, hp_zero, sizeof(Ncv32u),
+                                                        0, cudaMemcpyHostToDevice, cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+        }
+
+        dim3 gridInit((((anchorsRoi.width + pixelStep - 1) / pixelStep + NUM_THREADS_ANCHORSPARALLEL - 1) / NUM_THREADS_ANCHORSPARALLEL),
+                        (anchorsRoi.height + pixelStep - 1) / pixelStep);
+        dim3 blockInit(NUM_THREADS_ANCHORSPARALLEL);
+
+        if (gridInit.x == 0 || gridInit.y == 0)
+        {
+            numDetections = 0;
+            return NCV_SUCCESS;
+        }
+
+        initializeMaskVectorDynTemplate(bMaskElements,
+                                        bDoAtomicCompaction,
+                                        gridInit, blockInit, cuStream,
+                                        d_ptrNowData->ptr(),
+                                        d_ptrNowTmp->ptr(),
+                                        d_vecPixelMask.length(), d_pixelMask.stride(),
+                                        anchorsRoi, pixelStep);
+        ncvAssertCUDAReturn(cudaGetLastError(), NCV_CUDA_ERROR);
+
+        if (bDoAtomicCompaction)
+        {
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaMemcpyFromSymbolAsync(hp_numDet, d_outMaskPosition, sizeof(Ncv32u),
+                                                          0, cudaMemcpyDeviceToHost, cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+            swap(d_ptrNowData, d_ptrNowTmp);
+        }
+        else
+        {
+            NppStStatus nppSt;
+            nppSt = nppsStCompact_32u(d_ptrNowTmp->ptr(), d_vecPixelMask.length(),
+                                      d_ptrNowData->ptr(), hp_numDet, OBJDET_MASK_ELEMENT_INVALID_32U,
+                                      d_tmpBufCompact.ptr(), szNppCompactTmpBuf);
+            ncvAssertReturn(nppSt == NPP_SUCCESS, NCV_NPP_ERROR);
+        }
+        numDetections = *hp_numDet;
+    }
+    else
+    {
+        //
+        // 1. Run the first pixel-input pixel-parallel classifier for few stages
+        //
+
+        if (bDoAtomicCompaction)
+        {
+            ncvAssertCUDAReturn(cudaMemcpyToSymbolAsync(d_outMaskPosition, hp_zero, sizeof(Ncv32u),
+                                                        0, cudaMemcpyHostToDevice, cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+        }
+
+        dim3 grid1(((d_pixelMask.stride() + NUM_THREADS_ANCHORSPARALLEL - 1) / NUM_THREADS_ANCHORSPARALLEL),
+                   anchorsRoi.height);
+        dim3 block1(NUM_THREADS_ANCHORSPARALLEL);
+        applyHaarClassifierAnchorParallelDynTemplate(
+            true,                         //tbInitMaskPositively
+            bTexCacheIImg,                //tbCacheTextureIImg
+            bTexCacheCascade,             //tbCacheTextureCascade
+            pixParallelStageStops[pixParallelStageStopsIndex] != 0,//tbReadPixelIndexFromVector
+            bDoAtomicCompaction,          //tbDoAtomicCompaction
+            grid1,
+            block1,
+            cuStream,
+            d_integralImage.ptr(), d_integralImage.stride(),
+            d_weights.ptr(), d_weights.stride(),
+            d_HaarFeatures.ptr(), d_HaarNodes.ptr(), d_HaarStages.ptr(),
+            d_ptrNowData->ptr(),
+            bDoAtomicCompaction ? d_ptrNowTmp->ptr() : d_ptrNowData->ptr(),
+            0,
+            d_pixelMask.stride(),
+            anchorsRoi,
+            pixParallelStageStops[pixParallelStageStopsIndex],
+            pixParallelStageStops[pixParallelStageStopsIndex+1],
+            scaleAreaPixels);
+        ncvAssertCUDAReturn(cudaGetLastError(), NCV_CUDA_ERROR);
+
+        if (bDoAtomicCompaction)
+        {
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaMemcpyFromSymbolAsync(hp_numDet, d_outMaskPosition, sizeof(Ncv32u),
+                                                          0, cudaMemcpyDeviceToHost, cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+        }
+        else
+        {
+            NppStStatus nppSt;
+            nppSt = nppsStCompact_32u(d_ptrNowData->ptr(), d_vecPixelMask.length(),
+                                      d_ptrNowTmp->ptr(), hp_numDet, OBJDET_MASK_ELEMENT_INVALID_32U,
+                                      d_tmpBufCompact.ptr(), szNppCompactTmpBuf);
+            ncvAssertReturn(nppSt == NPP_SUCCESS, NCV_NPP_ERROR);
+        }
+
+        swap(d_ptrNowData, d_ptrNowTmp);
+        numDetections = *hp_numDet;
+
+        pixParallelStageStopsIndex++;
+    }
+
+    //
+    // 2. Run pixel-parallel stages
+    //
+
+    for (; pixParallelStageStopsIndex < pixParallelStageStops.size()-1; pixParallelStageStopsIndex++)
+    {
+        if (numDetections == 0)
+        {
+            break;
+        }
+
+        if (bDoAtomicCompaction)
+        {
+            ncvAssertCUDAReturn(cudaMemcpyToSymbolAsync(d_outMaskPosition, hp_zero, sizeof(Ncv32u),
+                                                        0, cudaMemcpyHostToDevice, cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+        }
+
+        dim3 grid2((numDetections + NUM_THREADS_ANCHORSPARALLEL - 1) / NUM_THREADS_ANCHORSPARALLEL);
+        if (numDetections > MAX_GRID_DIM)
+        {
+            grid2.x = MAX_GRID_DIM;
+            grid2.y = (numDetections + MAX_GRID_DIM - 1) / MAX_GRID_DIM;
+        }
+        dim3 block2(NUM_THREADS_ANCHORSPARALLEL);
+
+        applyHaarClassifierAnchorParallelDynTemplate(
+            false,                        //tbInitMaskPositively
+            bTexCacheIImg,                //tbCacheTextureIImg
+            bTexCacheCascade,             //tbCacheTextureCascade
+            pixParallelStageStops[pixParallelStageStopsIndex] != 0 || pixelStep != 1 || bMaskElements,//tbReadPixelIndexFromVector
+            bDoAtomicCompaction,          //tbDoAtomicCompaction
+            grid2,
+            block2,
+            cuStream,
+            d_integralImage.ptr(), d_integralImage.stride(),
+            d_weights.ptr(), d_weights.stride(),
+            d_HaarFeatures.ptr(), d_HaarNodes.ptr(), d_HaarStages.ptr(),
+            d_ptrNowData->ptr(),
+            bDoAtomicCompaction ? d_ptrNowTmp->ptr() : d_ptrNowData->ptr(),
+            numDetections,
+            d_pixelMask.stride(),
+            anchorsRoi,
+            pixParallelStageStops[pixParallelStageStopsIndex],
+            pixParallelStageStops[pixParallelStageStopsIndex+1],
+            scaleAreaPixels);
+        ncvAssertCUDAReturn(cudaGetLastError(), NCV_CUDA_ERROR);
+
+        if (bDoAtomicCompaction)
+        {
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaMemcpyFromSymbolAsync(hp_numDet, d_outMaskPosition, sizeof(Ncv32u),
+                                                          0, cudaMemcpyDeviceToHost, cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+        }
+        else
+        {
+            NppStStatus nppSt;
+            nppSt = nppsStCompact_32u(d_ptrNowData->ptr(), numDetections,
+                                      d_ptrNowTmp->ptr(), hp_numDet, OBJDET_MASK_ELEMENT_INVALID_32U,
+                                      d_tmpBufCompact.ptr(), szNppCompactTmpBuf);
+            ncvAssertReturn(nppSt == NPP_SUCCESS, NCV_NPP_ERROR);
+        }
+
+        swap(d_ptrNowData, d_ptrNowTmp);
+        numDetections = *hp_numDet;
+    }
+
+    //
+    // 3. Run all left stages in one stage-parallel kernel
+    //
+
+    if (numDetections > 0 && stageMiddleSwitch < stageEndClassifierParallel)
+    {
+        if (bDoAtomicCompaction)
+        {
+            ncvAssertCUDAReturn(cudaMemcpyToSymbolAsync(d_outMaskPosition, hp_zero, sizeof(Ncv32u),
+                                                        0, cudaMemcpyHostToDevice, cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+        }
+
+        dim3 grid3(numDetections);
+        if (numDetections > MAX_GRID_DIM)
+        {
+            grid3.x = MAX_GRID_DIM;
+            grid3.y = (numDetections + MAX_GRID_DIM - 1) / MAX_GRID_DIM;
+        }
+        dim3 block3(NUM_THREADS_CLASSIFIERPARALLEL);
+
+        applyHaarClassifierClassifierParallelDynTemplate(
+            bTexCacheIImg,                //tbCacheTextureIImg
+            bTexCacheCascade,             //tbCacheTextureCascade
+            bDoAtomicCompaction,          //tbDoAtomicCompaction
+            grid3,
+            block3,
+            cuStream,
+            d_integralImage.ptr(), d_integralImage.stride(),
+            d_weights.ptr(), d_weights.stride(),
+            d_HaarFeatures.ptr(), d_HaarNodes.ptr(), d_HaarStages.ptr(),
+            d_ptrNowData->ptr(),
+            bDoAtomicCompaction ? d_ptrNowTmp->ptr() : d_ptrNowData->ptr(),
+            numDetections,
+            d_pixelMask.stride(),
+            anchorsRoi,
+            stageMiddleSwitch,
+            stageEndClassifierParallel,
+            scaleAreaPixels);
+        ncvAssertCUDAReturn(cudaGetLastError(), NCV_CUDA_ERROR);
+
+        if (bDoAtomicCompaction)
+        {
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaMemcpyFromSymbolAsync(hp_numDet, d_outMaskPosition, sizeof(Ncv32u),
+                                                          0, cudaMemcpyDeviceToHost, cuStream), NCV_CUDA_ERROR);
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+        }
+        else
+        {
+            NppStStatus nppSt;
+            nppSt = nppsStCompact_32u(d_ptrNowData->ptr(), numDetections,
+                                      d_ptrNowTmp->ptr(), hp_numDet, OBJDET_MASK_ELEMENT_INVALID_32U,
+                                      d_tmpBufCompact.ptr(), szNppCompactTmpBuf);
+            ncvAssertReturn(nppSt == NPP_SUCCESS, NCV_NPP_ERROR);
+        }
+
+        swap(d_ptrNowData, d_ptrNowTmp);
+        numDetections = *hp_numDet;
+    }
+
+    if (d_ptrNowData != &d_vecPixelMask)
+    {
+        d_vecPixelMaskTmp.copySolid(d_vecPixelMask, cuStream);
+        ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+    }
+
+#if defined _SELF_TEST_
+
+    ncvStat = d_pixelMask.copySolid(h_pixelMask_d, 0);
+    ncvAssertReturnNcvStat(ncvStat);
+    ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+
+    if (bDoAtomicCompaction)
+    {
+        std::sort(h_pixelMask_d.ptr, h_pixelMask_d.ptr + numDetections);
+    }
+
+    Ncv32u fpu_oldcw, fpu_cw;
+    _controlfp_s(&fpu_cw, 0, 0);
+    fpu_oldcw = fpu_cw;
+    _controlfp_s(&fpu_cw, _PC_24, _MCW_PC);
+    Ncv32u numDetGold;
+    ncvStat = ncvApplyHaarClassifierCascade_host(h_integralImage, h_weights, h_pixelMask, numDetGold, haar,
+                                                 h_HaarStages, h_HaarNodes, h_HaarFeatures,
+                                                 bMaskElements, anchorsRoi, pixelStep, scaleArea);
+    ncvAssertReturnNcvStat(ncvStat);
+    _controlfp_s(&fpu_cw, fpu_oldcw, _MCW_PC);
+
+    bool bPass = true;
+
+    if (numDetGold != numDetections)
+    {
+        printf("NCVHaarClassifierCascade::applyHaarClassifierCascade numdetections don't match: cpu=%d, gpu=%d\n", numDetGold, numDetections);
+        bPass = false;
+    }
+    else
+    {
+        for (Ncv32u i=0; i<std::max(numDetGold, numDetections) && bPass; i++)
+        {
+            if (h_pixelMask.ptr[i] != h_pixelMask_d.ptr[i])
+            {
+                printf("NCVHaarClassifierCascade::applyHaarClassifierCascade self test failed: i=%d, cpu=%d, gpu=%d\n", i, h_pixelMask.ptr[i], h_pixelMask_d.ptr[i]);
+                bPass = false;
+            }
+        }
+    }
+
+    printf("NCVHaarClassifierCascade::applyHaarClassifierCascade %s\n", bPass?"PASSED":"FAILED");
+#endif
+
+    NCV_SKIP_COND_END
+
+    return NCV_SUCCESS;
+}
+
+
+//==============================================================================
+//
+// HypothesesOperations file
+//
+//==============================================================================
+
+
+const Ncv32u NUM_GROW_THREADS = 128;
+
+
+__device__ __host__ NcvRect32u pixelToRect(Ncv32u pixel, Ncv32u width, Ncv32u height, Ncv32f scale)
+{
+    NcvRect32u res;
+    res.x = (Ncv32u)(scale * (pixel & 0xFFFF));
+    res.y = (Ncv32u)(scale * (pixel >> 16));
+    res.width = (Ncv32u)(scale * width);
+    res.height = (Ncv32u)(scale * height);
+    return res;
+}
+
+
+__global__ void growDetectionsKernel(Ncv32u *pixelMask, Ncv32u numElements,
+                                     NcvRect32u *hypotheses,
+                                     Ncv32u rectWidth, Ncv32u rectHeight, Ncv32f curScale)
+{
+    Ncv32u blockId = blockIdx.y * 65535 + blockIdx.x;
+    Ncv32u elemAddr = blockId * NUM_GROW_THREADS + threadIdx.x;
+    if (elemAddr >= numElements)
+    {
+        return;
+    }
+    hypotheses[elemAddr] = pixelToRect(pixelMask[elemAddr], rectWidth, rectHeight, curScale);
+}
+
+
+NCVStatus ncvGrowDetectionsVector_device(NCVVector<Ncv32u> &pixelMask,
+                                         Ncv32u numPixelMaskDetections,
+                                         NCVVector<NcvRect32u> &hypotheses,
+                                         Ncv32u &totalDetections,
+                                         Ncv32u totalMaxDetections,
+                                         Ncv32u rectWidth,
+                                         Ncv32u rectHeight,
+                                         Ncv32f curScale,
+                                         cudaStream_t cuStream)
+{
+    ncvAssertReturn(pixelMask.ptr() != NULL && hypotheses.ptr() != NULL, NCV_NULL_PTR);
+    ncvAssertReturn(pixelMask.memType() == hypotheses.memType() &&
+                    pixelMask.memType() == NCVMemoryTypeDevice, NCV_MEM_RESIDENCE_ERROR);
+    ncvAssertReturn(rectWidth > 0 && rectHeight > 0 && curScale > 0, NCV_INVALID_ROI);
+    ncvAssertReturn(curScale > 0, NCV_INVALID_SCALE);
+    ncvAssertReturn(totalMaxDetections <= hypotheses.length() &&
+                    numPixelMaskDetections <= pixelMask.length() &&
+                    totalMaxDetections <= totalMaxDetections, NCV_INCONSISTENT_INPUT);
+
+    NCVStatus ncvStat = NCV_SUCCESS;
+    Ncv32u numDetsToCopy = numPixelMaskDetections;
+
+    if (numDetsToCopy == 0)
+    {
+        return ncvStat;
+    }
+
+    if (totalDetections + numPixelMaskDetections > totalMaxDetections)
+    {
+        ncvStat = NCV_WARNING_HAAR_DETECTIONS_VECTOR_OVERFLOW;
+        numDetsToCopy = totalMaxDetections - totalDetections;
+    }
+
+    dim3 block(NUM_GROW_THREADS);
+    dim3 grid((numDetsToCopy + NUM_GROW_THREADS - 1) / NUM_GROW_THREADS);
+    if (grid.x > 65535)
+    {
+        grid.y = (grid.x + 65534) / 65535;
+        grid.x = 65535;
+    }
+    growDetectionsKernel<<<grid, block, 0, cuStream>>>(pixelMask.ptr(), numDetsToCopy,
+                                                       hypotheses.ptr() + totalDetections,
+                                                       rectWidth, rectHeight, curScale);
+    ncvAssertCUDAReturn(cudaGetLastError(), NCV_CUDA_ERROR);
+
+    totalDetections += numDetsToCopy;
+    return ncvStat;
+}
+
+
+//==============================================================================
+//
+// Visualize file
+//
+//==============================================================================
+
+
+const Ncv32u NUMTHREADS_DRAWRECTS = 32;
+const Ncv32u NUMTHREADS_DRAWRECTS_LOG2 = 5;
+
+
+template <class T>
+__global__ void drawRects(T *d_dst,
+                          Ncv32u dstStride,
+                          Ncv32u dstWidth,
+                          Ncv32u dstHeight,
+                          NcvRect32u *d_rects,
+                          Ncv32u numRects,
+                          T color)
+{
+    Ncv32u blockId = blockIdx.y * 65535 + blockIdx.x;
+    if (blockId > numRects * 4)
+    {
+        return;
+    }
+
+    NcvRect32u curRect = d_rects[blockId >> 2];
+    NcvBool bVertical = blockId & 0x1;
+    NcvBool bTopLeft = blockId & 0x2;
+
+    Ncv32u pt0x, pt0y;
+    if (bVertical)
+    {
+        Ncv32u numChunks = (curRect.height + NUMTHREADS_DRAWRECTS - 1) >> NUMTHREADS_DRAWRECTS_LOG2;
+
+        pt0x = bTopLeft ? curRect.x : curRect.x + curRect.width - 1;
+        pt0y = curRect.y;
+
+        if (pt0x < dstWidth)
+        {
+            for (Ncv32u chunkId = 0; chunkId < numChunks; chunkId++)
+            {
+                Ncv32u ptY = pt0y + chunkId * NUMTHREADS_DRAWRECTS + threadIdx.x;
+                if (ptY < pt0y + curRect.height && ptY < dstHeight)
+                {
+                    d_dst[ptY * dstStride + pt0x] = color;
+                }
+            }
+        }
+    }
+    else
+    {
+        Ncv32u numChunks = (curRect.width + NUMTHREADS_DRAWRECTS - 1) >> NUMTHREADS_DRAWRECTS_LOG2;
+
+        pt0x = curRect.x;
+        pt0y = bTopLeft ? curRect.y : curRect.y + curRect.height - 1;
+
+        if (pt0y < dstHeight)
+        {
+            for (Ncv32u chunkId = 0; chunkId < numChunks; chunkId++)
+            {
+                Ncv32u ptX = pt0x + chunkId * NUMTHREADS_DRAWRECTS + threadIdx.x;
+                if (ptX < pt0x + curRect.width && ptX < dstWidth)
+                {
+                    d_dst[pt0y * dstStride + ptX] = color;
+                }
+            }
+        }
+    }
+}
+
+
+template <class T>
+static NCVStatus drawRectsWrapperDevice(T *d_dst,
+                                        Ncv32u dstStride,
+                                        Ncv32u dstWidth,
+                                        Ncv32u dstHeight,
+                                        NcvRect32u *d_rects,
+                                        Ncv32u numRects,
+                                        T color,
+                                        cudaStream_t cuStream)
+{
+    ncvAssertReturn(d_dst != NULL && d_rects != NULL, NCV_NULL_PTR);
+    ncvAssertReturn(dstWidth > 0 && dstHeight > 0, NCV_DIMENSIONS_INVALID);
+    ncvAssertReturn(dstStride >= dstWidth, NCV_INVALID_STEP);
+    ncvAssertReturn(numRects <= dstWidth * dstHeight, NCV_DIMENSIONS_INVALID);
+
+    if (numRects == 0)
+    {
+        return NCV_SUCCESS;
+    }
+
+#if defined _SELF_TEST_
+    T *h_dst;
+    ncvAssertCUDAReturn(cudaMallocHost(&h_dst, dstStride * dstHeight * sizeof(T)), NCV_CUDA_ERROR);
+    ncvAssertCUDAReturn(cudaMemcpy(h_dst, d_dst, dstStride * dstHeight * sizeof(T), cudaMemcpyDeviceToHost), NCV_CUDA_ERROR);
+    NcvRect32s *h_rects;
+    ncvAssertCUDAReturn(cudaMallocHost(&h_rects, numRects * sizeof(NcvRect32s)), NCV_CUDA_ERROR);
+    ncvAssertCUDAReturn(cudaMemcpy(h_rects, d_rects, numRects * sizeof(NcvRect32s), cudaMemcpyDeviceToHost), NCV_CUDA_ERROR);
+    ncvAssertReturnNcvStat(drawRectsWrapperHost(h_dst, dstStride, dstWidth, dstHeight, h_rects, numRects, color));
+#endif
+
+    dim3 grid(numRects * 4);
+    dim3 block(NUMTHREADS_DRAWRECTS);
+    if (grid.x > 65535)
+    {
+        grid.y = (grid.x + 65534) / 65535;
+        grid.x = 65535;
+    }
+
+    drawRects<T><<<grid, block>>>(d_dst, dstStride, dstWidth, dstHeight, d_rects, numRects, color);
+
+    ncvAssertCUDAReturn(cudaGetLastError(), NCV_CUDA_ERROR);
+
+#if defined _SELF_TEST_
+    T *h_dst_after;
+    ncvAssertCUDAReturn(cudaMallocHost(&h_dst_after, dstStride * dstHeight * sizeof(T)), NCV_CUDA_ERROR);
+    ncvAssertCUDAReturn(cudaMemcpy(h_dst_after, d_dst, dstStride * dstHeight * sizeof(T), cudaMemcpyDeviceToHost), NCV_CUDA_ERROR);
+    bool bPass = true;
+    for (Ncv32u i=0; i<dstHeight && bPass; i++)
+    {
+        for (Ncv32u j=0; j<dstWidth && bPass; j++)
+        {
+            if (h_dst[i*dstStride+j] != h_dst_after[i*dstStride+j])
+            {
+                printf("::drawRectsWrapperDevice self test failed: i=%d, j=%d, cpu=%d, gpu=%d\n", i, j, h_dst[i*dstStride+j], h_dst_after[i*dstStride+j]);
+                bPass = false;
+            }
+        }
+    }
+    ncvAssertCUDAReturn(cudaFreeHost(h_dst_after), NCV_CUDA_ERROR);
+    ncvAssertCUDAReturn(cudaFreeHost(h_dst), NCV_CUDA_ERROR);
+    ncvAssertCUDAReturn(cudaFreeHost(h_rects), NCV_CUDA_ERROR);
+    printf("::drawRectsWrapperDevice %s\n", bPass?"PASSED":"FAILED");
+#endif
+
+    return NCV_SUCCESS;
+}
+
+
+NCVStatus ncvDrawRects_8u_device(Ncv8u *d_dst,
+                                 Ncv32u dstStride,
+                                 Ncv32u dstWidth,
+                                 Ncv32u dstHeight,
+                                 NcvRect32u *d_rects,
+                                 Ncv32u numRects,
+                                 Ncv8u color,
+                                 cudaStream_t cuStream)
+{
+    return drawRectsWrapperDevice(d_dst, dstStride, dstWidth, dstHeight, d_rects, numRects, color, cuStream);
+}
+
+
+NCVStatus ncvDrawRects_32u_device(Ncv32u *d_dst,
+                                  Ncv32u dstStride,
+                                  Ncv32u dstWidth,
+                                  Ncv32u dstHeight,
+                                  NcvRect32u *d_rects,
+                                  Ncv32u numRects,
+                                  Ncv32u color,
+                                  cudaStream_t cuStream)
+{
+    return drawRectsWrapperDevice(d_dst, dstStride, dstWidth, dstHeight, d_rects, numRects, color, cuStream);
+}
+
+
+//==============================================================================
+//
+// Pipeline file
+//
+//==============================================================================
+
+
+NCVStatus ncvDetectObjectsMultiScale_device(NCVMatrix<Ncv8u> &d_srcImg,
+                                            NcvSize32u srcRoi,
+                                            NCVVector<NcvRect32u> &d_dstRects,
+                                            Ncv32u &dstNumRects,
+
+                                            HaarClassifierCascadeDescriptor &haar,
+                                            NCVVector<HaarStage64> &h_HaarStages,
+                                            NCVVector<HaarStage64> &d_HaarStages,
+                                            NCVVector<HaarClassifierNode128> &d_HaarNodes,
+                                            NCVVector<HaarFeature64> &d_HaarFeatures,
+
+                                            NcvSize32u minObjSize,
+                                            Ncv32u minNeighbors,      //default 4
+                                            Ncv32f scaleStep,         //default 1.2f
+                                            Ncv32u pixelStep,         //default 1
+                                            Ncv32u flags,             //default NCVPipeObjDet_Default
+
+                                            INCVMemAllocator &gpuAllocator,
+                                            INCVMemAllocator &cpuAllocator,
+                                            Ncv32u devPropMajor,
+                                            Ncv32u devPropMinor,
+                                            cudaStream_t cuStream)
+{
+    ncvAssertReturn(d_srcImg.memType() == d_dstRects.memType() &&
+                    d_srcImg.memType() == gpuAllocator.memType() &&
+                     (d_srcImg.memType() == NCVMemoryTypeDevice ||
+                      d_srcImg.memType() == NCVMemoryTypeNone), NCV_MEM_RESIDENCE_ERROR);
+    ncvAssertReturn(d_HaarStages.memType() == d_HaarNodes.memType() &&
+                    d_HaarStages.memType() == d_HaarFeatures.memType() &&
+                     (d_HaarStages.memType() == NCVMemoryTypeDevice ||
+                      d_HaarStages.memType() == NCVMemoryTypeNone), NCV_MEM_RESIDENCE_ERROR);
+    ncvAssertReturn(h_HaarStages.memType() != NCVMemoryTypeDevice, NCV_MEM_RESIDENCE_ERROR);
+    ncvAssertReturn(gpuAllocator.isInitialized() && cpuAllocator.isInitialized(), NCV_ALLOCATOR_NOT_INITIALIZED);
+    ncvAssertReturn((d_srcImg.ptr() != NULL && d_dstRects.ptr() != NULL &&
+                     h_HaarStages.ptr() != NULL && d_HaarStages.ptr() != NULL && d_HaarNodes.ptr() != NULL &&
+                     d_HaarFeatures.ptr() != NULL) || gpuAllocator.isCounting(), NCV_NULL_PTR);
+    ncvAssertReturn(srcRoi.width > 0 && srcRoi.height > 0 &&
+                    d_srcImg.width() >= srcRoi.width && d_srcImg.height() >= srcRoi.height &&
+                    srcRoi.width >= minObjSize.width && srcRoi.height >= minObjSize.height &&
+                    d_dstRects.length() >= 1, NCV_DIMENSIONS_INVALID);
+    ncvAssertReturn(scaleStep > 1.0f, NCV_INVALID_SCALE);
+    ncvAssertReturn(d_HaarStages.length() >= haar.NumStages &&
+                    d_HaarNodes.length() >= haar.NumClassifierTotalNodes &&
+                    d_HaarFeatures.length() >= haar.NumFeatures &&
+                    d_HaarStages.length() == h_HaarStages.length() &&
+                    haar.NumClassifierRootNodes <= haar.NumClassifierTotalNodes, NCV_DIMENSIONS_INVALID);
+    ncvAssertReturn(haar.bNeedsTiltedII == false, NCV_NOIMPL_HAAR_TILTED_FEATURES);
+    ncvAssertReturn(pixelStep == 1 || pixelStep == 2, NCV_HAAR_INVALID_PIXEL_STEP);
+
+    //TODO: set NPP active stream to cuStream
+
+    NCVStatus ncvStat;
+    NCV_SET_SKIP_COND(gpuAllocator.isCounting());
+
+    Ncv32u integralWidth = d_srcImg.width() + 1;
+    Ncv32u integralHeight = d_srcImg.height() + 1;
+
+    NCVMatrixAlloc<Ncv32u> d_integralImage(gpuAllocator, integralWidth, integralHeight);
+    ncvAssertReturn(d_integralImage.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    NCVMatrixAlloc<Ncv64u> d_sqIntegralImage(gpuAllocator, integralWidth, integralHeight);
+    ncvAssertReturn(d_sqIntegralImage.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    NCVMatrixAlloc<Ncv32f> d_rectStdDev(gpuAllocator, d_srcImg.width(), d_srcImg.height());
+    ncvAssertReturn(d_rectStdDev.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    NCVMatrixAlloc<Ncv32u> d_pixelMask(gpuAllocator, d_srcImg.width(), d_srcImg.height());
+    ncvAssertReturn(d_pixelMask.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    NCVMatrixAlloc<Ncv32u> d_scaledIntegralImage(gpuAllocator, integralWidth, integralHeight);
+    ncvAssertReturn(d_scaledIntegralImage.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    NCVMatrixAlloc<Ncv64u> d_scaledSqIntegralImage(gpuAllocator, integralWidth, integralHeight);
+    ncvAssertReturn(d_scaledSqIntegralImage.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    NCVVectorAlloc<NcvRect32u> d_hypothesesIntermediate(gpuAllocator, d_srcImg.width() * d_srcImg.height());
+    ncvAssertReturn(d_hypothesesIntermediate.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+    NCVVectorAlloc<NcvRect32u> h_hypothesesIntermediate(cpuAllocator, d_srcImg.width() * d_srcImg.height());
+    ncvAssertReturn(h_hypothesesIntermediate.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    NppStStatus nppStat;
+    Ncv32u szTmpBufIntegral, szTmpBufSqIntegral;
+    nppStat = nppiStIntegralGetSize_8u32u(NppStSize32u(d_srcImg.width(), d_srcImg.height()), &szTmpBufIntegral);
+    ncvAssertReturn(nppStat == NPP_SUCCESS, NCV_NPP_ERROR);
+    nppStat = nppiStSqrIntegralGetSize_8u64u(NppStSize32u(d_srcImg.width(), d_srcImg.height()), &szTmpBufSqIntegral);
+    ncvAssertReturn(nppStat == NPP_SUCCESS, NCV_NPP_ERROR);
+    NCVVectorAlloc<Ncv8u> d_tmpIIbuf(gpuAllocator, std::max(szTmpBufIntegral, szTmpBufSqIntegral));
+    ncvAssertReturn(d_tmpIIbuf.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
+
+    NCV_SKIP_COND_BEGIN
+
+    nppStat = nppiStIntegral_8u32u_C1R(d_srcImg.ptr(), d_srcImg.pitch(),
+                                       d_integralImage.ptr(), d_integralImage.pitch(),
+                                       NppStSize32u(d_srcImg.width(), d_srcImg.height()),
+                                       d_tmpIIbuf.ptr(), szTmpBufIntegral);
+    ncvAssertReturn(nppStat == NPP_SUCCESS, NCV_NPP_ERROR);
+
+    nppStat = nppiStSqrIntegral_8u64u_C1R(d_srcImg.ptr(), d_srcImg.pitch(),
+                                          d_sqIntegralImage.ptr(), d_sqIntegralImage.pitch(),
+                                          NppStSize32u(d_srcImg.width(), d_srcImg.height()),
+                                          d_tmpIIbuf.ptr(), szTmpBufSqIntegral);
+    ncvAssertReturn(nppStat == NPP_SUCCESS, NCV_NPP_ERROR);
+
+    NCV_SKIP_COND_END
+
+    dstNumRects = 0;
+
+    Ncv32u lastCheckedScale = 0;
+    NcvBool bReverseTraverseScale = ((flags & NCVPipeObjDet_FindLargestObject) != 0);
+    std::vector<Ncv32u> scalesVector;
+
+    NcvBool bFoundLargestFace = false;
+
+    for (Ncv32f scaleIter = 1.0f; ; scaleIter *= scaleStep)
+    {
+        Ncv32u scale = (Ncv32u)scaleIter;
+        if (lastCheckedScale == scale)
+        {
+            continue;
+        }
+        lastCheckedScale = scale;
+
+        if (haar.ClassifierSize.width * (Ncv32s)scale < minObjSize.width ||
+            haar.ClassifierSize.height * (Ncv32s)scale < minObjSize.height)
+        {
+            continue;
+        }
+
+        NcvSize32s srcRoi, srcIIRoi, scaledIIRoi, searchRoi;
+
+        srcRoi.width = d_srcImg.width();
+        srcRoi.height = d_srcImg.height();
+
+        srcIIRoi.width = srcRoi.width + 1;
+        srcIIRoi.height = srcRoi.height + 1;
+
+        scaledIIRoi.width = srcIIRoi.width / scale;
+        scaledIIRoi.height = srcIIRoi.height / scale;
+
+        searchRoi.width = scaledIIRoi.width - haar.ClassifierSize.width;
+        searchRoi.height = scaledIIRoi.height - haar.ClassifierSize.height;
+
+        if (searchRoi.width <= 0 || searchRoi.height <= 0)
+        {
+            break;
+        }
+
+        scalesVector.push_back(scale);
+
+        if (gpuAllocator.isCounting())
+        {
+            break;
+        }
+    }
+
+    if (bReverseTraverseScale)
+    {
+        std::reverse(scalesVector.begin(), scalesVector.end());
+    }
+
+    //TODO: handle _fair_scale_ flag
+    for (Ncv32u i=0; i<scalesVector.size(); i++)
+    {
+        Ncv32u scale = scalesVector[i];
+
+        NcvSize32u srcRoi, scaledIIRoi, searchRoi;
+        NppStSize32u srcIIRoi;
+        srcRoi.width = d_srcImg.width();
+        srcRoi.height = d_srcImg.height();
+        srcIIRoi.width = srcRoi.width + 1;
+        srcIIRoi.height = srcRoi.height + 1;
+        scaledIIRoi.width = srcIIRoi.width / scale;
+        scaledIIRoi.height = srcIIRoi.height / scale;
+        searchRoi.width = scaledIIRoi.width - haar.ClassifierSize.width;
+        searchRoi.height = scaledIIRoi.height - haar.ClassifierSize.height;
+
+        NCV_SKIP_COND_BEGIN
+
+        nppStat = nppiStDownsampleNearest_32u_C1R(
+            d_integralImage.ptr(), d_integralImage.pitch(),
+            d_scaledIntegralImage.ptr(), d_scaledIntegralImage.pitch(),
+            srcIIRoi, scale, true);
+        ncvAssertReturn(nppStat == NPP_SUCCESS, NCV_NPP_ERROR);
+
+        nppStat = nppiStDownsampleNearest_64u_C1R(
+            d_sqIntegralImage.ptr(), d_sqIntegralImage.pitch(),
+            d_scaledSqIntegralImage.ptr(), d_scaledSqIntegralImage.pitch(),
+            srcIIRoi, scale, true);
+        ncvAssertReturn(nppStat == NPP_SUCCESS, NCV_NPP_ERROR);
+
+        const NppStRect32u rect(
+            HAAR_STDDEV_BORDER,
+            HAAR_STDDEV_BORDER,
+            haar.ClassifierSize.width - 2*HAAR_STDDEV_BORDER,
+            haar.ClassifierSize.height - 2*HAAR_STDDEV_BORDER);
+        nppStat = nppiStRectStdDev_32f_C1R(
+            d_scaledIntegralImage.ptr(), d_scaledIntegralImage.pitch(),
+            d_scaledSqIntegralImage.ptr(), d_scaledSqIntegralImage.pitch(),
+            d_rectStdDev.ptr(), d_rectStdDev.pitch(),
+            NppStSize32u(searchRoi.width, searchRoi.height), rect,
+            (Ncv32f)scale*scale, true);
+        ncvAssertReturn(nppStat == NPP_SUCCESS, NCV_NPP_ERROR);
+
+        NCV_SKIP_COND_END
+
+        Ncv32u detectionsOnThisScale;
+        ncvStat = ncvApplyHaarClassifierCascade_device(
+            d_scaledIntegralImage, d_rectStdDev, d_pixelMask,
+            detectionsOnThisScale,
+            haar, h_HaarStages, d_HaarStages, d_HaarNodes, d_HaarFeatures, false,
+            searchRoi, pixelStep, (Ncv32f)scale*scale,
+            gpuAllocator, cpuAllocator, devPropMajor, devPropMinor, cuStream);
+        ncvAssertReturn(ncvStat == NCV_SUCCESS, ncvStat);
+
+        NCV_SKIP_COND_BEGIN
+
+        NCVVectorReuse<Ncv32u> d_vecPixelMask(d_pixelMask.getSegment());
+        ncvStat = ncvGrowDetectionsVector_device(
+            d_vecPixelMask,
+            detectionsOnThisScale,
+            d_hypothesesIntermediate,
+            dstNumRects,
+            d_hypothesesIntermediate.length(),
+            haar.ClassifierSize.width,
+            haar.ClassifierSize.height,
+            (Ncv32f)scale,
+            cuStream);
+        ncvAssertReturn(ncvStat == NCV_SUCCESS, ncvStat);
+
+        if (flags & NCVPipeObjDet_FindLargestObject)
+        {
+            if (dstNumRects == 0)
+            {
+                continue;
+            }
+
+            if (dstNumRects != 0)
+            {
+                ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+                ncvStat = d_hypothesesIntermediate.copySolid(h_hypothesesIntermediate, cuStream,
+                                                             dstNumRects * sizeof(NcvRect32u));
+                ncvAssertReturnNcvStat(ncvStat);
+                ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+            }
+
+            Ncv32u numStrongHypothesesNow = dstNumRects;
+            ncvStat = ncvFilterHypotheses_host(
+                h_hypothesesIntermediate,
+                numStrongHypothesesNow,
+                minNeighbors,
+                RECT_SIMILARITY_PROPORTION,
+                NULL);
+            ncvAssertReturnNcvStat(ncvStat);
+
+            if (numStrongHypothesesNow > 0)
+            {
+                NcvRect32u maxRect = h_hypothesesIntermediate.ptr()[0];
+                for (Ncv32u j=1; j<numStrongHypothesesNow; j++)
+                {
+                    if (maxRect.width < h_hypothesesIntermediate.ptr()[j].width)
+                    {
+                        maxRect = h_hypothesesIntermediate.ptr()[j];
+                    }
+                }
+
+                h_hypothesesIntermediate.ptr()[0] = maxRect;
+                dstNumRects = 1;
+
+                ncvStat = h_hypothesesIntermediate.copySolid(d_dstRects, cuStream, sizeof(NcvRect32u));
+                ncvAssertReturnNcvStat(ncvStat);
+
+                bFoundLargestFace = true;
+
+                break;
+            }
+        }
+
+        NCV_SKIP_COND_END
+
+        if (gpuAllocator.isCounting())
+        {
+            break;
+        }
+    }
+
+    NCVStatus ncvRetCode = NCV_SUCCESS;
+
+    NCV_SKIP_COND_BEGIN
+
+    if (flags & NCVPipeObjDet_FindLargestObject)
+    {
+        if (!bFoundLargestFace)
+        {
+            dstNumRects = 0;
+        }
+    }
+    else
+    {
+        //TODO: move hypotheses filtration to GPU pipeline (the only CPU-resident element of the pipeline left)
+        if (dstNumRects != 0)
+        {
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+            ncvStat = d_hypothesesIntermediate.copySolid(h_hypothesesIntermediate, cuStream,
+                                                         dstNumRects * sizeof(NcvRect32u));
+            ncvAssertReturnNcvStat(ncvStat);
+            ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+        }
+
+        ncvStat = ncvFilterHypotheses_host(
+            h_hypothesesIntermediate,
+            dstNumRects,
+            minNeighbors,
+            RECT_SIMILARITY_PROPORTION,
+            NULL);
+        ncvAssertReturnNcvStat(ncvStat);
+
+        if (dstNumRects > d_dstRects.length())
+        {
+            ncvRetCode = NCV_WARNING_HAAR_DETECTIONS_VECTOR_OVERFLOW;
+            dstNumRects = d_dstRects.length();
+        }
+
+        if (dstNumRects != 0)
+        {
+            ncvStat = h_hypothesesIntermediate.copySolid(d_dstRects, cuStream,
+                                                         dstNumRects * sizeof(NcvRect32u));
+            ncvAssertReturnNcvStat(ncvStat);
+        }
+    }
+
+    if (flags & NCVPipeObjDet_VisualizeInPlace)
+    {
+        ncvAssertCUDAReturn(cudaStreamSynchronize(cuStream), NCV_CUDA_ERROR);
+        ncvDrawRects_8u_device(d_srcImg.ptr(), d_srcImg.stride(),
+                               d_srcImg.width(), d_srcImg.height(),
+                               d_dstRects.ptr(), dstNumRects, 255, cuStream);
+    }
+
+    NCV_SKIP_COND_END
+
+    return ncvRetCode;
+}
+
+
+//==============================================================================
+//
+// Purely Host code: classifier IO, mock-ups
+//
+//==============================================================================
+
+
+#ifdef _SELF_TEST_
+#include <float.h>
+#endif
+
+
+NCVStatus ncvApplyHaarClassifierCascade_host(NCVMatrix<Ncv32u> &h_integralImage,
+                                             NCVMatrix<Ncv32f> &h_weights,
+                                             NCVMatrixAlloc<Ncv32u> &h_pixelMask,
+                                             Ncv32u &numDetections,
+                                             HaarClassifierCascadeDescriptor &haar,
+                                             NCVVector<HaarStage64> &h_HaarStages,
+                                             NCVVector<HaarClassifierNode128> &h_HaarNodes,
+                                             NCVVector<HaarFeature64> &h_HaarFeatures,
+                                             NcvBool bMaskElements,
+                                             NcvSize32u anchorsRoi,
+                                             Ncv32u pixelStep,
+                                             Ncv32f scaleArea)
+{
+    ncvAssertReturn(h_integralImage.memType() == h_weights.memType() &&
+                    h_integralImage.memType() == h_pixelMask.memType() &&
+                     (h_integralImage.memType() == NCVMemoryTypeHostPageable ||
+                      h_integralImage.memType() == NCVMemoryTypeHostPinned), NCV_MEM_RESIDENCE_ERROR);
+    ncvAssertReturn(h_HaarStages.memType() == h_HaarNodes.memType() &&
+                    h_HaarStages.memType() == h_HaarFeatures.memType() &&
+                     (h_HaarStages.memType() == NCVMemoryTypeHostPageable ||
+                      h_HaarStages.memType() == NCVMemoryTypeHostPinned), NCV_MEM_RESIDENCE_ERROR);
+    ncvAssertReturn(h_integralImage.ptr() != NULL && h_weights.ptr() != NULL && h_pixelMask.ptr() != NULL &&
+                    h_HaarStages.ptr() != NULL && h_HaarNodes.ptr() != NULL && h_HaarFeatures.ptr() != NULL, NCV_NULL_PTR);
+    ncvAssertReturn(anchorsRoi.width > 0 && anchorsRoi.height > 0 &&
+                    h_pixelMask.width() >= anchorsRoi.width && h_pixelMask.height() >= anchorsRoi.height &&
+                    h_weights.width() >= anchorsRoi.width && h_weights.height() >= anchorsRoi.height &&
+                    h_integralImage.width() >= anchorsRoi.width + haar.ClassifierSize.width &&
+                    h_integralImage.height() >= anchorsRoi.height + haar.ClassifierSize.height, NCV_DIMENSIONS_INVALID);
+    ncvAssertReturn(scaleArea > 0, NCV_INVALID_SCALE);
+    ncvAssertReturn(h_HaarStages.length() >= haar.NumStages &&
+                    h_HaarNodes.length() >= haar.NumClassifierTotalNodes &&
+                    h_HaarFeatures.length() >= haar.NumFeatures &&
+                    h_HaarStages.length() == h_HaarStages.length() &&
+                    haar.NumClassifierRootNodes <= haar.NumClassifierTotalNodes, NCV_DIMENSIONS_INVALID);
+    ncvAssertReturn(haar.bNeedsTiltedII == false, NCV_NOIMPL_HAAR_TILTED_FEATURES);
+    ncvAssertReturn(pixelStep == 1 || pixelStep == 2, NCV_HAAR_INVALID_PIXEL_STEP);
+
+    Ncv32f scaleAreaPixels = scaleArea * ((haar.ClassifierSize.width - 2*HAAR_STDDEV_BORDER) *
+                                          (haar.ClassifierSize.height - 2*HAAR_STDDEV_BORDER));
+
+    for (Ncv32u i=0; i<anchorsRoi.height; i++)
+    {
+        for (Ncv32u j=0; j<h_pixelMask.stride(); j++)
+        {
+            if (i % pixelStep != 0 || j % pixelStep != 0 || j >= anchorsRoi.width)
+            {
+                h_pixelMask.ptr()[i * h_pixelMask.stride() + j] = OBJDET_MASK_ELEMENT_INVALID_32U;
+            }
+            else
+            {
+                for (Ncv32u iStage = 0; iStage < haar.NumStages; iStage++)
+                {
+                    Ncv32f curStageSum = 0.0f;
+                    Ncv32u numRootNodesInStage = h_HaarStages.ptr()[iStage].getNumClassifierRootNodes();
+                    Ncv32u curRootNodeOffset = h_HaarStages.ptr()[iStage].getStartClassifierRootNodeOffset();
+
+                    if (iStage == 0)
+                    {
+                        if (bMaskElements && h_pixelMask.ptr()[i * h_pixelMask.stride() + j] == OBJDET_MASK_ELEMENT_INVALID_32U)
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            h_pixelMask.ptr()[i * h_pixelMask.stride() + j] = ((i << 16) | j);
+                        }
+                    }
+                    else if (h_pixelMask.ptr()[i * h_pixelMask.stride() + j] == OBJDET_MASK_ELEMENT_INVALID_32U)
+                    {
+                        break;
+                    }
+
+                    while (numRootNodesInStage--)
+                    {
+                        NcvBool bMoreNodesToTraverse = true;
+                        Ncv32u curNodeOffset = curRootNodeOffset;
+
+                        while (bMoreNodesToTraverse)
+                        {
+                            HaarClassifierNode128 curNode = h_HaarNodes.ptr()[curNodeOffset];
+                            Ncv32u curNodeFeaturesNum = curNode.getFeatureDesc().getNumFeatures();
+                            Ncv32u curNodeFeaturesOffs = curNode.getFeatureDesc().getFeaturesOffset();
+
+                            Ncv32f curNodeVal = 0.f;
+                            for (Ncv32u iRect=0; iRect<curNodeFeaturesNum; iRect++)
+                            {
+                                HaarFeature64 feature = h_HaarFeatures.ptr()[curNodeFeaturesOffs + iRect];
+                                Ncv32u rectX, rectY, rectWidth, rectHeight;
+                                feature.getRect(&rectX, &rectY, &rectWidth, &rectHeight);
+                                Ncv32f rectWeight = feature.getWeight();
+                                Ncv32u iioffsTL = (i + rectY) * h_integralImage.stride() + (j + rectX);
+                                Ncv32u iioffsTR = iioffsTL + rectWidth;
+                                Ncv32u iioffsBL = iioffsTL + rectHeight * h_integralImage.stride();
+                                Ncv32u iioffsBR = iioffsBL + rectWidth;
+
+                                Ncv32u iivalTL = h_integralImage.ptr()[iioffsTL];
+                                Ncv32u iivalTR = h_integralImage.ptr()[iioffsTR];
+                                Ncv32u iivalBL = h_integralImage.ptr()[iioffsBL];
+                                Ncv32u iivalBR = h_integralImage.ptr()[iioffsBR];
+                                Ncv32u rectSum = iivalBR - iivalBL + iivalTL - iivalTR;
+                                curNodeVal += (Ncv32f)rectSum * rectWeight;
+                            }
+
+                            HaarClassifierNodeDescriptor32 nodeLeft = curNode.getLeftNodeDesc();
+                            HaarClassifierNodeDescriptor32 nodeRight = curNode.getRightNodeDesc();
+                            Ncv32f nodeThreshold = curNode.getThreshold();
+                            HaarClassifierNodeDescriptor32 nextNodeDescriptor;
+
+                            if (curNodeVal < scaleAreaPixels * h_weights.ptr()[i * h_weights.stride() + j] * nodeThreshold)
+                            {
+                                nextNodeDescriptor = nodeLeft;
+                            }
+                            else
+                            {
+                                nextNodeDescriptor = nodeRight;
+                            }
+
+                            NcvBool tmpIsLeaf = nextNodeDescriptor.isLeaf();
+                            if (tmpIsLeaf)
+                            {
+                                Ncv32f tmpLeafValue = nextNodeDescriptor.getLeafValueHost();
+                                curStageSum += tmpLeafValue;
+                                bMoreNodesToTraverse = false;
+                            }
+                            else
+                            {
+                                curNodeOffset = nextNodeDescriptor.getNextNodeOffset();
+                            }
+                        }
+
+                        curRootNodeOffset++;
+                    }
+
+                    Ncv32f tmpStageThreshold = h_HaarStages.ptr()[iStage].getStageThreshold();
+                    if (curStageSum < tmpStageThreshold)
+                    {
+                        //drop
+                        h_pixelMask.ptr()[i * h_pixelMask.stride() + j] = OBJDET_MASK_ELEMENT_INVALID_32U;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    std::sort(h_pixelMask.ptr(), h_pixelMask.ptr() + anchorsRoi.height * h_pixelMask.stride());
+    Ncv32u i = 0;
+    for (; i<anchorsRoi.height * h_pixelMask.stride(); i++)
+    {
+        if (h_pixelMask.ptr()[i] == OBJDET_MASK_ELEMENT_INVALID_32U)
+        {
+            break;
+        }
+    }
+    numDetections = i;
+
+    return NCV_SUCCESS;
+}
+
+
+NCVStatus ncvGrowDetectionsVector_host(NCVVector<Ncv32u> &pixelMask,
+                                       Ncv32u numPixelMaskDetections,
+                                       NCVVector<NcvRect32u> &hypotheses,
+                                       Ncv32u &totalDetections,
+                                       Ncv32u totalMaxDetections,
+                                       Ncv32u rectWidth,
+                                       Ncv32u rectHeight,
+                                       Ncv32f curScale)
+{
+    ncvAssertReturn(pixelMask.ptr() != NULL && hypotheses.ptr() != NULL, NCV_NULL_PTR);
+    ncvAssertReturn(pixelMask.memType() == hypotheses.memType() &&
+                    pixelMask.memType() != NCVMemoryTypeDevice, NCV_MEM_RESIDENCE_ERROR);
+    ncvAssertReturn(rectWidth > 0 && rectHeight > 0 && curScale > 0, NCV_INVALID_ROI);
+    ncvAssertReturn(curScale > 0, NCV_INVALID_SCALE);
+    ncvAssertReturn(totalMaxDetections <= hypotheses.length() &&
+                    numPixelMaskDetections <= pixelMask.length() &&
+                    totalMaxDetections <= totalMaxDetections, NCV_INCONSISTENT_INPUT);
+
+    NCVStatus ncvStat = NCV_SUCCESS;
+    Ncv32u numDetsToCopy = numPixelMaskDetections;
+
+    if (numDetsToCopy == 0)
+    {
+        return ncvStat;
+    }
+
+    if (totalDetections + numPixelMaskDetections > totalMaxDetections)
+    {
+        ncvStat = NCV_WARNING_HAAR_DETECTIONS_VECTOR_OVERFLOW;
+        numDetsToCopy = totalMaxDetections - totalDetections;
+    }
+
+    for (Ncv32u i=0; i<numDetsToCopy; i++)
+    {
+        hypotheses.ptr()[totalDetections + i] = pixelToRect(pixelMask.ptr()[i], rectWidth, rectHeight, curScale);
+    }
+
+    totalDetections += numDetsToCopy;
+    return ncvStat;
+}
+
+NCVStatus ncvFilterHypotheses_host(NCVVector<NcvRect32u> &hypotheses,
+                                   Ncv32u &numHypotheses,
+                                   Ncv32u minNeighbors,
+                                   Ncv32f intersectEps,
+                                   NCVVector<Ncv32u> *hypothesesWeights)
+{
+    ncvAssertReturn(hypotheses.memType() == NCVMemoryTypeHostPageable ||
+                    hypotheses.memType() == NCVMemoryTypeHostPinned, NCV_MEM_RESIDENCE_ERROR);
+    if (hypothesesWeights != NULL)
+    {
+        ncvAssertReturn(hypothesesWeights->memType() == NCVMemoryTypeHostPageable ||
+                        hypothesesWeights->memType() == NCVMemoryTypeHostPinned, NCV_MEM_RESIDENCE_ERROR);
+    }
+
+    if (numHypotheses == 0)
+    {
+        return NCV_SUCCESS;
+    }
+
+    std::vector<NcvRect32u> rects(numHypotheses);
+    memcpy(&rects[0], hypotheses.ptr(), numHypotheses * sizeof(NcvRect32u));
+
+    std::vector<Ncv32u> weights;
+    if (hypothesesWeights != NULL)
+    {
+        groupRectangles(rects, minNeighbors, intersectEps, &weights);
+    }
+    else
+    {
+        groupRectangles(rects, minNeighbors, intersectEps, NULL);
+    }
+
+    numHypotheses = (Ncv32u)rects.size();
+    if (numHypotheses > 0)
+    {
+        memcpy(hypotheses.ptr(), &rects[0], numHypotheses * sizeof(NcvRect32u));
+    }
+
+    if (hypothesesWeights != NULL)
+    {
+        memcpy(hypothesesWeights->ptr(), &weights[0], numHypotheses * sizeof(Ncv32u));
+    }
+
+    return NCV_SUCCESS;
+}
+
+
+template <class T>
+static NCVStatus drawRectsWrapperHost(T *h_dst,
+                                      Ncv32u dstStride,
+                                      Ncv32u dstWidth,
+                                      Ncv32u dstHeight,
+                                      NcvRect32u *h_rects,
+                                      Ncv32u numRects,
+                                      T color)
+{
+    ncvAssertReturn(h_dst != NULL && h_rects != NULL, NCV_NULL_PTR);
+    ncvAssertReturn(dstWidth > 0 && dstHeight > 0, NCV_DIMENSIONS_INVALID);
+    ncvAssertReturn(dstStride >= dstWidth, NCV_INVALID_STEP);
+    ncvAssertReturn(numRects != 0, NCV_SUCCESS);
+    ncvAssertReturn(numRects <= dstWidth * dstHeight, NCV_DIMENSIONS_INVALID);
+
+    for (Ncv32u i=0; i<numRects; i++)
+    {
+        NcvRect32u rect = h_rects[i];
+
+        if (rect.x < dstWidth)
+        {
+            for (Ncv32u i=rect.y; i<rect.y+rect.height && i<dstHeight; i++)
+            {
+                h_dst[i*dstStride+rect.x] = color;
+            }
+        }
+        if (rect.x+rect.width-1 < dstWidth)
+        {
+            for (Ncv32u i=rect.y; i<rect.y+rect.height && i<dstHeight; i++)
+            {
+                h_dst[i*dstStride+rect.x+rect.width-1] = color;
+            }
+        }
+        if (rect.y < dstHeight)
+        {
+            for (Ncv32u j=rect.x; j<rect.x+rect.width && j<dstWidth; j++)
+            {
+                h_dst[rect.y*dstStride+j] = color;
+            }
+        }
+        if (rect.y + rect.height - 1 < dstHeight)
+        {
+            for (Ncv32u j=rect.x; j<rect.x+rect.width && j<dstWidth; j++)
+            {
+                h_dst[(rect.y+rect.height-1)*dstStride+j] = color;
+            }
+        }
+    }
+
+    return NCV_SUCCESS;
+}
+
+
+NCVStatus ncvDrawRects_8u_host(Ncv8u *h_dst,
+                               Ncv32u dstStride,
+                               Ncv32u dstWidth,
+                               Ncv32u dstHeight,
+                               NcvRect32u *h_rects,
+                               Ncv32u numRects,
+                               Ncv8u color)
+{
+    return drawRectsWrapperHost(h_dst, dstStride, dstWidth, dstHeight, h_rects, numRects, color);
+}
+
+
+NCVStatus ncvDrawRects_32u_host(Ncv32u *h_dst,
+                                Ncv32u dstStride,
+                                Ncv32u dstWidth,
+                                Ncv32u dstHeight,
+                                NcvRect32u *h_rects,
+                                Ncv32u numRects,
+                                Ncv32u color)
+{
+    return drawRectsWrapperHost(h_dst, dstStride, dstWidth, dstHeight, h_rects, numRects, color);
+}
+
+
+NCVStatus loadFromXML(const std::string &filename,
+                      HaarClassifierCascadeDescriptor &haar,
+                      std::vector<HaarStage64> &haarStages,
+                      std::vector<HaarClassifierNode128> &haarClassifierNodes,
+                      std::vector<HaarFeature64> &haarFeatures);
+
+
+#define NVBIN_HAAR_SIZERESERVED     16
+#define NVBIN_HAAR_VERSION          0x1
+
+
+static NCVStatus loadFromNVBIN(const std::string &filename,
+                               HaarClassifierCascadeDescriptor &haar,
+                               std::vector<HaarStage64> &haarStages,
+                               std::vector<HaarClassifierNode128> &haarClassifierNodes,
+                               std::vector<HaarFeature64> &haarFeatures)
+{
+    FILE *fp;
+    fopen_s(&fp, filename.c_str(), "rb");
+    ncvAssertReturn(fp != NULL, NCV_FILE_ERROR);
+    Ncv32u fileVersion;
+    fread_s(&fileVersion, sizeof(Ncv32u), sizeof(Ncv32u), 1, fp);
+    ncvAssertReturn(fileVersion == NVBIN_HAAR_VERSION, NCV_FILE_ERROR);
+    Ncv32u fsize;
+    fread_s(&fsize, sizeof(Ncv32u), sizeof(Ncv32u), 1, fp);
+    fseek(fp, 0, SEEK_END);
+    Ncv32u fsizeActual = ftell(fp);
+    ncvAssertReturn(fsize == fsizeActual, NCV_FILE_ERROR);
+
+    std::vector<unsigned char> fdata;
+    fdata.resize(fsize);
+    Ncv32u dataOffset = 0;
+    fseek(fp, 0, SEEK_SET);
+    fread_s(&fdata[0], fsize, fsize, 1, fp);
+    fclose(fp);
+
+    //data
+    dataOffset = NVBIN_HAAR_SIZERESERVED;
+    haar.NumStages = *(Ncv32u *)(&fdata[0]+dataOffset);
+    dataOffset += sizeof(Ncv32u);
+    haar.NumClassifierRootNodes = *(Ncv32u *)(&fdata[0]+dataOffset);
+    dataOffset += sizeof(Ncv32u);
+    haar.NumClassifierTotalNodes = *(Ncv32u *)(&fdata[0]+dataOffset);
+    dataOffset += sizeof(Ncv32u);
+    haar.NumFeatures = *(Ncv32u *)(&fdata[0]+dataOffset);
+    dataOffset += sizeof(Ncv32u);
+    haar.ClassifierSize = *(NcvSize32u *)(&fdata[0]+dataOffset);
+    dataOffset += sizeof(NcvSize32u);
+    haar.bNeedsTiltedII = *(NcvBool *)(&fdata[0]+dataOffset);
+    dataOffset += sizeof(NcvBool);
+    haar.bHasStumpsOnly = *(NcvBool *)(&fdata[0]+dataOffset);
+    dataOffset += sizeof(NcvBool);
+
+    haarStages.resize(haar.NumStages);
+    haarClassifierNodes.resize(haar.NumClassifierTotalNodes);
+    haarFeatures.resize(haar.NumFeatures);
+
+    Ncv32u szStages = haar.NumStages * sizeof(HaarStage64);
+    Ncv32u szClassifiers = haar.NumClassifierTotalNodes * sizeof(HaarClassifierNode128);
+    Ncv32u szFeatures = haar.NumFeatures * sizeof(HaarFeature64);
+
+    memcpy(&haarStages[0], &fdata[0]+dataOffset, szStages);
+    dataOffset += szStages;
+    memcpy(&haarClassifierNodes[0], &fdata[0]+dataOffset, szClassifiers);
+    dataOffset += szClassifiers;
+    memcpy(&haarFeatures[0], &fdata[0]+dataOffset, szFeatures);
+    dataOffset += szFeatures;
+
+    return NCV_SUCCESS;
+}
+
+
+NCVStatus ncvHaarGetClassifierSize(const std::string &filename, Ncv32u &numStages,
+                                   Ncv32u &numNodes, Ncv32u &numFeatures)
+{
+    NCVStatus ncvStat;
+
+    std::string fext = filename.substr(filename.find_last_of(".") + 1);
+    std::transform(fext.begin(), fext.end(), fext.begin(), ::tolower);
+
+    if (fext == "nvbin")
+    {
+        FILE *fp;
+        fopen_s(&fp, filename.c_str(), "rb");
+        ncvAssertReturn(fp != NULL, NCV_FILE_ERROR);
+        Ncv32u fileVersion;
+        fread_s(&fileVersion, sizeof(Ncv32u), sizeof(Ncv32u), 1, fp);
+        ncvAssertReturn(fileVersion == NVBIN_HAAR_VERSION, NCV_FILE_ERROR);
+        fseek(fp, NVBIN_HAAR_SIZERESERVED, SEEK_SET);
+        Ncv32u tmp;
+        fread_s(&numStages, sizeof(Ncv32u), sizeof(Ncv32u), 1, fp);
+        fread_s(&tmp, sizeof(Ncv32u), sizeof(Ncv32u), 1, fp);
+        fread_s(&numNodes, sizeof(Ncv32u), sizeof(Ncv32u), 1, fp);
+        fread_s(&numFeatures, sizeof(Ncv32u), sizeof(Ncv32u), 1, fp);
+        fclose(fp);
+    }
+    else if (fext == "xml")
+    {
+        HaarClassifierCascadeDescriptor haar;
+        std::vector<HaarStage64> haarStages;
+        std::vector<HaarClassifierNode128> haarNodes;
+        std::vector<HaarFeature64> haarFeatures;
+
+        ncvStat = loadFromXML(filename, haar, haarStages, haarNodes, haarFeatures);
+        ncvAssertReturnNcvStat(ncvStat);
+
+        numStages = haar.NumStages;
+        numNodes = haar.NumClassifierTotalNodes;
+        numFeatures = haar.NumFeatures;
+    }
+    else
+    {
+        return NCV_HAAR_XML_LOADING_EXCEPTION;
+    }
+
+    return NCV_SUCCESS;
+}
+
+
+NCVStatus ncvHaarLoadFromFile_host(const std::string &filename,
+                                   HaarClassifierCascadeDescriptor &haar,
+                                   NCVVector<HaarStage64> &h_HaarStages,
+                                   NCVVector<HaarClassifierNode128> &h_HaarNodes,
+                                   NCVVector<HaarFeature64> &h_HaarFeatures)
+{
+    ncvAssertReturn(h_HaarStages.memType() == NCVMemoryTypeHostPinned &&
+                    h_HaarNodes.memType() == NCVMemoryTypeHostPinned &&
+                    h_HaarFeatures.memType() == NCVMemoryTypeHostPinned, NCV_MEM_RESIDENCE_ERROR);
+
+    NCVStatus ncvStat;
+
+    std::string fext = filename.substr(filename.find_last_of(".") + 1);
+    std::transform(fext.begin(), fext.end(), fext.begin(), ::tolower);
+
+    std::vector<HaarStage64> haarStages;
+    std::vector<HaarClassifierNode128> haarNodes;
+    std::vector<HaarFeature64> haarFeatures;
+
+    if (fext == "nvbin")
+    {
+        ncvStat = loadFromNVBIN(filename, haar, haarStages, haarNodes, haarFeatures);
+        ncvAssertReturnNcvStat(ncvStat);
+    }
+    else if (fext == "xml")
+    {
+        ncvStat = loadFromXML(filename, haar, haarStages, haarNodes, haarFeatures);
+        ncvAssertReturnNcvStat(ncvStat);
+    }
+    else
+    {
+        return NCV_HAAR_XML_LOADING_EXCEPTION;
+    }
+
+    ncvAssertReturn(h_HaarStages.length() >= haarStages.size(), NCV_MEM_INSUFFICIENT_CAPACITY);
+    ncvAssertReturn(h_HaarNodes.length() >= haarNodes.size(), NCV_MEM_INSUFFICIENT_CAPACITY);
+    ncvAssertReturn(h_HaarFeatures.length() >= haarFeatures.size(), NCV_MEM_INSUFFICIENT_CAPACITY);
+
+    memcpy(h_HaarStages.ptr(), &haarStages[0], haarStages.size()*sizeof(HaarStage64));
+    memcpy(h_HaarNodes.ptr(), &haarNodes[0], haarNodes.size()*sizeof(HaarClassifierNode128));
+    memcpy(h_HaarFeatures.ptr(), &haarFeatures[0], haarFeatures.size()*sizeof(HaarFeature64));
+
+    return NCV_SUCCESS;
+}
+
+
+NCVStatus ncvHaarStoreNVBIN_host(std::string &filename,
+                                 HaarClassifierCascadeDescriptor haar,
+                                 NCVVector<HaarStage64> &h_HaarStages,
+                                 NCVVector<HaarClassifierNode128> &h_HaarNodes,
+                                 NCVVector<HaarFeature64> &h_HaarFeatures)
+{
+    ncvAssertReturn(h_HaarStages.length() >= haar.NumStages, NCV_INCONSISTENT_INPUT);
+    ncvAssertReturn(h_HaarNodes.length() >= haar.NumClassifierTotalNodes, NCV_INCONSISTENT_INPUT);
+    ncvAssertReturn(h_HaarFeatures.length() >= haar.NumFeatures, NCV_INCONSISTENT_INPUT);
+    ncvAssertReturn(h_HaarStages.memType() == NCVMemoryTypeHostPinned &&
+                    h_HaarNodes.memType() == NCVMemoryTypeHostPinned &&
+                    h_HaarFeatures.memType() == NCVMemoryTypeHostPinned, NCV_MEM_RESIDENCE_ERROR);
+
+    Ncv32u szStages = haar.NumStages * sizeof(HaarStage64);
+    Ncv32u szClassifiers = haar.NumClassifierTotalNodes * sizeof(HaarClassifierNode128);
+    Ncv32u szFeatures = haar.NumFeatures * sizeof(HaarFeature64);
+
+    Ncv32u dataOffset = 0;
+    std::vector<unsigned char> fdata;
+    fdata.resize(szStages+szClassifiers+szFeatures+1024, 0);
+
+    //header
+    *(Ncv32u *)(&fdata[0]+dataOffset) = NVBIN_HAAR_VERSION;
+
+    //data
+    dataOffset = NVBIN_HAAR_SIZERESERVED;
+    *(Ncv32u *)(&fdata[0]+dataOffset) = haar.NumStages;
+    dataOffset += sizeof(Ncv32u);
+    *(Ncv32u *)(&fdata[0]+dataOffset) = haar.NumClassifierRootNodes;
+    dataOffset += sizeof(Ncv32u);
+    *(Ncv32u *)(&fdata[0]+dataOffset) = haar.NumClassifierTotalNodes;
+    dataOffset += sizeof(Ncv32u);
+    *(Ncv32u *)(&fdata[0]+dataOffset) = haar.NumFeatures;
+    dataOffset += sizeof(Ncv32u);
+    *(NcvSize32u *)(&fdata[0]+dataOffset) = haar.ClassifierSize;
+    dataOffset += sizeof(NcvSize32u);
+    *(NcvBool *)(&fdata[0]+dataOffset) = haar.bNeedsTiltedII;
+    dataOffset += sizeof(NcvBool);
+    *(NcvBool *)(&fdata[0]+dataOffset) = haar.bHasStumpsOnly;
+    dataOffset += sizeof(NcvBool);
+
+    memcpy(&fdata[0]+dataOffset, h_HaarStages.ptr(), szStages);
+    dataOffset += szStages;
+    memcpy(&fdata[0]+dataOffset, h_HaarNodes.ptr(), szClassifiers);
+    dataOffset += szClassifiers;
+    memcpy(&fdata[0]+dataOffset, h_HaarFeatures.ptr(), szFeatures);
+    dataOffset += szFeatures;
+    Ncv32u fsize = dataOffset;
+
+    //TODO: CRC32 here
+
+    //update header
+    dataOffset = sizeof(Ncv32u);
+    *(Ncv32u *)(&fdata[0]+dataOffset) = fsize;
+
+    FILE *fp;
+    fopen_s(&fp, filename.c_str(), "wb");
+    ncvAssertReturn(fp != NULL, NCV_FILE_ERROR);
+    fwrite(&fdata[0], fsize, 1, fp);
+    fclose(fp);
+    return NCV_SUCCESS;
+}
diff --git a/modules/gpu/src/nvidia/NCVHaarObjectDetection.hpp b/modules/gpu/src/nvidia/NCVHaarObjectDetection.hpp
new file mode 100644
index 0000000000..d9f500d7a0
--- /dev/null
+++ b/modules/gpu/src/nvidia/NCVHaarObjectDetection.hpp
@@ -0,0 +1,501 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 
+// 
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2009-2010, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// NVIDIA CUDA implementation of Viola-Jones Object Detection Framework
+//
+// The algorithm and code are explained in the upcoming GPU Computing Gems
+// chapter in detail:
+//
+//   Anton Obukhov, "Haar Classifiers for Object Detection with CUDA"
+//   PDF URL placeholder
+//   email: aobukhov@nvidia.com, devsupport@nvidia.com
+//
+// Credits for help with the code to:
+// Alexey Mendelenko, Cyril Crassin, and Mikhail Smirnov.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _ncvhaarobjectdetection_hpp_
+#define _ncvhaarobjectdetection_hpp_
+
+#include <string>
+#include "NCV.hpp"
+
+
+//==============================================================================
+//
+// Guaranteed size cross-platform classifier structures
+//
+//==============================================================================
+
+
+struct HaarFeature64
+{
+    uint2 _ui2;
+
+#define HaarFeature64_CreateCheck_MaxRectField                  0xFF
+
+    __host__ NCVStatus setRect(Ncv32u rectX, Ncv32u rectY, Ncv32u rectWidth, Ncv32u rectHeight, Ncv32u clsWidth, Ncv32u clsHeight)
+    {
+        ncvAssertReturn(rectWidth <= HaarFeature64_CreateCheck_MaxRectField && rectHeight <= HaarFeature64_CreateCheck_MaxRectField, NCV_HAAR_TOO_LARGE_FEATURES);
+        ((NcvRect8u*)&(this->_ui2.x))->x = rectX;
+        ((NcvRect8u*)&(this->_ui2.x))->y = rectY;
+        ((NcvRect8u*)&(this->_ui2.x))->width = rectWidth;
+        ((NcvRect8u*)&(this->_ui2.x))->height = rectHeight;
+        return NCV_SUCCESS;
+    }
+
+    __host__ NCVStatus setWeight(Ncv32f weight)
+    {
+        ((Ncv32f*)&(this->_ui2.y))[0] = weight;
+        return NCV_SUCCESS;
+    }
+
+    __device__ __host__ void getRect(Ncv32u *rectX, Ncv32u *rectY, Ncv32u *rectWidth, Ncv32u *rectHeight)
+    {
+        NcvRect8u tmpRect = *(NcvRect8u*)(&this->_ui2.x);
+        *rectX = tmpRect.x;
+        *rectY = tmpRect.y;
+        *rectWidth = tmpRect.width;
+        *rectHeight = tmpRect.height;
+    }
+
+    __device__ __host__ Ncv32f getWeight(void)
+    {
+        return *(Ncv32f*)(&this->_ui2.y);
+    }
+};
+
+
+struct HaarFeatureDescriptor32
+{
+private:
+
+#define HaarFeatureDescriptor32_Interpret_MaskFlagTilted        0x80000000
+#define HaarFeatureDescriptor32_CreateCheck_MaxNumFeatures      0x7F
+#define HaarFeatureDescriptor32_NumFeatures_Shift               24
+#define HaarFeatureDescriptor32_CreateCheck_MaxFeatureOffset    0x00FFFFFF
+
+    Ncv32u desc;
+
+public:
+
+    __host__ NCVStatus create(NcvBool bTilted, Ncv32u numFeatures, Ncv32u offsetFeatures)
+    {
+        if (numFeatures > HaarFeatureDescriptor32_CreateCheck_MaxNumFeatures)
+        {
+            return NCV_HAAR_TOO_MANY_FEATURES_IN_CLASSIFIER;
+        }
+        if (offsetFeatures > HaarFeatureDescriptor32_CreateCheck_MaxFeatureOffset)
+        {
+            return NCV_HAAR_TOO_MANY_FEATURES_IN_CASCADE;
+        }
+        this->desc = 0;
+        this->desc |= (bTilted ? HaarFeatureDescriptor32_Interpret_MaskFlagTilted : 0);
+        this->desc |= (numFeatures << HaarFeatureDescriptor32_NumFeatures_Shift);
+        this->desc |= offsetFeatures;
+        return NCV_SUCCESS;
+    }
+
+    __device__ __host__ NcvBool isTilted(void)
+    {
+        return (this->desc & HaarFeatureDescriptor32_Interpret_MaskFlagTilted) != 0;
+    }
+
+    __device__ __host__ Ncv32u getNumFeatures(void)
+    {
+        return (this->desc & ~HaarFeatureDescriptor32_Interpret_MaskFlagTilted) >> HaarFeatureDescriptor32_NumFeatures_Shift;
+    }
+
+    __device__ __host__ Ncv32u getFeaturesOffset(void)
+    {
+        return this->desc & HaarFeatureDescriptor32_CreateCheck_MaxFeatureOffset;
+    }
+};
+
+
+struct HaarClassifierNodeDescriptor32
+{
+    uint1 _ui1;
+
+#define HaarClassifierNodeDescriptor32_Interpret_MaskSwitch     (1 << 30)
+
+    __host__ NCVStatus create(Ncv32f leafValue)
+    {
+        if ((*(Ncv32u *)&leafValue) & HaarClassifierNodeDescriptor32_Interpret_MaskSwitch)
+        {
+            return NCV_HAAR_XML_LOADING_EXCEPTION;
+        }
+        *(Ncv32f *)&this->_ui1 = leafValue;
+        return NCV_SUCCESS;
+    }
+
+    __host__ NCVStatus create(Ncv32u offsetHaarClassifierNode)
+    {
+        if (offsetHaarClassifierNode >= HaarClassifierNodeDescriptor32_Interpret_MaskSwitch)
+        {
+            return NCV_HAAR_XML_LOADING_EXCEPTION;
+        }
+        this->_ui1.x = offsetHaarClassifierNode;
+        this->_ui1.x |= HaarClassifierNodeDescriptor32_Interpret_MaskSwitch;
+        return NCV_SUCCESS;
+    }
+
+    __device__ __host__ NcvBool isLeaf(void)
+    {
+        return !(this->_ui1.x & HaarClassifierNodeDescriptor32_Interpret_MaskSwitch);
+    }
+
+    __host__ Ncv32f getLeafValueHost(void)
+    {
+        return *(Ncv32f *)&this->_ui1.x;
+    }
+
+#ifdef __CUDACC__
+    __device__ Ncv32f getLeafValue(void)
+    {
+        return __int_as_float(this->_ui1.x);
+    }
+#endif
+
+    __device__ __host__ Ncv32u getNextNodeOffset(void)
+    {
+        return (this->_ui1.x & ~HaarClassifierNodeDescriptor32_Interpret_MaskSwitch);
+    }
+};
+
+
+struct HaarClassifierNode128
+{
+    uint4 _ui4;
+
+    __host__ NCVStatus setFeatureDesc(HaarFeatureDescriptor32 f)
+    {
+        this->_ui4.x = *(Ncv32u *)&f;
+        return NCV_SUCCESS;
+    }
+
+    __host__ NCVStatus setThreshold(Ncv32f t)
+    {
+        this->_ui4.y = *(Ncv32u *)&t;
+        return NCV_SUCCESS;
+    }
+
+    __host__ NCVStatus setLeftNodeDesc(HaarClassifierNodeDescriptor32 nl)
+    {
+        this->_ui4.z = *(Ncv32u *)&nl;
+        return NCV_SUCCESS;
+    }
+
+    __host__ NCVStatus setRightNodeDesc(HaarClassifierNodeDescriptor32 nr)
+    {
+        this->_ui4.w = *(Ncv32u *)&nr;
+        return NCV_SUCCESS;
+    }
+
+    __host__ __device__ HaarFeatureDescriptor32 getFeatureDesc(void)
+    {
+        return *(HaarFeatureDescriptor32 *)&this->_ui4.x;
+    }
+
+    __host__ __device__ Ncv32f getThreshold(void)
+    {
+        return *(Ncv32f*)&this->_ui4.y;
+    }
+
+    __host__ __device__ HaarClassifierNodeDescriptor32 getLeftNodeDesc(void)
+    {
+        return *(HaarClassifierNodeDescriptor32 *)&this->_ui4.z;
+    }
+
+    __host__ __device__ HaarClassifierNodeDescriptor32 getRightNodeDesc(void)
+    {
+        return *(HaarClassifierNodeDescriptor32 *)&this->_ui4.w;
+    }
+};
+
+
+struct HaarStage64
+{
+#define HaarStage64_Interpret_MaskRootNodes         0x0000FFFF
+#define HaarStage64_Interpret_MaskRootNodeOffset    0xFFFF0000
+#define HaarStage64_Interpret_ShiftRootNodeOffset   16
+
+    uint2 _ui2;
+
+    __host__ NCVStatus setStageThreshold(Ncv32f t)
+    {
+        this->_ui2.x = *(Ncv32u *)&t;
+        return NCV_SUCCESS;
+    }
+
+    __host__ NCVStatus setStartClassifierRootNodeOffset(Ncv32u val)
+    {
+        if (val > (HaarStage64_Interpret_MaskRootNodeOffset >> HaarStage64_Interpret_ShiftRootNodeOffset))
+        {
+            return NCV_HAAR_XML_LOADING_EXCEPTION;
+        }
+        this->_ui2.y = (val << HaarStage64_Interpret_ShiftRootNodeOffset) | (this->_ui2.y & HaarStage64_Interpret_MaskRootNodes);
+        return NCV_SUCCESS;
+    }
+
+    __host__ NCVStatus setNumClassifierRootNodes(Ncv32u val)
+    {
+        if (val > HaarStage64_Interpret_MaskRootNodes)
+        {
+            return NCV_HAAR_XML_LOADING_EXCEPTION;
+        }
+        this->_ui2.y = val | (this->_ui2.y & HaarStage64_Interpret_MaskRootNodeOffset);
+        return NCV_SUCCESS;
+    }
+
+    __host__ __device__ Ncv32f getStageThreshold(void)
+    {
+        return *(Ncv32f*)&this->_ui2.x;
+    }
+
+    __host__ __device__ Ncv32u getStartClassifierRootNodeOffset(void)
+    {
+        return (this->_ui2.y >> HaarStage64_Interpret_ShiftRootNodeOffset);
+    }
+
+    __host__ __device__ Ncv32u getNumClassifierRootNodes(void)
+    {
+        return (this->_ui2.y & HaarStage64_Interpret_MaskRootNodes);
+    }
+};
+
+
+NPPST_CT_ASSERT(sizeof(HaarFeature64) == 8);
+NPPST_CT_ASSERT(sizeof(HaarFeatureDescriptor32) == 4);
+NPPST_CT_ASSERT(sizeof(HaarClassifierNodeDescriptor32) == 4);
+NPPST_CT_ASSERT(sizeof(HaarClassifierNode128) == 16);
+NPPST_CT_ASSERT(sizeof(HaarStage64) == 8);
+
+
+//==============================================================================
+//
+// Classifier cascade descriptor
+//
+//==============================================================================
+
+
+struct HaarClassifierCascadeDescriptor
+{
+    Ncv32u NumStages;
+    Ncv32u NumClassifierRootNodes;
+    Ncv32u NumClassifierTotalNodes;
+    Ncv32u NumFeatures;
+    NcvSize32u ClassifierSize;
+    NcvBool bNeedsTiltedII;
+    NcvBool bHasStumpsOnly;
+};
+
+
+//==============================================================================
+//
+// Functional interface
+//
+//==============================================================================
+
+
+enum
+{
+    NCVPipeObjDet_Default               = 0x000,
+    NCVPipeObjDet_UseFairImageScaling   = 0x001,
+    NCVPipeObjDet_FindLargestObject     = 0x002,
+    NCVPipeObjDet_VisualizeInPlace      = 0x004,
+};
+
+
+NCVStatus ncvDetectObjectsMultiScale_device(NCVMatrix<Ncv8u> &d_srcImg,
+                                            NcvSize32u srcRoi,
+                                            NCVVector<NcvRect32u> &d_dstRects,
+                                            Ncv32u &dstNumRects,
+
+                                            HaarClassifierCascadeDescriptor &haar,
+                                            NCVVector<HaarStage64> &h_HaarStages,
+                                            NCVVector<HaarStage64> &d_HaarStages,
+                                            NCVVector<HaarClassifierNode128> &d_HaarNodes,
+                                            NCVVector<HaarFeature64> &d_HaarFeatures,
+
+                                            NcvSize32u minObjSize,
+                                            Ncv32u minNeighbors,      //default 4
+                                            Ncv32f scaleStep,         //default 1.2f
+                                            Ncv32u pixelStep,         //default 1
+                                            Ncv32u flags,             //default NCVPipeObjDet_Default
+
+                                            INCVMemAllocator &gpuAllocator,
+                                            INCVMemAllocator &cpuAllocator,
+                                            Ncv32u devPropMajor,
+                                            Ncv32u devPropMinor,
+                                            cudaStream_t cuStream);
+
+
+#define OBJDET_MASK_ELEMENT_INVALID_32U     0xFFFFFFFF
+#define HAAR_STDDEV_BORDER                  1
+
+
+NCVStatus ncvApplyHaarClassifierCascade_device(NCVMatrix<Ncv32u> &d_integralImage,
+                                               NCVMatrix<Ncv32f> &d_weights,
+                                               NCVMatrixAlloc<Ncv32u> &d_pixelMask,
+                                               Ncv32u &numDetections,
+                                               HaarClassifierCascadeDescriptor &haar,
+                                               NCVVector<HaarStage64> &h_HaarStages,
+                                               NCVVector<HaarStage64> &d_HaarStages,
+                                               NCVVector<HaarClassifierNode128> &d_HaarNodes,
+                                               NCVVector<HaarFeature64> &d_HaarFeatures,
+                                               NcvBool bMaskElements,
+                                               NcvSize32u anchorsRoi,
+                                               Ncv32u pixelStep,
+                                               Ncv32f scaleArea,
+                                               INCVMemAllocator &gpuAllocator,
+                                               INCVMemAllocator &cpuAllocator,
+                                               Ncv32u devPropMajor,
+                                               Ncv32u devPropMinor,
+                                               cudaStream_t cuStream);
+
+
+NCVStatus ncvApplyHaarClassifierCascade_host(NCVMatrix<Ncv32u> &h_integralImage,
+                                             NCVMatrix<Ncv32f> &h_weights,
+                                             NCVMatrixAlloc<Ncv32u> &h_pixelMask,
+                                             Ncv32u &numDetections,
+                                             HaarClassifierCascadeDescriptor &haar,
+                                             NCVVector<HaarStage64> &h_HaarStages,
+                                             NCVVector<HaarClassifierNode128> &h_HaarNodes,
+                                             NCVVector<HaarFeature64> &h_HaarFeatures,
+                                             NcvBool bMaskElements,
+                                             NcvSize32u anchorsRoi,
+                                             Ncv32u pixelStep,
+                                             Ncv32f scaleArea);
+
+
+NCVStatus ncvDrawRects_8u_device(Ncv8u *d_dst,
+                                 Ncv32u dstStride,
+                                 Ncv32u dstWidth,
+                                 Ncv32u dstHeight,
+                                 NcvRect32u *d_rects,
+                                 Ncv32u numRects,
+                                 Ncv8u color,
+                                 cudaStream_t cuStream);
+
+
+NCVStatus ncvDrawRects_32u_device(Ncv32u *d_dst,
+                                  Ncv32u dstStride,
+                                  Ncv32u dstWidth,
+                                  Ncv32u dstHeight,
+                                  NcvRect32u *d_rects,
+                                  Ncv32u numRects,
+                                  Ncv32u color,
+                                  cudaStream_t cuStream);
+
+
+NCVStatus ncvDrawRects_8u_host(Ncv8u *h_dst,
+                               Ncv32u dstStride,
+                               Ncv32u dstWidth,
+                               Ncv32u dstHeight,
+                               NcvRect32u *h_rects,
+                               Ncv32u numRects,
+                               Ncv8u color);
+
+
+NCVStatus ncvDrawRects_32u_host(Ncv32u *h_dst,
+                                Ncv32u dstStride,
+                                Ncv32u dstWidth,
+                                Ncv32u dstHeight,
+                                NcvRect32u *h_rects,
+                                Ncv32u numRects,
+                                Ncv32u color);
+
+
+#define RECT_SIMILARITY_PROPORTION      0.2f
+
+
+NCVStatus ncvGrowDetectionsVector_device(NCVVector<Ncv32u> &pixelMask,
+                                         Ncv32u numPixelMaskDetections,
+                                         NCVVector<NcvRect32u> &hypotheses,
+                                         Ncv32u &totalDetections,
+                                         Ncv32u totalMaxDetections,
+                                         Ncv32u rectWidth,
+                                         Ncv32u rectHeight,
+                                         Ncv32f curScale,
+                                         cudaStream_t cuStream);
+
+
+NCVStatus ncvGrowDetectionsVector_host(NCVVector<Ncv32u> &pixelMask,
+                                       Ncv32u numPixelMaskDetections,
+                                       NCVVector<NcvRect32u> &hypotheses,
+                                       Ncv32u &totalDetections,
+                                       Ncv32u totalMaxDetections,
+                                       Ncv32u rectWidth,
+                                       Ncv32u rectHeight,
+                                       Ncv32f curScale);
+
+
+NCVStatus ncvFilterHypotheses_host(NCVVector<NcvRect32u> &hypotheses,
+                                   Ncv32u &numHypotheses,
+                                   Ncv32u minNeighbors,
+                                   Ncv32f intersectEps,
+                                   NCVVector<Ncv32u> *hypothesesWeights);
+
+
+NCVStatus ncvHaarGetClassifierSize(const std::string &filename, Ncv32u &numStages,
+                                   Ncv32u &numNodes, Ncv32u &numFeatures);
+
+
+NCVStatus ncvHaarLoadFromFile_host(const std::string &filename,
+                                   HaarClassifierCascadeDescriptor &haar,
+                                   NCVVector<HaarStage64> &h_HaarStages,
+                                   NCVVector<HaarClassifierNode128> &h_HaarNodes,
+                                   NCVVector<HaarFeature64> &h_HaarFeatures);
+
+
+NCVStatus ncvHaarStoreNVBIN_host(const std::string &filename,
+                                 HaarClassifierCascadeDescriptor haar,
+                                 NCVVector<HaarStage64> &h_HaarStages,
+                                 NCVVector<HaarClassifierNode128> &h_HaarNodes,
+                                 NCVVector<HaarFeature64> &h_HaarFeatures);
+
+
+
+#endif // _ncvhaarobjectdetection_hpp_
diff --git a/modules/gpu/src/nvidia/NCVRuntimeTemplates.hpp b/modules/gpu/src/nvidia/NCVRuntimeTemplates.hpp
new file mode 100644
index 0000000000..14d16bb3b9
--- /dev/null
+++ b/modules/gpu/src/nvidia/NCVRuntimeTemplates.hpp
@@ -0,0 +1,174 @@
+////////////////////////////////////////////////////////////////////////////////
+// The Loki Library
+// Copyright (c) 2001 by Andrei Alexandrescu
+// This code accompanies the book:
+// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
+//     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
+// Permission to use, copy, modify, distribute and sell this software for any 
+//     purpose is hereby granted without fee, provided that the above copyright 
+//     notice appear in all copies and that both that copyright notice and this 
+//     permission notice appear in supporting documentation.
+// The author or Addison-Welsey Longman make no representations about the 
+//     suitability of this software for any purpose. It is provided "as is" 
+//     without express or implied warranty.
+// http://loki-lib.sourceforge.net/index.php?n=Main.License
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _ncvruntimetemplates_hpp_
+#define _ncvruntimetemplates_hpp_
+
+#include <stdarg.h>
+#include <vector>
+
+
+namespace Loki
+{
+    //==============================================================================
+    // class NullType
+    // Used as a placeholder for "no type here"
+    // Useful as an end marker in typelists 
+    //==============================================================================
+
+    class NullType {};
+
+    //==============================================================================
+    // class template Typelist
+    // The building block of typelists of any length
+    // Use it through the LOKI_TYPELIST_NN macros
+    // Defines nested types:
+    //     Head (first element, a non-typelist type by convention)
+    //     Tail (second element, can be another typelist)
+    //==============================================================================
+
+    template <class T, class U>
+    struct Typelist
+    {
+        typedef T Head;
+        typedef U Tail;
+    };
+
+    //==============================================================================
+    // class template Int2Type
+    // Converts each integral constant into a unique type
+    // Invocation: Int2Type<v> where v is a compile-time constant integral
+    // Defines 'value', an enum that evaluates to v
+    //==============================================================================
+
+    template <int v>
+    struct Int2Type
+    {
+        enum { value = v };
+    };
+
+    namespace TL
+    {
+        //==============================================================================
+        // class template TypeAt
+        // Finds the type at a given index in a typelist
+        // Invocation (TList is a typelist and index is a compile-time integral 
+        //     constant):
+        // TypeAt<TList, index>::Result
+        // returns the type in position 'index' in TList
+        // If you pass an out-of-bounds index, the result is a compile-time error
+        //==============================================================================
+
+        template <class TList, unsigned int index> struct TypeAt;
+
+        template <class Head, class Tail>
+        struct TypeAt<Typelist<Head, Tail>, 0>
+        {
+            typedef Head Result;
+        };
+
+        template <class Head, class Tail, unsigned int i>
+        struct TypeAt<Typelist<Head, Tail>, i>
+        {
+            typedef typename TypeAt<Tail, i - 1>::Result Result;
+        };
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Runtime boolean template instance dispatcher
+// Cyril Crassin <cyril.crassin@icare3d.org>
+// NVIDIA, 2010
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NCVRuntimeTemplateBool
+{
+    //This struct is used to transform a list of parameters into template arguments
+    //The idea is to build a typelist containing the arguments
+    //and to pass this typelist to a user defined functor
+    template<typename TList, int NumArguments, class Func>
+    struct KernelCaller
+    {
+        //Convenience function used by the user
+        //Takes a variable argument list, transforms it into a list
+        static void call(Func &functor, int dummy, ...)
+        {
+            //Vector used to collect arguments
+            std::vector<int> templateParamList;
+
+            //Variable argument list manipulation
+            va_list listPointer;
+            va_start(listPointer, dummy);
+            //Collect parameters into the list
+            for(int i=0; i<NumArguments; i++)
+            {
+                int val = va_arg(listPointer, int);
+                templateParamList.push_back(val);
+            }
+            va_end(listPointer);
+
+            //Call the actual typelist building function
+            call(functor, templateParamList);
+        }
+
+        //Actual function called recursively to build a typelist based
+        //on a list of values
+        static void call( Func &functor, std::vector<int> &templateParamList)
+        {
+            //Get current parameter value in the list
+            int val = templateParamList[templateParamList.size() - 1];
+            templateParamList.pop_back();
+
+            //Select the compile time value to add into the typelist
+            //depending on the runtime variable and make recursive call. 
+            //Both versions are really instantiated
+            if(val)
+            {
+                KernelCaller<
+                    Loki::Typelist<typename Loki::Int2Type<true>, TList >,
+                    NumArguments-1, Func >
+                    ::call(functor, templateParamList);
+            }
+            else
+            {
+                KernelCaller< 
+                    Loki::Typelist<typename Loki::Int2Type<false>, TList >,
+                    NumArguments-1, Func >
+                    ::call(functor, templateParamList);
+            }
+        }
+    };
+
+    //Specialization for 0 value left in the list
+    //-> actual kernel functor call
+    template<class TList, class Func>
+    struct KernelCaller<TList, 0, Func>
+    {
+        static void call(Func &functor)
+        {
+            //Call to the functor's kernel call method
+            functor.call(TList()); //TList instantiated to get the method template parameter resolved
+        }
+
+        static void call(Func &functor, std::vector<int> &templateParams)
+        {
+            functor.call(TList());
+        }
+    };
+}
+
+#endif //_ncvruntimetemplates_hpp_
diff --git a/modules/gpu/src/precomp.hpp b/modules/gpu/src/precomp.hpp
index eb906e3368..a7ba6ffaba 100644
--- a/modules/gpu/src/precomp.hpp
+++ b/modules/gpu/src/precomp.hpp
@@ -71,6 +71,9 @@
     #include "npp_staging.h"
     #include "surf_key_point.h"
 
+	#include "nvidia/NCV.hpp"
+	#include "nvidia/NCVHaarObjectDetection.hpp"
+
 #define CUDART_MINIMUM_REQUIRED_VERSION 3020
 #define NPP_MINIMUM_REQUIRED_VERSION 3216
 
diff --git a/samples/gpu/cascadeclassifier.cpp b/samples/gpu/cascadeclassifier.cpp
new file mode 100644
index 0000000000..7f0a0e74db
--- /dev/null
+++ b/samples/gpu/cascadeclassifier.cpp
@@ -0,0 +1,193 @@
+// WARNING: this sample is under construction! Use it on your own risk.
+
+#include <opencv2/contrib/contrib.hpp>
+#include <opencv2/objdetect/objdetect.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/gpu/gpu.hpp>
+
+#include <iostream>
+#include <iomanip>
+#include <stdio.h>
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+void help()
+{
+    cout << "Usage: ./cascadeclassifier <cascade_file> <image_or_video_or_cameraid>\n"               
+            "Using OpenCV version " << CV_VERSION << endl << endl;
+}
+
+void DetectAndDraw(Mat& img, CascadeClassifier_GPU& cascade);
+
+String cascadeName = "../../data/haarcascades/haarcascade_frontalface_alt.xml";
+String nestedCascadeName = "../../data/haarcascades/haarcascade_eye_tree_eyeglasses.xml";
+
+
+
+template<class T> void convertAndReseize(const T& src, T& gray, T& resized, double scale = 2.0)
+{
+    if (src.channels() == 3)
+        cvtColor( src, gray, CV_BGR2GRAY );
+    else
+        gray = src;
+
+    Size sz(cvRound(gray.cols * scale), cvRound(gray.rows * scale));
+    if (scale != 1)
+        resize(gray, resized, sz);
+    else
+        resized = gray;
+}
+
+
+
+int main( int argc, const char** argv )
+{        
+    if (argc != 3)
+        return help(), -1;
+
+    if (cv::gpu::getCudaEnabledDeviceCount() == 0)
+        return cerr << "No GPU found or the library is compiled without GPU support" << endl, -1;
+
+    VideoCapture capture;
+     
+    string cascadeName = argv[1];
+    string inputName = argv[2];
+
+    cv::gpu::CascadeClassifier_GPU cascade_gpu;
+    if( !cascade_gpu.load( cascadeName ) )
+        return cerr << "ERROR: Could not load cascade classifier \"" << cascadeName << "\"" << endl, help(), -1;
+
+    cv::CascadeClassifier cascade_cpu;
+    if( !cascade_cpu.load( cascadeName ) )
+        return cerr << "ERROR: Could not load cascade classifier \"" << cascadeName << "\"" << endl, help(), -1;
+    
+    Mat image = imread( inputName);
+    if( image.empty() )
+        if (!capture.open(inputName))
+        {
+            int camid = 0;
+            sscanf(inputName.c_str(), "%d", &camid);
+            if(!capture.open(camid))
+                cout << "Can't open source" << endl;
+        }
+    
+    namedWindow( "result", 1 );        
+    Size fontSz = cv::getTextSize("T[]", FONT_HERSHEY_SIMPLEX, 1.0, 2, 0);
+
+    Mat frame, frame_cpu, gray_cpu, resized_cpu, faces_downloaded, frameDisp;
+    vector<Rect> facesBuf_cpu;
+
+    GpuMat frame_gpu, gray_gpu, resized_gpu, facesBuf_gpu;    
+    
+    /* parameters */
+    bool useGPU = true;
+    double scale_factor = 2;
+
+    bool visualizeInPlace = false;   
+    bool findLargestObject = false;    
+
+    printf("\t<space> - toggle GPU/CPU\n");
+    printf("\tL       - toggle lagest faces\n");
+    printf("\tV       - toggle visualisation in-place (for GPU only)\n");
+    printf("\t1/q     - inc/dec scale\n");
+        
+    int detections_num;
+    for(;;)
+    {               
+        if( capture.isOpened() )
+        {
+            capture >> frame;                            
+            if( frame.empty())
+                break;
+        }
+
+        (image.empty() ? frame : image).copyTo(frame_cpu);
+        frame_gpu.upload( image.empty() ? frame : image);
+        
+        convertAndReseize(frame_gpu, gray_gpu, resized_gpu, scale_factor);
+        convertAndReseize(frame_cpu, gray_cpu, resized_cpu, scale_factor);
+
+        cv::TickMeter tm;
+        tm.start();      
+
+        if (useGPU)
+        {
+            cascade_gpu.visualizeInPlace = visualizeInPlace;   
+            cascade_gpu.findLargestObject = findLargestObject;    
+
+            detections_num = cascade_gpu.detectMultiScale( resized_gpu, facesBuf_gpu ); 
+            facesBuf_gpu.colRange(0, detections_num).download(faces_downloaded);
+        
+        }
+        else /* so use CPU */
+        {   
+            Size minSize = cascade_gpu.getClassifierSize();
+            if (findLargestObject)
+            {                
+                float ratio = (float)std::min(frame.cols / minSize.width, frame.rows / minSize.height);
+                ratio = std::max(ratio / 2.5f, 1.f);
+                minSize = Size(cvRound(minSize.width * ratio), cvRound(minSize.height * ratio));                
+            }
+            
+            cascade_cpu.detectMultiScale(resized_cpu, facesBuf_cpu, 1.2, 4, (findLargestObject ? CV_HAAR_FIND_BIGGEST_OBJECT : 0) | CV_HAAR_SCALE_IMAGE, minSize);                            
+            detections_num = (int)facesBuf_cpu.size();
+        }
+
+        tm.stop();
+        printf( "detection time = %g ms\n", tm.getTimeMilli() );
+
+        if (useGPU)
+            resized_gpu.download(resized_cpu);
+
+        if (!visualizeInPlace || !useGPU)
+            if (detections_num)
+            {
+                Rect* faces = useGPU ? faces_downloaded.ptr<Rect>() : &facesBuf_cpu[0];                
+                for(int i = 0; i < detections_num; ++i)                
+                    cv::rectangle(resized_cpu, faces[i], Scalar(255));            
+            }
+        
+        Point text_pos(5, 25);
+        int offs = fontSz.height + 5;
+        Scalar color = CV_RGB(255, 0, 0);
+
+
+        cv::cvtColor(resized_cpu, frameDisp, CV_GRAY2BGR);
+
+        char buf[4096];
+        sprintf(buf, "%s, FPS = %0.3g", useGPU ? "GPU" : "CPU", 1.0/tm.getTimeSec());                       
+        putText(frameDisp, buf, text_pos, FONT_HERSHEY_SIMPLEX, 1.0, color, 2);
+        sprintf(buf, "scale = %0.3g, [%d*scale x %d*scale]", scale_factor, frame.cols, frame.rows);                       
+        putText(frameDisp, buf, text_pos+=Point(0,offs), FONT_HERSHEY_SIMPLEX, 1.0, color, 2);
+        putText(frameDisp, "Hotkeys: space, 1, Q, L, V, Esc", text_pos+=Point(0,offs), FONT_HERSHEY_SIMPLEX, 1.0, color, 2);
+
+        if (findLargestObject)
+            putText(frameDisp, "FindLargestObject", text_pos+=Point(0,offs), FONT_HERSHEY_SIMPLEX, 1.0, color, 2);
+
+        if (visualizeInPlace && useGPU)
+            putText(frameDisp, "VisualizeInPlace", text_pos+Point(0,offs), FONT_HERSHEY_SIMPLEX, 1.0, color, 2);
+
+        cv::imshow( "result", frameDisp);
+
+        int key = waitKey( 5 );
+        if( key == 27)
+            break;
+
+        switch (key)
+        {
+        case (int)' ':  useGPU = !useGPU;  printf("Using %s\n", useGPU ? "GPU" : "CPU");break;
+        case (int)'v':  case (int)'V': visualizeInPlace = !visualizeInPlace; printf("VisualizeInPlace = %d\n", visualizeInPlace); break;
+        case (int)'l':  case (int)'L': findLargestObject = !findLargestObject;  printf("FindLargestObject = %d\n", findLargestObject); break;
+        case (int)'1':  scale_factor*=1.05; printf("Scale factor = %g\n", scale_factor); break;
+        case (int)'q':  case (int)'Q':scale_factor/=1.05; printf("Scale factor = %g\n", scale_factor); break;
+        }
+       
+    }    
+    return 0;
+}
+
+
+