Merge remote-tracking branch 'origin/master' into merge-2.4

Conflicts:
	modules/ocl/src/arithm.cpp

modules/core/include/opencv2/core/cvdef.h

@@ -458,15 +458,8 @@ CV_INLINE int cvIsInf( double value )
 #      define CV_XADD(addr, delta) (int)__sync_fetch_and_add((unsigned*)(addr), (unsigned)(delta))
 #    endif
 #  endif
-#elif (defined WIN32 || defined _WIN32 || defined WINCE) && (!defined RC_INVOKED)
-#  if !defined(_M_AMD64) && !defined(_M_IA64) && !defined(_M_ARM)
-     CV_EXTERN_C __declspec(dllimport) long __stdcall InterlockedExchangeAdd(long volatile *Addend, long Value);
-#    define CV_XADD(addr, delta) (int)InterlockedExchangeAdd((long volatile*)addr, delta)
-#  else
-     CV_EXTERN_C long _InterlockedExchangeAdd (long volatile *Addend, long Value);
-#    pragma intrinsic(_InterlockedExchangeAdd)
-#    define CV_XADD(addr, delta) (int)_InterlockedExchangeAdd((long volatile*)addr, delta)
-#  endif
+#elif defined _MSC_VER && !defined RC_INVOKED
+#  define CV_XADD(addr, delta) (int)_InterlockedExchangeAdd((long volatile*)addr, delta)
 #else
    CV_INLINE CV_XADD(int* addr, int delta) { int tmp = *addr; *addr += delta; return tmp; }
 #endif

modules/core/include/opencv2/core/cvstd.hpp

@@ -364,6 +364,10 @@ public:
     String& operator=(const char* s);
     String& operator=(char c);
 
+    String& operator+=(const String& str);
+    String& operator+=(const char* s);
+    String& operator+=(char c);
+
     size_t size() const;
     size_t length() const;
 
@@ -416,6 +420,7 @@ public:
     String(const std::string& str);
     String(const std::string& str, size_t pos, size_t len = npos);
     String& operator=(const std::string& str);
+    String& operator+=(const std::string& str);
     operator std::string() const;
 
     friend String operator+ (const String& lhs, const std::string& rhs);
@@ -544,6 +549,27 @@ String& String::operator=(char c)
     return *this;
 }
 
+inline
+String& String::operator+=(const String& str)
+{
+    *this = *this + str;
+    return *this;
+}
+
+inline
+String& String::operator+=(const char* s)
+{
+    *this = *this + s;
+    return *this;
+}
+
+inline
+String& String::operator+=(char c)
+{
+    *this = *this + c;
+    return *this;
+}
+
 inline
 size_t String::size() const
 {

modules/core/include/opencv2/core/cvstd.inl.hpp

@@ -103,6 +103,13 @@ String& String::operator = (const std::string& str)
     return *this;
 }
 
+inline
+String& String::operator += (const std::string& str)
+{
+    *this = *this + str;
+    return *this;
+}
+
 inline
 String::operator std::string() const
 {

modules/core/src/system.cpp

@@ -87,10 +87,41 @@
 
 #ifdef HAVE_WINRT
 #include <wrl/client.h>
+#ifndef __cplusplus_winrt
+#include <windows.storage.h>
+#pragma comment(lib, "runtimeobject.lib")
+#endif
 
 std::wstring GetTempPathWinRT()
 {
+#ifdef __cplusplus_winrt
     return std::wstring(Windows::Storage::ApplicationData::Current->TemporaryFolder->Path->Data());
+#else
+    Microsoft::WRL::ComPtr<ABI::Windows::Storage::IApplicationDataStatics> appdataFactory;
+    Microsoft::WRL::ComPtr<ABI::Windows::Storage::IApplicationData> appdataRef;
+    Microsoft::WRL::ComPtr<ABI::Windows::Storage::IStorageFolder> storagefolderRef;
+    Microsoft::WRL::ComPtr<ABI::Windows::Storage::IStorageItem> storageitemRef;
+    HSTRING str;
+    HSTRING_HEADER hstrHead;
+    std::wstring wstr;
+    if (FAILED(WindowsCreateStringReference(RuntimeClass_Windows_Storage_ApplicationData,
+                                            (UINT32)wcslen(RuntimeClass_Windows_Storage_ApplicationData), &hstrHead, &str)))
+        return wstr;
+    if (FAILED(RoGetActivationFactory(str, IID_PPV_ARGS(appdataFactory.ReleaseAndGetAddressOf()))))
+        return wstr;
+    if (FAILED(appdataFactory->get_Current(appdataRef.ReleaseAndGetAddressOf())))
+        return wstr;
+    if (FAILED(appdataRef->get_TemporaryFolder(storagefolderRef.ReleaseAndGetAddressOf())))
+        return wstr;
+    if (FAILED(storagefolderRef.As(&storageitemRef)))
+        return wstr;
+    str = NULL;
+    if (FAILED(storageitemRef->get_Path(&str)))
+        return wstr;
+    wstr = WindowsGetStringRawBuffer(str, NULL);
+    WindowsDeleteString(str);
+    return wstr;
+#endif
 }
 
 std::wstring GetTempFileNameWinRT(std::wstring prefix)

modules/imgproc/src/connectedcomponents.cpp

@@ -195,11 +195,9 @@ namespace cv{
         CV_Assert(connectivity == 8 || connectivity == 4);
         const int rows = L.rows;
         const int cols = L.cols;
-        size_t Plength = (size_t(rows + 3 - 1)/3) * (size_t(cols + 3 - 1)/3);
-        if(connectivity == 4){
-            Plength = 4 * Plength;//a quick and dirty upper bound, an exact answer exists if you want to find it
-            //the 4 comes from the fact that a 3x3 block can never have more than 4 unique labels
-        }
+        //A quick and dirty upper bound for the maximimum number of labels.  The 4 comes from
+        //the fact that a 3x3 block can never have more than 4 unique labels for both 4 & 8-way
+        const size_t Plength = 4 * (size_t(rows + 3 - 1)/3) * (size_t(cols + 3 - 1)/3);
         LabelT *P = (LabelT *) fastMalloc(sizeof(LabelT) * Plength);
         P[0] = 0;
         LabelT lunique = 1;

modules/ocl/src/arithm.cpp

@@ -518,7 +518,7 @@ static void arithmetic_minMax_run(const oclMat &src, const oclMat & mask, cl_mem
         args.push_back( std::make_pair( sizeof(cl_int) , (void *)&minvalid_cols ));
         args.push_back( std::make_pair( sizeof(cl_int) , (void *)&moffset ));
 
-        kernelName = kernelName + "_mask";
+        kernelName += "_mask";
     }
 
     size_t globalThreads[3] = {groupnum * 256, 1, 1};
@@ -658,8 +658,8 @@ static void arithm_absdiff_nonsaturate_run(const oclMat & src1, const oclMat & s
         args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2step1 ));
         args.push_back( std::make_pair( sizeof(cl_int), (void *)&src2offset1 ));
 
-        kernelName = kernelName + "_binary";
-        buildOptions = buildOptions + " -D BINARY";
+        kernelName += "_binary";
+        buildOptions += " -D BINARY";
     }
 
     args.push_back( std::make_pair( sizeof(cl_mem), (void *)&diff.data ));

modules/ocl/src/cl_operations.cpp

@@ -379,7 +379,7 @@ cl_kernel openCLGetKernelFromSource(Context *ctx, const cv::ocl::ProgramEntry* s
         idxStr << "_C" << channels;
     if(depth != -1)
         idxStr << "_D" << depth;
-    kernelName = kernelName + idxStr.str();
+    kernelName += idxStr.str();
 
     std::string fixedOptions = removeDuplicatedWhiteSpaces(build_options);
     cl_kernel kernel = openCLGetKernelFromSource(ctx, source, kernelName, fixedOptions.c_str());
@@ -497,7 +497,7 @@ void openCLExecuteKernelInterop(Context *ctx, const cv::ocl::ProgramSource& sour
         idxStr << "_C" << channels;
     if(depth != -1)
         idxStr << "_D" << depth;
-    kernelName = kernelName + idxStr.str();
+    kernelName += idxStr.str();
 
     std::string name = std::string("custom_") + source.name;
     ProgramEntry program = { name.c_str(), source.programStr, source.programHash };

modules/ocl/src/cl_programcache.cpp

@@ -489,11 +489,11 @@ cl_program ProgramCache::getProgram(const Context *ctx, const cv::ocl::ProgramEn
 
     String all_build_options;
     if (!ctx->getDeviceInfo().compilationExtraOptions.empty())
-        all_build_options = all_build_options + ctx->getDeviceInfo().compilationExtraOptions;
+        all_build_options += ctx->getDeviceInfo().compilationExtraOptions;
     if (build_options != NULL)
     {
-        all_build_options = all_build_options + " ";
-        all_build_options = all_build_options + build_options;
+        all_build_options += " ";
+        all_build_options += build_options;
     }
     const DeviceInfo& devInfo = ctx->getDeviceInfo();
     String filename = binpath + (source->name ? source->name : "NULL") + "_" + devInfo.platform->platformName + "_" + devInfo.deviceName + ".clb";

modules/ocl/src/haar.cpp

@@ -959,15 +959,15 @@ void OclCascadeClassifier::detectMultiScale(oclMat &gimg, CV_OUT std::vector<cv:
 
             //form build options for kernel
             String  options = "-D PACKED_CLASSIFIER";
-            options = options + format(" -D NODE_SIZE=%d",NODE_SIZE);
-            options = options + format(" -D WND_SIZE_X=%d",cascade->orig_window_size.width);
-            options = options + format(" -D WND_SIZE_Y=%d",cascade->orig_window_size.height);
-            options = options + format(" -D STUMP_BASED=%d",gcascade->is_stump_based);
-            options = options + format(" -D LSx=%d",localThreads[0]);
-            options = options + format(" -D LSy=%d",localThreads[1]);
-            options = options + format(" -D SPLITNODE=%d",splitnode);
-            options = options + format(" -D SPLITSTAGE=%d",splitstage);
-            options = options + format(" -D OUTPUTSZ=%d",outputsz);
+            options += format(" -D NODE_SIZE=%d",NODE_SIZE);
+            options += format(" -D WND_SIZE_X=%d",cascade->orig_window_size.width);
+            options += format(" -D WND_SIZE_Y=%d",cascade->orig_window_size.height);
+            options += format(" -D STUMP_BASED=%d",gcascade->is_stump_based);
+            options += format(" -D LSx=%d",localThreads[0]);
+            options += format(" -D LSy=%d",localThreads[1]);
+            options += format(" -D SPLITNODE=%d",splitnode);
+            options += format(" -D SPLITSTAGE=%d",splitstage);
+            options += format(" -D OUTPUTSZ=%d",outputsz);
 
             // init candiate global count by 0
             int pattern = 0;

modules/ocl/src/imgproc.cpp

@@ -217,15 +217,15 @@ namespace cv
 
             String kernelName = "remap";
             if (map1.type() == CV_32FC2 && map2.empty())
-                kernelName = kernelName + "_32FC2";
+                kernelName += "_32FC2";
             else if (map1.type() == CV_16SC2)
             {
-                kernelName = kernelName + "_16SC2";
+                kernelName += "_16SC2";
                 if (!map2.empty())
-                    kernelName = kernelName + "_16UC1";
+                    kernelName += "_16UC1";
             }
             else if (map1.type() == CV_32FC1 && map2.type() == CV_32FC1)
-                kernelName = kernelName + "_2_32FC1";
+                kernelName += "_2_32FC1";
             else
                 CV_Error(Error::StsBadArg, "Unsupported map types");
 
@@ -1072,16 +1072,16 @@ namespace cv
                     switch(borderType)
                     {
                     case cv::BORDER_REPLICATE:
-                        option = option + " -D BORDER_REPLICATE";
+                        option += " -D BORDER_REPLICATE";
                         break;
                     case cv::BORDER_REFLECT:
-                        option = option + " -D BORDER_REFLECT";
+                        option += " -D BORDER_REFLECT";
                         break;
                     case cv::BORDER_REFLECT101:
-                        option = option + " -D BORDER_REFLECT101";
+                        option += " -D BORDER_REFLECT101";
                         break;
                     case cv::BORDER_WRAP:
-                        option = option + " -D BORDER_WRAP";
+                        option += " -D BORDER_WRAP";
                         break;
                     }
                     openCLExecuteKernel(src.clCxt, &imgproc_sobel3, "sobel3", gt2, lt2, args, -1, -1, option.c_str() );

modules/ocl/src/mcwutil.cpp

@@ -64,7 +64,7 @@ namespace cv
                 idxStr << "_C" << channels;
             if(depth != -1)
                 idxStr << "_D" << depth;
-            kernelName = kernelName + idxStr.str().c_str();
+            kernelName += idxStr.str().c_str();
 
             cl_kernel kernel;
             kernel = openCLGetKernelFromSource(clCxt, source, kernelName, build_options);

modules/ocl/src/split_merge.cpp

@@ -234,13 +234,13 @@ namespace cv
                                    (int)VEC_SIZE, depth, channels);
 
                 if (dst0Aligned)
-                    build_options = build_options + " -D DST0_ALIGNED";
+                    build_options += " -D DST0_ALIGNED";
                 if (dst1Aligned)
-                    build_options = build_options + " -D DST1_ALIGNED";
+                    build_options += " -D DST1_ALIGNED";
                 if (dst2Aligned)
-                    build_options = build_options + " -D DST2_ALIGNED";
+                    build_options += " -D DST2_ALIGNED";
                 if (dst3Aligned)
-                    build_options = build_options + " -D DST3_ALIGNED";
+                    build_options += " -D DST3_ALIGNED";
 
                 const DeviceInfo& devInfo = clCtx->getDeviceInfo();
 
@@ -251,7 +251,7 @@ namespace cv
                         && (devInfo.deviceVersion.find("Build 56860") != std::string::npos
                             || devInfo.deviceVersion.find("Build 76921") != std::string::npos
                             || devInfo.deviceVersion.find("Build 78712") != std::string::npos))
-                    build_options = build_options + " -D BYPASS_VSTORE=true";
+                    build_options += " -D BYPASS_VSTORE=true";
 
                 size_t globalThreads[3] = { divUp(src.cols, VEC_SIZE), src.rows, 1 };
                 openCLExecuteKernel(clCtx, &split_mat, kernelName, globalThreads, NULL, args, -1, -1, build_options.c_str());