fixed more "shadow" warnings

diff --git a/modules/gpu/src/brute_force_matcher.cpp b/modules/gpu/src/brute_force_matcher.cpp
index ce3e028..ca4a6fc 100644 (file)
--- a/modules/gpu/src/brute_force_matcher.cpp
+++ b/modules/gpu/src/brute_force_matcher.cpp
@@ -1024,11 +1024,11 @@ void cv::gpu::BFMatcher_GPU::radiusMatchConvert(const Mat& trainIdx, const Mat&
 \r
         for (int i = 0; i < nMatches; ++i, ++trainIdx_ptr, ++imgIdx_ptr, ++distance_ptr)\r
         {\r
-            int trainIdx = *trainIdx_ptr;\r
-            int imgIdx = *imgIdx_ptr;\r
-            float distance = *distance_ptr;\r
+            int _trainIdx = *trainIdx_ptr;\r
+            int _imgIdx = *imgIdx_ptr;\r
+            float _distance = *distance_ptr;\r
 \r
-            DMatch m(queryIdx, trainIdx, imgIdx, distance);\r
+            DMatch m(queryIdx, _trainIdx, _imgIdx, _distance);\r
 \r
             curMatches.push_back(m);\r
         }\r

diff --git a/modules/gpu/src/hog.cpp b/modules/gpu/src/hog.cpp
index 25c3f47..3e5317a 100644 (file)
--- a/modules/gpu/src/hog.cpp
+++ b/modules/gpu/src/hog.cpp
@@ -98,17 +98,17 @@ namespace cv { namespace gpu { namespace device
 \r
 using namespace ::cv::gpu::device;\r
     \r
-cv::gpu::HOGDescriptor::HOGDescriptor(Size win_size, Size block_size, Size block_stride, Size cell_size, \r
-                                                                         int nbins, double win_sigma, double threshold_L2hys, bool gamma_correction, int nlevels)\r
-        : win_size(win_size), \r
-          block_size(block_size), \r
-          block_stride(block_stride), \r
-          cell_size(cell_size),\r
-          nbins(nbins), \r
-          win_sigma(win_sigma),\r
-          threshold_L2hys(threshold_L2hys),\r
-          gamma_correction(gamma_correction),\r
-          nlevels(nlevels)\r
+cv::gpu::HOGDescriptor::HOGDescriptor(Size win_size_, Size block_size_, Size block_stride_, Size cell_size_,\r
+                                      int nbins_, double win_sigma_, double threshold_L2hys_, bool gamma_correction_, int nlevels_)\r
+        : win_size(win_size_),\r
+          block_size(block_size_),\r
+          block_stride(block_stride_),\r
+          cell_size(cell_size_),\r
+          nbins(nbins_),\r
+          win_sigma(win_sigma_),\r
+          threshold_L2hys(threshold_L2hys_),\r
+          gamma_correction(gamma_correction_),\r
+          nlevels(nlevels_)\r
 {\r
     CV_Assert((win_size.width  - block_size.width ) % block_stride.width  == 0 && \r
               (win_size.height - block_size.height) % block_stride.height == 0);\r
@@ -149,9 +149,9 @@ bool cv::gpu::HOGDescriptor::checkDetectorSize() const
     return detector_size == 0 || detector_size == descriptor_size || detector_size == descriptor_size + 1;\r
 }\r
 \r
-void cv::gpu::HOGDescriptor::setSVMDetector(const vector<float>& detector)\r
+void cv::gpu::HOGDescriptor::setSVMDetector(const vector<float>& _detector)\r
 {\r
-    std::vector<float> detector_reordered(detector.size());\r
+    std::vector<float> detector_reordered(_detector.size());\r
 \r
     size_t block_hist_size = getBlockHistogramSize();\r
     cv::Size blocks_per_img = numPartsWithin(win_size, block_size, block_stride);\r
@@ -159,7 +159,7 @@ void cv::gpu::HOGDescriptor::setSVMDetector(const vector<float>& detector)
     for (int i = 0; i < blocks_per_img.height; ++i)\r
         for (int j = 0; j < blocks_per_img.width; ++j)\r
         {\r
-            const float* src = &detector[0] + (j * blocks_per_img.height + i) * block_hist_size;\r
+            const float* src = &_detector[0] + (j * blocks_per_img.height + i) * block_hist_size;\r
             float* dst = &detector_reordered[0] + (i * blocks_per_img.width + j) * block_hist_size;\r
             for (size_t k = 0; k < block_hist_size; ++k)\r
                 dst[k] = src[k];\r
@@ -168,7 +168,7 @@ void cv::gpu::HOGDescriptor::setSVMDetector(const vector<float>& detector)
     this->detector.upload(Mat(detector_reordered).reshape(1, 1));\r
 \r
     size_t descriptor_size = getDescriptorSize();  \r
-    free_coef = detector.size() > descriptor_size ? detector[descriptor_size] : 0;\r
+    free_coef = _detector.size() > descriptor_size ? _detector[descriptor_size] : 0;\r
 \r
     CV_Assert(checkDetectorSize());\r
 }\r
@@ -190,24 +190,24 @@ cv::gpu::GpuMat cv::gpu::HOGDescriptor::getBuffer(int rows, int cols, int type,
 }\r
 \r
 \r
-void cv::gpu::HOGDescriptor::computeGradient(const GpuMat& img, GpuMat& grad, GpuMat& qangle)\r
+void cv::gpu::HOGDescriptor::computeGradient(const GpuMat& img, GpuMat& _grad, GpuMat& _qangle)\r
 {\r
     CV_Assert(img.type() == CV_8UC1 || img.type() == CV_8UC4);\r
        \r
     //   grad.create(img.size(), CV_32FC2);\r
-       grad = getBuffer(img.size(), CV_32FC2, grad_buf);    \r
+    _grad = getBuffer(img.size(), CV_32FC2, grad_buf);\r
 \r
     //   qangle.create(img.size(), CV_8UC2);\r
-       qangle = getBuffer(img.size(), CV_8UC2, qangle_buf);  \r
+    _qangle = getBuffer(img.size(), CV_8UC2, qangle_buf);\r
 \r
     float angleScale = (float)(nbins / CV_PI);\r
     switch (img.type()) \r
        {\r
         case CV_8UC1:\r
-            hog::compute_gradients_8UC1(nbins, img.rows, img.cols, img, angleScale, grad, qangle, gamma_correction);\r
+            hog::compute_gradients_8UC1(nbins, img.rows, img.cols, img, angleScale, _grad, _qangle, gamma_correction);\r
             break;\r
         case CV_8UC4:\r
-            hog::compute_gradients_8UC4(nbins, img.rows, img.cols, img, angleScale, grad, qangle, gamma_correction);\r
+            hog::compute_gradients_8UC4(nbins, img.rows, img.cols, img, angleScale, _grad, _qangle, gamma_correction);\r
             break;\r
     }\r
 }\r
@@ -323,8 +323,8 @@ void cv::gpu::HOGDescriptor::detectMultiScale(const GpuMat& img, vector<Rect>& f
 \r
     for (size_t i = 0; i < level_scale.size(); i++)\r
     {\r
-        double scale = level_scale[i];\r
-        Size sz(cvRound(img.cols / scale), cvRound(img.rows / scale));\r
+        double _scale = level_scale[i];\r
+        Size sz(cvRound(img.cols / _scale), cvRound(img.rows / _scale));\r
         GpuMat smaller_img;\r
 \r
         if (sz == img.size())\r

diff --git a/modules/gpu/src/mssegmentation.cpp b/modules/gpu/src/mssegmentation.cpp
index b5b7bac..1b9e481 100644 (file)
--- a/modules/gpu/src/mssegmentation.cpp
+++ b/modules/gpu/src/mssegmentation.cpp
@@ -78,7 +78,7 @@ template <typename T>
 struct GraphEdge\r
 {\r
     GraphEdge() {}\r
-    GraphEdge(int to, int next, const T& val) : to(to), next(next), val(val) {}\r
+    GraphEdge(int to_, int next_, const T& val_) : to(to_), next(next_), val(val_) {}\r
     int to;\r
     int next;\r
     T val;\r
@@ -110,7 +110,7 @@ private:
 struct SegmLinkVal\r
 {\r
     SegmLinkVal() {}\r
-    SegmLinkVal(int dr, int dsp) : dr(dr), dsp(dsp) {}\r
+    SegmLinkVal(int dr_, int dsp_) : dr(dr_), dsp(dsp_) {}\r
     bool operator <(const SegmLinkVal& other) const\r
     {\r
         return dr + dsp < other.dr + other.dsp;\r
@@ -123,8 +123,8 @@ struct SegmLinkVal
 struct SegmLink\r
 {\r
     SegmLink() {}\r
-    SegmLink(int from, int to, const SegmLinkVal& val)\r
-        : from(from), to(to), val(val) {}\r
+    SegmLink(int from_, int to_, const SegmLinkVal& val_)\r
+        : from(from_), to(to_), val(val_) {}\r
     bool operator <(const SegmLink& other) const\r
     {\r
         return val < other.val;\r
@@ -182,10 +182,10 @@ inline int DjSets::merge(int set1, int set2)
 \r
 \r
 template <typename T>\r
-Graph<T>::Graph(int numv, int nume_max) : start(numv, -1), edges(nume_max)\r
+Graph<T>::Graph(int numv_, int nume_max_) : start(numv_, -1), edges(nume_max_)\r
 {\r
-    this->numv = numv;\r
-    this->nume_max = nume_max;\r
+    this->numv = numv_;\r
+    this->nume_max = nume_max_;\r
     nume = 0;\r
 }\r
 \r

diff --git a/modules/gpu/src/stereocsbp.cpp b/modules/gpu/src/stereocsbp.cpp
index 02af8fd..3c5842e 100644 (file)
--- a/modules/gpu/src/stereocsbp.cpp
+++ b/modules/gpu/src/stereocsbp.cpp
@@ -171,8 +171,8 @@ static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat& mbuf, GpuMat& te
     {\r
         cols_pyr[i]     = cols_pyr[i-1] / 2;\r
         rows_pyr[i]     = rows_pyr[i-1] / 2;\r
-        nr_plane_pyr[i] = nr_plane_pyr[i-1] * 2;        \r
-    }          \r
+        nr_plane_pyr[i] = nr_plane_pyr[i-1] * 2;\r
+    }\r
 \r
 \r
        GpuMat u[2], d[2], l[2], r[2], disp_selected_pyr[2], data_cost, data_cost_selected;\r
@@ -193,14 +193,14 @@ static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat& mbuf, GpuMat& te
                GpuMat sub2 = sub1.rowRange((k+0)*sub1.rows/2, (k+1)*sub1.rows/2);\r
 \r
                GpuMat *buf_ptrs[] = { &u[k], &d[k], &l[k], &r[k], &disp_selected_pyr[k] };                                             \r
-               for(int r = 0; r < 5; ++r)              \r
+        for(int _r = 0; _r < 5; ++_r)\r
                {\r
-                       *buf_ptrs[r] = sub2.rowRange(r * sub2.rows/5, (r+1) * sub2.rows/5);\r
-                       assert(buf_ptrs[r]->cols == cols && buf_ptrs[r]->rows == rows * rthis.nr_plane);\r
+            *buf_ptrs[_r] = sub2.rowRange(_r * sub2.rows/5, (_r+1) * sub2.rows/5);\r
+            assert(buf_ptrs[_r]->cols == cols && buf_ptrs[_r]->rows == rows * rthis.nr_plane);\r
                }\r
        };\r
              \r
-    size_t elem_step = mbuf.step / sizeof(T);  \r
+    size_t elem_step = mbuf.step / sizeof(T);\r
 \r
        Size temp_size = data_cost.size();\r
        if ((size_t)temp_size.area() < elem_step * rows_pyr[levels - 1] * rthis.ndisp)  \r

diff --git a/modules/gpu/src/video_reader.cpp b/modules/gpu/src/video_reader.cpp
index 795509d..2ebc608 100644 (file)
--- a/modules/gpu/src/video_reader.cpp
+++ b/modules/gpu/src/video_reader.cpp
@@ -391,11 +391,11 @@ void cv::gpu::VideoReader_GPU::dumpFormat(std::ostream& st)
         "YUV444"\r
     };\r
 \r
-    FormatInfo format = this->format();\r
+    FormatInfo _format = this->format();\r
 \r
-    st << "Frame Size    : " << format.width << "x" << format.height << std::endl;\r
-    st << "Codec         : " << (format.codec <= H264_MVC ? codecs[format.codec] : "Uncompressed YUV") << std::endl;\r
-    st << "Chroma Format : " << chromas[format.chromaFormat] << std::endl;\r
+    st << "Frame Size    : " << _format.width << "x" << _format.height << std::endl;\r
+    st << "Codec         : " << (_format.codec <= H264_MVC ? codecs[_format.codec] : "Uncompressed YUV") << std::endl;\r
+    st << "Chroma Format : " << chromas[_format.chromaFormat] << std::endl;\r
 }\r
 \r
 #endif // HAVE_CUDA\r