fixed "shadow" warnings in nvidia folder

diff --git a/modules/gpu/src/nvidia/NCVBroxOpticalFlow.cu b/modules/gpu/src/nvidia/NCVBroxOpticalFlow.cu
index cfe26d5..574de53 100644 (file)
--- a/modules/gpu/src/nvidia/NCVBroxOpticalFlow.cu
+++ b/modules/gpu/src/nvidia/NCVBroxOpticalFlow.cu
@@ -940,7 +940,7 @@ NCVStatus NCVBroxOpticalFlow(const NCVBroxOpticalFlowDescriptor desc,
             ncvAssertCUDAReturn(cudaMemsetAsync(dv.ptr(), 0, kLevelSizeInBytes, stream), NCV_CUDA_ERROR);\r
 \r
             //texture format descriptor\r
-            cudaChannelFormatDesc channel_desc = cudaCreateChannelDesc<float>();\r
+            cudaChannelFormatDesc ch_desc = cudaCreateChannelDesc<float>();\r
 \r
             I0 = *img0Iter;\r
             I1 = *img1Iter;\r
@@ -948,8 +948,8 @@ NCVStatus NCVBroxOpticalFlow(const NCVBroxOpticalFlowDescriptor desc,
             ++img0Iter;\r
             ++img1Iter;\r
 \r
-            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_I0, I0->ptr(), channel_desc, kLevelWidth, kLevelHeight, kLevelStride*sizeof(float)), NCV_CUDA_ERROR);\r
-            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_I1, I1->ptr(), channel_desc, kLevelWidth, kLevelHeight, kLevelStride*sizeof(float)), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_I0, I0->ptr(), ch_desc, kLevelWidth, kLevelHeight, kLevelStride*sizeof(float)), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_I1, I1->ptr(), ch_desc, kLevelWidth, kLevelHeight, kLevelStride*sizeof(float)), NCV_CUDA_ERROR);\r
 \r
             //compute derivatives\r
             dim3 dBlocks(iDivUp(kLevelWidth, 32), iDivUp(kLevelHeight, 6));\r
@@ -989,20 +989,20 @@ NCVStatus NCVBroxOpticalFlow(const NCVBroxOpticalFlowDescriptor desc,
             ncvAssertReturnNcvStat( nppiStFilterRowBorder_32f_C1R (Iy.ptr(), srcSize, nSrcStep, Ixy.ptr(), srcSize, nSrcStep, oROI,\r
                 nppStBorderMirror, derivativeFilter.ptr(), kDFilterSize, kDFilterSize/2, 1.0f/12.0f) ); \r
       \r
-            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Ix,  Ix.ptr(),  channel_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
-            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Ixx, Ixx.ptr(), channel_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
-            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Ix0, Ix0.ptr(), channel_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
-            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Iy,  Iy.ptr(),  channel_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
-            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Iyy, Iyy.ptr(), channel_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
-            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Iy0, Iy0.ptr(), channel_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
-            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Ixy, Ixy.ptr(), channel_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Ix,  Ix.ptr(),  ch_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Ixx, Ixx.ptr(), ch_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Ix0, Ix0.ptr(), ch_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Iy,  Iy.ptr(),  ch_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Iyy, Iyy.ptr(), ch_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Iy0, Iy0.ptr(), ch_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture2D(0, tex_Ixy, Ixy.ptr(), ch_desc, kLevelWidth, kLevelHeight, kPitchTex), NCV_CUDA_ERROR);\r
 \r
             //    flow\r
-            ncvAssertCUDAReturn(cudaBindTexture(0, tex_u, ptrU->ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
-            ncvAssertCUDAReturn(cudaBindTexture(0, tex_v, ptrV->ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture(0, tex_u, ptrU->ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture(0, tex_v, ptrV->ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
             //    flow increments\r
-            ncvAssertCUDAReturn(cudaBindTexture(0, tex_du, du.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
-            ncvAssertCUDAReturn(cudaBindTexture(0, tex_dv, dv.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture(0, tex_du, du.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+            ncvAssertCUDAReturn(cudaBindTexture(0, tex_dv, dv.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
 \r
             dim3 psor_blocks(iDivUp(kLevelWidth, PSOR_TILE_WIDTH), iDivUp(kLevelHeight, PSOR_TILE_HEIGHT));\r
             dim3 psor_threads(PSOR_TILE_WIDTH, PSOR_TILE_HEIGHT);\r
@@ -1032,37 +1032,37 @@ NCVStatus NCVBroxOpticalFlow(const NCVBroxOpticalFlowDescriptor desc,
 \r
                 ncvAssertCUDALastErrorReturn(NCV_CUDA_ERROR);\r
                     \r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_diffusivity_x, diffusivity_x.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_diffusivity_y, diffusivity_y.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_diffusivity_x, diffusivity_x.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_diffusivity_y, diffusivity_y.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
 \r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_dudv, num_dudv.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_dudv, num_dudv.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
 \r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_u, num_u.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_v, num_v.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_u, num_u.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_v, num_v.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
 \r
                 prepare_sor_stage_2<<<psor_blocks, psor_threads, 0, stream>>>(denom_u.ptr(), denom_v.ptr(), kLevelWidth, kLevelHeight, kLevelStride);\r
 \r
                 ncvAssertCUDALastErrorReturn(NCV_CUDA_ERROR);\r
                 \r
                 //    linear system coefficients\r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_diffusivity_x, diffusivity_x.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_diffusivity_y, diffusivity_y.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_diffusivity_x, diffusivity_x.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_diffusivity_y, diffusivity_y.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
 \r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_dudv, num_dudv.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_dudv, num_dudv.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
 \r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_u, num_u.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_v, num_v.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_u, num_u.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_numerator_v, num_v.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
 \r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_inv_denominator_u, denom_u.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
-                ncvAssertCUDAReturn(cudaBindTexture(0, tex_inv_denominator_v, denom_v.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_inv_denominator_u, denom_u.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                ncvAssertCUDAReturn(cudaBindTexture(0, tex_inv_denominator_v, denom_v.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
             \r
                 //solve linear system\r
                 for (Ncv32u solver_iteration = 0; solver_iteration < desc.number_of_solver_iterations; ++solver_iteration)\r
                 {\r
                     float omega = 1.99f;\r
                 \r
-                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_du, du.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
-                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_dv, dv.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_du, du.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_dv, dv.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
 \r
                     sor_pass<0><<<sor_blocks, sor_threads, 0, stream>>>\r
                         (du_new.ptr(), \r
@@ -1079,8 +1079,8 @@ NCVStatus NCVBroxOpticalFlow(const NCVBroxOpticalFlowDescriptor desc,
 \r
                     ncvAssertCUDALastErrorReturn(NCV_CUDA_ERROR);\r
 \r
-                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_du, du_new.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
-                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_dv, dv_new.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_du, du_new.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_dv, dv_new.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
 \r
                     sor_pass<1><<<sor_blocks, sor_threads, 0, stream>>>\r
                         (du.ptr(), \r
@@ -1097,8 +1097,8 @@ NCVStatus NCVBroxOpticalFlow(const NCVBroxOpticalFlowDescriptor desc,
 \r
                     ncvAssertCUDALastErrorReturn(NCV_CUDA_ERROR);\r
 \r
-                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_du, du.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
-                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_dv, dv.ptr(), channel_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_du, du.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
+                    ncvAssertCUDAReturn(cudaBindTexture(0, tex_dv, dv.ptr(), ch_desc, kLevelSizeInBytes), NCV_CUDA_ERROR);\r
                 }//end of solver loop\r
             }// end of inner loop\r
 \r

diff --git a/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu b/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
index 781d411..ad072eb 100644 (file)
--- a/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
+++ b/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
@@ -1622,16 +1622,16 @@ NCVStatus ncvDetectObjectsMultiScale_device(NCVMatrix<Ncv8u> &d_srcImg,
             continue;\r
         }\r
 \r
-        NcvSize32s srcRoi, srcIIRoi, scaledIIRoi, searchRoi;\r
+        NcvSize32s srcRoi_, srcIIRo_i, scaledIIRoi, searchRoi;\r
 \r
-        srcRoi.width = d_srcImg.width();\r
-        srcRoi.height = d_srcImg.height();\r
+        srcRoi_.width = d_srcImg.width();\r
+        srcRoi_.height = d_srcImg.height();\r
 \r
-        srcIIRoi.width = srcRoi.width + 1;\r
-        srcIIRoi.height = srcRoi.height + 1;\r
+        srcIIRo_i.width = srcRoi_.width + 1;\r
+        srcIIRo_i.height = srcRoi_.height + 1;\r
 \r
-        scaledIIRoi.width = srcIIRoi.width / scale;\r
-        scaledIIRoi.height = srcIIRoi.height / scale;\r
+        scaledIIRoi.width = srcIIRo_i.width / scale;\r
+        scaledIIRoi.height = srcIIRo_i.height / scale;\r
 \r
         searchRoi.width = scaledIIRoi.width - haar.ClassifierSize.width;\r
         searchRoi.height = scaledIIRoi.height - haar.ClassifierSize.height;\r
@@ -1659,12 +1659,12 @@ NCVStatus ncvDetectObjectsMultiScale_device(NCVMatrix<Ncv8u> &d_srcImg,
     {\r
         Ncv32u scale = scalesVector[i];\r
 \r
-        NcvSize32u srcRoi, scaledIIRoi, searchRoi;\r
+        NcvSize32u srcRoi_, scaledIIRoi, searchRoi;\r
         NcvSize32u srcIIRoi;\r
-        srcRoi.width = d_srcImg.width();\r
-        srcRoi.height = d_srcImg.height();\r
-        srcIIRoi.width = srcRoi.width + 1;\r
-        srcIIRoi.height = srcRoi.height + 1;\r
+        srcRoi_.width = d_srcImg.width();\r
+        srcRoi_.height = d_srcImg.height();\r
+        srcIIRoi.width = srcRoi_.width + 1;\r
+        srcIIRoi.height = srcRoi_.height + 1;\r
         scaledIIRoi.width = srcIIRoi.width / scale;\r
         scaledIIRoi.height = srcIIRoi.height / scale;\r
         searchRoi.width = scaledIIRoi.width - haar.ClassifierSize.width;\r

diff --git a/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu b/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu
index 1ac44c5..af239e9 100644 (file)
--- a/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu
+++ b/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu
@@ -1414,17 +1414,17 @@ NCVStatus compactVector_32u_device(Ncv32u *d_src, Ncv32u srcLen,
         //calculate hierarchical partial sums\r
         for (Ncv32u i=1; i<partSumNums.size()-1; i++)\r
         {\r
-            dim3 grid(partSumNums[i+1]);\r
-            if (grid.x > 65535)\r
+            dim3 grid_partial(partSumNums[i+1]);\r
+            if (grid_partial.x > 65535)\r
             {\r
-                grid.y = (grid.x + 65534) / 65535;\r
-                grid.x = 65535;\r
+                grid_partial.y = (grid_partial.x + 65534) / 65535;\r
+                grid_partial.x = 65535;\r
             }\r
-            if (grid.x != 1)\r
+            if (grid_partial.x != 1)\r
             {\r
                 removePass1Scan\r
                     <false, true>\r
-                    <<<grid, block, 0, nppStGetActiveCUDAstream()>>>\r
+                    <<<grid_partial, block, 0, nppStGetActiveCUDAstream()>>>\r
                     (d_hierSums.ptr() + partSumOffsets[i],\r
                      partSumNums[i], NULL,\r
                      d_hierSums.ptr() + partSumOffsets[i+1],\r
@@ -1434,7 +1434,7 @@ NCVStatus compactVector_32u_device(Ncv32u *d_src, Ncv32u srcLen,
             {\r
                 removePass1Scan\r
                     <false, false>\r
-                    <<<grid, block, 0, nppStGetActiveCUDAstream()>>>\r
+                    <<<grid_partial, block, 0, nppStGetActiveCUDAstream()>>>\r
                     (d_hierSums.ptr() + partSumOffsets[i],\r
                      partSumNums[i], NULL,\r
                      NULL,\r

diff --git a/modules/gpu/src/nvidia/core/NCV.cu b/modules/gpu/src/nvidia/core/NCV.cu
index e24a47b..ba4e08e 100644 (file)
--- a/modules/gpu/src/nvidia/core/NCV.cu
+++ b/modules/gpu/src/nvidia/core/NCV.cu
@@ -723,16 +723,16 @@ static NCVStatus drawRectsWrapperHost(T *h_dst,
 \r
         if (rect.x < dstWidth)\r
         {\r
-            for (Ncv32u i=rect.y; i<rect.y+rect.height && i<dstHeight; i++)\r
+            for (Ncv32u each=rect.y; each<rect.y+rect.height && each<dstHeight; each++)\r
             {\r
-                h_dst[i*dstStride+rect.x] = color;\r
+                h_dst[each*dstStride+rect.x] = color;\r
             }\r
         }\r
         if (rect.x+rect.width-1 < dstWidth)\r
         {\r
-            for (Ncv32u i=rect.y; i<rect.y+rect.height && i<dstHeight; i++)\r
+            for (Ncv32u each=rect.y; each<rect.y+rect.height && each<dstHeight; each++)\r
             {\r
-                h_dst[i*dstStride+rect.x+rect.width-1] = color;\r
+                h_dst[each*dstStride+rect.x+rect.width-1] = color;\r
             }\r
         }\r
         if (rect.y < dstHeight)\r

diff --git a/modules/gpu/src/nvidia/core/NCV.hpp b/modules/gpu/src/nvidia/core/NCV.hpp
index f89a364..19003e3 100644 (file)
--- a/modules/gpu/src/nvidia/core/NCV.hpp
+++ b/modules/gpu/src/nvidia/core/NCV.hpp
@@ -623,11 +623,11 @@ class NCVVectorAlloc : public NCVVector<T>
 {\r
     NCVVectorAlloc();\r
     NCVVectorAlloc(const NCVVectorAlloc &);\r
-    NCVVectorAlloc& operator=(const NCVVectorAlloc<T>&);       \r
+    NCVVectorAlloc& operator=(const NCVVectorAlloc<T>&);\r
 \r
 public:\r
 \r
-    NCVVectorAlloc(INCVMemAllocator &allocator_, Ncv32u length)\r
+    NCVVectorAlloc(INCVMemAllocator &allocator_, Ncv32u length_)\r
         :\r
         allocator(allocator_)\r
     {\r
@@ -636,11 +636,11 @@ public:
         this->clear();\r
         this->allocatedMem.clear();\r
 \r
-        ncvStat = allocator.alloc(this->allocatedMem, length * sizeof(T));\r
+        ncvStat = allocator.alloc(this->allocatedMem, length_ * sizeof(T));\r
         ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "NCVVectorAlloc ctor:: alloc failed", );\r
 \r
         this->_ptr = (T *)this->allocatedMem.begin.ptr;\r
-        this->_length = length;\r
+        this->_length = length_;\r
         this->_memtype = this->allocatedMem.begin.memtype;\r
     }\r
 \r
@@ -698,15 +698,15 @@ public:
         this->bReused = true;\r
     }\r
 \r
-    NCVVectorReuse(const NCVMemSegment &memSegment, Ncv32u length)\r
+    NCVVectorReuse(const NCVMemSegment &memSegment, Ncv32u length_)\r
     {\r
         this->bReused = false;\r
         this->clear();\r
 \r
-        ncvAssertPrintReturn(length * sizeof(T) <= memSegment.size, \\r
+        ncvAssertPrintReturn(length_ * sizeof(T) <= memSegment.size, \\r
             "NCVVectorReuse ctor:: memory binding failed due to size mismatch", );\r
 \r
-        this->_length = length;\r
+        this->_length = length_;\r
         this->_ptr = (T *)memSegment.begin.ptr;\r
         this->_memtype = memSegment.begin.memtype;\r
 \r
@@ -841,34 +841,34 @@ class NCVMatrixAlloc : public NCVMatrix<T>
     NCVMatrixAlloc& operator=(const NCVMatrixAlloc &);\r
 public:\r
 \r
-    NCVMatrixAlloc(INCVMemAllocator &allocator, Ncv32u width, Ncv32u height, Ncv32u _pitch=0)\r
+    NCVMatrixAlloc(INCVMemAllocator &allocator_, Ncv32u width_, Ncv32u height_, Ncv32u pitch_=0)\r
         :\r
-        allocator(allocator)\r
+        allocator(allocator_)\r
     {\r
         NCVStatus ncvStat;\r
 \r
         this->clear();\r
         this->allocatedMem.clear();\r
 \r
-        Ncv32u widthBytes = width * sizeof(T);\r
+        Ncv32u widthBytes = width_ * sizeof(T);\r
         Ncv32u pitchBytes = alignUp(widthBytes, allocator.alignment());\r
 \r
-        if (_pitch != 0)\r
+        if (pitch_ != 0)\r
         {\r
-            ncvAssertPrintReturn(_pitch >= pitchBytes &&\r
-                (_pitch & (allocator.alignment() - 1)) == 0,\r
+            ncvAssertPrintReturn(pitch_ >= pitchBytes &&\r
+                (pitch_ & (allocator.alignment() - 1)) == 0,\r
                 "NCVMatrixAlloc ctor:: incorrect pitch passed", );\r
-            pitchBytes = _pitch;\r
+            pitchBytes = pitch_;\r
         }\r
 \r
-        Ncv32u requiredAllocSize = pitchBytes * height;\r
+        Ncv32u requiredAllocSize = pitchBytes * height_;\r
 \r
         ncvStat = allocator.alloc(this->allocatedMem, requiredAllocSize);\r
         ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "NCVMatrixAlloc ctor:: alloc failed", );\r
 \r
         this->_ptr = (T *)this->allocatedMem.begin.ptr;\r
-        this->_width = width;\r
-        this->_height = height;\r
+        this->_width = width_;\r
+        this->_height = height_;\r
         this->_pitch = pitchBytes;\r
         this->_memtype = this->allocatedMem.begin.memtype;\r
     }\r
@@ -916,34 +916,34 @@ class NCVMatrixReuse : public NCVMatrix<T>
 \r
 public:\r
 \r
-    NCVMatrixReuse(const NCVMemSegment &memSegment, Ncv32u alignment, Ncv32u width, Ncv32u height, Ncv32u pitch=0, NcvBool bSkipPitchCheck=false)\r
+    NCVMatrixReuse(const NCVMemSegment &memSegment, Ncv32u alignment, Ncv32u width_, Ncv32u height_, Ncv32u pitch_=0, NcvBool bSkipPitchCheck=false)\r
     {\r
         this->bReused = false;\r
         this->clear();\r
 \r
-        Ncv32u widthBytes = width * sizeof(T);\r
+        Ncv32u widthBytes = width_ * sizeof(T);\r
         Ncv32u pitchBytes = alignUp(widthBytes, alignment);\r
 \r
-        if (pitch != 0)\r
+        if (pitch_ != 0)\r
         {\r
             if (!bSkipPitchCheck)\r
             {\r
-                ncvAssertPrintReturn(pitch >= pitchBytes &&\r
-                    (pitch & (alignment - 1)) == 0,\r
+                ncvAssertPrintReturn(pitch_ >= pitchBytes &&\r
+                    (pitch_ & (alignment - 1)) == 0,\r
                     "NCVMatrixReuse ctor:: incorrect pitch passed", );\r
             }\r
             else\r
             {\r
-                ncvAssertPrintReturn(pitch >= widthBytes, "NCVMatrixReuse ctor:: incorrect pitch passed", );\r
+                ncvAssertPrintReturn(pitch_ >= widthBytes, "NCVMatrixReuse ctor:: incorrect pitch passed", );\r
             }\r
-            pitchBytes = pitch;\r
+            pitchBytes = pitch_;\r
         }\r
 \r
-        ncvAssertPrintReturn(pitchBytes * height <= memSegment.size, \\r
+        ncvAssertPrintReturn(pitchBytes * height_ <= memSegment.size, \\r
             "NCVMatrixReuse ctor:: memory binding failed due to size mismatch", );\r
 \r
-        this->_width = width;\r
-        this->_height = height;\r
+        this->_width = width_;\r
+        this->_height = height_;\r
         this->_pitch = pitchBytes;\r
         this->_ptr = (T *)memSegment.begin.ptr;\r
         this->_memtype = memSegment.begin.memtype;\r