fixed "shadow" warnings in NVIDIA tests

modules/gpu/test/nvidia/NCVAutoTestLister.hpp

@@ -26,11 +26,11 @@ class NCVAutoTestLister
 {
 public:
 
-    NCVAutoTestLister(std::string testSuiteName, OutputLevel outputLevel = OutputLevelCompact, NcvBool bStopOnFirstFail=false)
+    NCVAutoTestLister(std::string testSuiteName_, OutputLevel outputLevel_ = OutputLevelCompact, NcvBool bStopOnFirstFail_=false)
         :
-    testSuiteName(testSuiteName),
-    outputLevel(outputLevel),
-    bStopOnFirstFail(bStopOnFirstFail)
+    testSuiteName(testSuiteName_),
+    outputLevel(outputLevel_),
+    bStopOnFirstFail(bStopOnFirstFail_)
     {
     }
 

modules/gpu/test/nvidia/NCVTest.hpp

@@ -46,9 +46,9 @@ class NCVTestProvider : public INCVTest
 {
 public:
 
-    NCVTestProvider(std::string testName)
+    NCVTestProvider(std::string testName_)
         :
-        testName(testName)
+        testName(testName_)
     {
         int devId;
         ncvAssertPrintReturn(cudaSuccess == cudaGetDevice(&devId), "Error returned from cudaGetDevice", );

modules/gpu/test/nvidia/TestCompact.cpp

@@ -12,14 +12,14 @@
 #include "TestCompact.h"
 
 
-TestCompact::TestCompact(std::string testName, NCVTestSourceProvider<Ncv32u> &src,
-                                             Ncv32u length, Ncv32u badElem, Ncv32u badElemPercentage)
+TestCompact::TestCompact(std::string testName_, NCVTestSourceProvider<Ncv32u> &src_,
+                                             Ncv32u length_, Ncv32u badElem_, Ncv32u badElemPercentage_)
     :
-    NCVTestProvider(testName),
-    src(src),
-    length(length),
-    badElem(badElem),
-    badElemPercentage(badElemPercentage > 100 ? 100 : badElemPercentage)
+    NCVTestProvider(testName_),
+    src(src_),
+    length(length_),
+    badElem(badElem_),
+    badElemPercentage(badElemPercentage_ > 100 ? 100 : badElemPercentage_)
 {
 }
 

modules/gpu/test/nvidia/TestDrawRects.cpp

@@ -14,16 +14,17 @@
 
 
 template <class T>
-TestDrawRects<T>::TestDrawRects(std::string testName, NCVTestSourceProvider<T> &src, NCVTestSourceProvider<Ncv32u> &src32u,
-                                Ncv32u width, Ncv32u height, Ncv32u numRects, T color)
+TestDrawRects<T>::TestDrawRects(std::string testName_, NCVTestSourceProvider<T> &src_,
+                                NCVTestSourceProvider<Ncv32u> &src32u_,
+                                Ncv32u width_, Ncv32u height_, Ncv32u numRects_, T color_)
     :
-    NCVTestProvider(testName),
-    src(src),
-    src32u(src32u),
-    width(width),
-    height(height),
-    numRects(numRects),
-    color(color)
+    NCVTestProvider(testName_),
+    src(src_),
+    src32u(src32u_),
+    width(width_),
+    height(height_),
+    numRects(numRects_),
+    color(color_)
 {
 }
 

modules/gpu/test/nvidia/TestHaarCascadeApplication.cpp

@@ -19,14 +19,14 @@
 #include "NCVHaarObjectDetection.hpp"
 
 
-TestHaarCascadeApplication::TestHaarCascadeApplication(std::string testName, NCVTestSourceProvider<Ncv8u> &src,
-                                                       std::string cascadeName, Ncv32u width, Ncv32u height)
+TestHaarCascadeApplication::TestHaarCascadeApplication(std::string testName_, NCVTestSourceProvider<Ncv8u> &src_,
+                                                       std::string cascadeName_, Ncv32u width_, Ncv32u height_)
     :
-    NCVTestProvider(testName),
-    src(src),
-    cascadeName(cascadeName),
-    width(width),
-    height(height)
+    NCVTestProvider(testName_),
+    src(src_),
+    cascadeName(cascadeName_),
+    width(width_),
+    height(height_)
 {
 }
 

modules/gpu/test/nvidia/TestHaarCascadeLoader.cpp

@@ -13,10 +13,10 @@
 #include "NCVHaarObjectDetection.hpp"
 
 
-TestHaarCascadeLoader::TestHaarCascadeLoader(std::string testName, std::string cascadeName)
+TestHaarCascadeLoader::TestHaarCascadeLoader(std::string testName_, std::string cascadeName_)
     :
-    NCVTestProvider(testName),
-    cascadeName(cascadeName)
+    NCVTestProvider(testName_),
+    cascadeName(cascadeName_)
 {
 }
 

modules/gpu/test/nvidia/TestHypothesesGrow.cpp

@@ -13,19 +13,19 @@
 #include "NCVHaarObjectDetection.hpp"
 
 
-TestHypothesesGrow::TestHypothesesGrow(std::string testName, NCVTestSourceProvider<Ncv32u> &src,
-                                       Ncv32u rectWidth, Ncv32u rectHeight, Ncv32f rectScale, 
-                                       Ncv32u maxLenSrc, Ncv32u lenSrc, Ncv32u maxLenDst, Ncv32u lenDst)
+TestHypothesesGrow::TestHypothesesGrow(std::string testName_, NCVTestSourceProvider<Ncv32u> &src_,
+                                       Ncv32u rectWidth_, Ncv32u rectHeight_, Ncv32f rectScale_,
+                                       Ncv32u maxLenSrc_, Ncv32u lenSrc_, Ncv32u maxLenDst_, Ncv32u lenDst_)
     :
-    NCVTestProvider(testName),
-    src(src),
-    rectWidth(rectWidth),
-    rectHeight(rectHeight),
-    rectScale(rectScale),
-    maxLenSrc(maxLenSrc),
-    lenSrc(lenSrc),
-    maxLenDst(maxLenDst),
-    lenDst(lenDst)
+    NCVTestProvider(testName_),
+    src(src_),
+    rectWidth(rectWidth_),
+    rectHeight(rectHeight_),
+    rectScale(rectScale_),
+    maxLenSrc(maxLenSrc_),
+    lenSrc(lenSrc_),
+    maxLenDst(maxLenDst_),
+    lenDst(lenDst_)
 {
 }
 

modules/gpu/test/nvidia/TestIntegralImage.cpp

@@ -14,13 +14,13 @@
 
 
 template <class T_in, class T_out>
-TestIntegralImage<T_in, T_out>::TestIntegralImage(std::string testName, NCVTestSourceProvider<T_in> &src,
-                                                  Ncv32u width, Ncv32u height)
+TestIntegralImage<T_in, T_out>::TestIntegralImage(std::string testName_, NCVTestSourceProvider<T_in> &src_,
+                                                  Ncv32u width_, Ncv32u height_)
     :
-    NCVTestProvider(testName),
-    src(src),
-    width(width),
-    height(height)
+    NCVTestProvider(testName_),
+    src(src_),
+    width(width_),
+    height(height_)
 {
 }
 

modules/gpu/test/nvidia/TestIntegralImageSquared.cpp

@@ -12,13 +12,13 @@
 #include "TestIntegralImageSquared.h"
 
 
-TestIntegralImageSquared::TestIntegralImageSquared(std::string testName, NCVTestSourceProvider<Ncv8u> &src,
-                                                   Ncv32u width, Ncv32u height)
+TestIntegralImageSquared::TestIntegralImageSquared(std::string testName_, NCVTestSourceProvider<Ncv8u> &src_,
+                                                   Ncv32u width_, Ncv32u height_)
     :
-    NCVTestProvider(testName),
-    src(src),
-    width(width),
-    height(height)
+    NCVTestProvider(testName_),
+    src(src_),
+    width(width_),
+    height(height_)
 {
 }
 

modules/gpu/test/nvidia/TestRectStdDev.cpp

@@ -14,17 +14,17 @@
 #include "TestRectStdDev.h"
 
 
-TestRectStdDev::TestRectStdDev(std::string testName, NCVTestSourceProvider<Ncv8u> &src,
-                               Ncv32u width, Ncv32u height, NcvRect32u rect, Ncv32f scaleFactor,
-                               NcvBool bTextureCache)
+TestRectStdDev::TestRectStdDev(std::string testName_, NCVTestSourceProvider<Ncv8u> &src_,
+                               Ncv32u width_, Ncv32u height_, NcvRect32u rect_, Ncv32f scaleFactor_,
+                               NcvBool bTextureCache_)
     :
-    NCVTestProvider(testName),
-    src(src),
-    width(width),
-    height(height),
-    rect(rect),
-    scaleFactor(scaleFactor),
-    bTextureCache(bTextureCache)
+    NCVTestProvider(testName_),
+    src(src_),
+    width(width_),
+    height(height_),
+    rect(rect_),
+    scaleFactor(scaleFactor_),
+    bTextureCache(bTextureCache_)
 {
 }
 

modules/gpu/test/nvidia/TestTranspose.cpp

@@ -15,13 +15,13 @@
 
 
 template <class T>
-TestTranspose<T>::TestTranspose(std::string testName, NCVTestSourceProvider<T> &src,
-                                Ncv32u width, Ncv32u height)
+TestTranspose<T>::TestTranspose(std::string testName_, NCVTestSourceProvider<T> &src_,
+                                Ncv32u width_, Ncv32u height_)
     :
-    NCVTestProvider(testName),
-    src(src),
-    width(width),
-    height(height)
+    NCVTestProvider(testName_),
+    src(src_),
+    width(width_),
+    height(height_)
 {
 }