From 14bb4cbe1e5159ea93f955b49473418bc5fb405b Mon Sep 17 00:00:00 2001 From: Andrey Kamaev Date: Wed, 20 Mar 2013 13:00:04 +0400 Subject: [PATCH 01/12] Add cv::String class --- cmake/OpenCVModule.cmake | 2 + modules/core/include/opencv2/core.hpp | 14 +- modules/core/include/opencv2/core/cvstd.hpp | 470 ++++++++++++++++++ .../core/include/opencv2/core/cvstd.inl.hpp | 131 +++++ .../core/include/opencv2/core/operations.hpp | 11 +- modules/core/include/opencv2/core/utility.hpp | 35 +- modules/core/src/stl.cpp | 69 +++ 7 files changed, 713 insertions(+), 19 deletions(-) create mode 100644 modules/core/include/opencv2/core/cvstd.hpp create mode 100644 modules/core/include/opencv2/core/cvstd.inl.hpp create mode 100644 modules/core/src/stl.cpp diff --git a/cmake/OpenCVModule.cmake b/cmake/OpenCVModule.cmake index 75f91a1a2..6ea7bafd1 100644 --- a/cmake/OpenCVModule.cmake +++ b/cmake/OpenCVModule.cmake @@ -507,6 +507,8 @@ macro(ocv_create_module) ) endif() + set_target_properties(${the_module} PROPERTIES COMPILE_DEFINITIONS OPENCV_NOSTL) + if(BUILD_SHARED_LIBS) if(MSVC) set_target_properties(${the_module} PROPERTIES DEFINE_SYMBOL CVAPI_EXPORTS) diff --git a/modules/core/include/opencv2/core.hpp b/modules/core/include/opencv2/core.hpp index 337ddb059..889ed2162 100644 --- a/modules/core/include/opencv2/core.hpp +++ b/modules/core/include/opencv2/core.hpp @@ -47,11 +47,12 @@ #define __OPENCV_CORE_HPP__ #include "opencv2/core/cvdef.h" - -#include "opencv2/core/types_c.h" #include "opencv2/core/version.hpp" +#include "opencv2/core/types_c.h" + #ifdef __cplusplus +#include "opencv2/core/cvstd.hpp" #ifndef SKIP_INCLUDES #include @@ -3939,7 +3940,10 @@ public: //! returns the node content as double operator double() const; //! returns the node content as text string + operator String() const; +#ifndef OPENCV_NOSTL operator std::string() const; +#endif //! returns pointer to the underlying file node CvFileNode* operator *(); @@ -4419,9 +4423,11 @@ template<> struct ParamType } //namespace cv -#endif // __cplusplus - #include "opencv2/core/operations.hpp" #include "opencv2/core/mat.hpp" +#include "opencv2/core/cvstd.inl.hpp" +#endif // __cplusplus + + #endif /*__OPENCV_CORE_HPP__*/ diff --git a/modules/core/include/opencv2/core/cvstd.hpp b/modules/core/include/opencv2/core/cvstd.hpp new file mode 100644 index 000000000..e5af0f234 --- /dev/null +++ b/modules/core/include/opencv2/core/cvstd.hpp @@ -0,0 +1,470 @@ +/*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) 2000-2008, Intel Corporation, all rights reserved. +// Copyright (C) 2009, Willow Garage Inc., all rights reserved. +// Copyright (C) 2013, OpenCV Foundation, 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 __OPENCV_CORE_CVSTD_HPP__ +#define __OPENCV_CORE_CVSTD_HPP__ + +#include +#include + +#include "opencv2/core/cvdef.h" + +#ifndef OPENCV_NOSTL +# include +#endif + +// import useful primitives from stl +#ifndef OPENCV_NOSTL_TRANSITIONAL +# include +# include +# include + +namespace cv +{ + using std::min; + using std::max; + using std::abs; + using std::swap; +} + +#else +namespace cv +{ + template inline T min(T a, T b) { return a < b ? a : b; } + template inline T max(T a, T b) { return a > b ? a : b; } + template inline T abs(T a) { return a < 0 ? -a : a; } + template inline void swap(T& a, T& b) { T tmp = a; a = b; b = tmp; } + + template<> inline uchar abs(uchar a) { return a; } + template<> inline ushort abs(ushort a) { return a; } + template<> inline uint abs(uint a) { return a; } + template<> inline uint64 abs(uint64 a) { return a; } +} +#endif + +namespace cv { + +class CV_EXPORTS FileNode; //for string constructor from FileNode + +class CV_EXPORTS String +{ +public: + typedef char value_type; + typedef char& reference; + typedef const char& const_reference; + typedef char* pointer; + typedef const char* const_pointer; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + + typedef char* iterator; + typedef const char* const_iterator; + + static const size_t npos = size_t(-1); + + explicit String() : cstr_(0), len_(0) {} + + String(const String& str) : cstr_(str.cstr_), len_(str.len_) + { + if (cstr_) CV_XADD(((int*)cstr_)-1, 1); + } + + String(const String& str, size_t pos, size_t len = npos) : cstr_(0), len_(0) + { + pos = min(pos, str.len_); + len = min(str.len_ - pos, len); + if (!len) return; + if (len == str.len_) + { + CV_XADD(((int*)str.cstr_)-1, 1); + cstr_ = str.cstr_; + len_ = str.len_; + return; + } + memcpy(allocate(len), str.cstr_ + pos, len); + } + + String(const char* s): cstr_(0), len_(0) + { + if (!s) return; + size_t len = strlen(s); + memcpy(allocate(len), s, len); + } + + String(const char* s, size_t n): cstr_(0), len_(0) + { + if (!n) return; + memcpy(allocate(n), s, n); + } + + String(size_t n, char c): cstr_(0), len_(0) + { + memset(allocate(n), c, n); + } + + String(const char* first, const char* last): cstr_(0), len_(0) + { + size_t len = (size_t)(last - first); + memcpy(allocate(len), first, len); + } + + template + String(Iterator first, Iterator last): cstr_(0), len_(0) + { + size_t len = (size_t)(last - first); + char* str = allocate(len); + while (first != last) + { + *str++ = *first; + ++first; + } + } + + ~String() { deallocate(); } + + String& operator=(const String& str) + { + deallocate(); + if (str.cstr_) CV_XADD(((int*)str.cstr_)-1, 1); + cstr_ = str.cstr_; + len_ = str.len_; + return *this; + } + + String& operator=(const char* s) + { + deallocate(); + if (!s) return *this; + size_t len = strlen(s); + memcpy(allocate(len), s, len); + return *this; + } + + String& operator=(char c) + { + deallocate(); + allocate(1)[0] = c; + return *this; + } + + size_t size() const { return len_; } + size_t length() const { return len_; } + + char operator[](size_t idx) const { return cstr_[idx]; } + char operator[](int idx) const { return cstr_[idx]; } + + const char* begin() const { return cstr_; } + const char* end() const { return len_ ? cstr_ + 1 : 0; } + + bool empty() const { return len_ == 0; } + + const char* c_str() const { return cstr_ ? cstr_ : ""; } + + void swap(String& str) + { + cv::swap(cstr_, str.cstr_); + cv::swap(len_, str.len_); + } + + void clear() { deallocate(); } + + int compare(const char* s) const + { + if (cstr_ == s) return 0; + + return strcmp(c_str(), s); + } + + int compare(const String& str) const + { + if (cstr_ == str.cstr_) return 0; + + return strcmp(c_str(), str.c_str()); + } + + String substr(size_t pos = 0, size_t len = npos) const + { + return String(*this, pos, len); + } + + size_t find(const char* s, size_t pos, size_t n) const + { + if (n == 0 || pos + n > len_) return npos; + const char* lmax = cstr_ + len_ - n; + for (const char* i = cstr_ + pos; i <= lmax; ++i) + { + size_t j = 0; + while (j < n && s[j] == i[j]) ++j; + if (j == n) return (size_t)(i - cstr_); + } + return npos; + } + + size_t find(char c, size_t pos = 0) const + { + return find(&c, pos, 1); + } + + size_t find(const String& str, size_t pos = 0) const + { + return find(str.c_str(), pos, str.len_); + } + + size_t find(const char* s, size_t pos = 0) const + { + if (pos >= len_ || !s[0]) return npos; + const char* lmax = cstr_ + len_; + for (const char* i = cstr_ + pos; i < lmax; ++i) + { + size_t j = 0; + while (s[j] && s[j] == i[j]) + { if(i + j >= lmax) return npos; + ++j; + } + if (!s[j]) return (size_t)(i - cstr_); + } + return npos; + } + + size_t rfind(const char* s, size_t pos, size_t n) const + { + if (n > len_) return npos; + if (pos > len_ - n) pos = len_ - n; + for (const char* i = cstr_ + pos; i >= cstr_; --i) + { + size_t j = 0; + while (j < n && s[j] == i[j]) ++j; + if (j == n) return (size_t)(i - cstr_); + } + return npos; + } + + size_t rfind(char c, size_t pos = npos) const + { + return rfind(&c, pos, 1); + } + + size_t rfind(const String& str, size_t pos = npos) const + { + return rfind(str.c_str(), pos, str.len_); + } + + size_t rfind(const char* s, size_t pos = npos) const + { + return rfind(s, pos, strlen(s)); + } + + size_t find_first_of(const char* s, size_t pos, size_t n) const + { + if (n == 0 || pos + n > len_) return npos; + const char* lmax = cstr_ + len_; + for (const char* i = cstr_ + pos; i < lmax; ++i) + { + for (size_t j = 0; j < n; ++j) + if (s[j] == *i) + return (size_t)(i - cstr_); + } + return npos; + } + + size_t find_first_of(char c, size_t pos = 0) const + { + return find_first_of(&c, pos, 1); + } + + size_t find_first_of(const String& str, size_t pos = 0) const + { + return find_first_of(str.c_str(), pos, str.len_); + } + + size_t find_first_of(const char* s, size_t pos = 0) const + { + if (pos >= len_ || !s[0]) return npos; + const char* lmax = cstr_ + len_; + for (const char* i = cstr_ + pos; i < lmax; ++i) + { + for (size_t j = 0; s[j]; ++j) + if (s[j] == *i) + return (size_t)(i - cstr_); + } + return npos; + } + + size_t find_last_of(const char* s, size_t pos, size_t n) const + { + if (pos >= len_) pos = len_ - 1; + for (const char* i = cstr_ + pos; i >= cstr_; --i) + { + for (size_t j = 0; j < n; ++j) + if (s[j] == *i) + return (size_t)(i - cstr_); + } + return npos; + } + + size_t find_last_of(char c, size_t pos = npos) const + { + return find_last_of(&c, pos, 1); + } + + size_t find_last_of(const String& str, size_t pos = npos) const + { + return find_last_of(str.c_str(), pos, str.len_); + } + + size_t find_last_of(const char* s, size_t pos = npos) const + { + if (pos >= len_) pos = len_ - 1; + for (const char* i = cstr_ + pos; i >= cstr_; --i) + { + for (size_t j = 0; s[j]; ++j) + if (s[j] == *i) + return (size_t)(i - cstr_); + } + return npos; + } + + friend String operator+ (const String& lhs, const String& rhs); + friend String operator+ (const String& lhs, const char* rhs); + friend String operator+ (const char* lhs, const String& rhs); + friend String operator+ (const String& lhs, char rhs); + friend String operator+ (char lhs, const String& rhs); + +#ifndef OPENCV_NOSTL + String(const std::string& str); + String(const std::string& str, size_t pos, size_t len = npos); + String& operator=(const std::string& str); + operator std::string() const; + + friend String operator+ (const String& lhs, const std::string& rhs); + friend String operator+ (const std::string& lhs, const String& rhs); +#endif + + explicit String(const FileNode& fn); + +private: + char* cstr_; + size_t len_; + + char* allocate(size_t len); // len_ without trailing 0 + void deallocate(); +}; + +inline String operator+ (const String& lhs, const String& rhs) +{ + String s; + s.allocate(lhs.len_ + rhs.len_); + memcpy(s.cstr_, lhs.cstr_, lhs.len_); + memcpy(s.cstr_ + lhs.len_, rhs.cstr_, rhs.len_); + return s; +} + +inline String operator+ (const String& lhs, const char* rhs) +{ + String s; + size_t rhslen = strlen(rhs); + s.allocate(lhs.len_ + rhslen); + memcpy(s.cstr_, lhs.cstr_, lhs.len_); + memcpy(s.cstr_ + lhs.len_, rhs, rhslen); + return s; +} + +inline String operator+ (const char* lhs, const String& rhs) +{ + String s; + size_t lhslen = strlen(lhs); + s.allocate(lhslen + rhs.len_); + memcpy(s.cstr_, lhs, lhslen); + memcpy(s.cstr_ + lhslen, rhs.cstr_, rhs.len_); + return s; +} + +inline String operator+ (const String& lhs, char rhs) +{ + String s; + s.allocate(lhs.len_ + 1); + memcpy(s.cstr_, lhs.cstr_, lhs.len_); + s.cstr_[lhs.len_] = rhs; + return s; +} + +inline String operator+ (char lhs, const String& rhs) +{ + String s; + s.allocate(rhs.len_ + 1); + s.cstr_[0] = lhs; + memcpy(s.cstr_ + 1, rhs.cstr_, rhs.len_); + return s; +} + +inline bool operator== (const String& lhs, const String& rhs) { return 0 == lhs.compare(rhs); } +inline bool operator== (const char* lhs, const String& rhs) { return 0 == rhs.compare(lhs); } +inline bool operator== (const String& lhs, const char* rhs) { return 0 == lhs.compare(rhs); } +inline bool operator!= (const String& lhs, const String& rhs) { return 0 != lhs.compare(rhs); } +inline bool operator!= (const char* lhs, const String& rhs) { return 0 != rhs.compare(lhs); } +inline bool operator!= (const String& lhs, const char* rhs) { return 0 != lhs.compare(rhs); } +inline bool operator< (const String& lhs, const String& rhs) { return lhs.compare(rhs) < 0; } +inline bool operator< (const char* lhs, const String& rhs) { return rhs.compare(lhs) > 0; } +inline bool operator< (const String& lhs, const char* rhs) { return lhs.compare(rhs) < 0; } +inline bool operator<= (const String& lhs, const String& rhs) { return lhs.compare(rhs) <= 0; } +inline bool operator<= (const char* lhs, const String& rhs) { return rhs.compare(lhs) >= 0; } +inline bool operator<= (const String& lhs, const char* rhs) { return lhs.compare(rhs) <= 0; } +inline bool operator> (const String& lhs, const String& rhs) { return lhs.compare(rhs) > 0; } +inline bool operator> (const char* lhs, const String& rhs) { return rhs.compare(lhs) < 0; } +inline bool operator> (const String& lhs, const char* rhs) { return lhs.compare(rhs) > 0; } +inline bool operator>= (const String& lhs, const String& rhs) { return lhs.compare(rhs) >= 0; } +inline bool operator>= (const char* lhs, const String& rhs) { return rhs.compare(lhs) <= 0; } +inline bool operator>= (const String& lhs, const char* rhs) { return lhs.compare(rhs) >= 0; } + +} // cv + +#ifndef OPENCV_NOSTL_TRANSITIONAL +namespace std +#else +namespace cv +#endif +{ + template<> inline void swap(cv::String& a, cv::String& b) { a.swap(b); } +} + +#endif //__OPENCV_CORE_CVSTD_HPP__ diff --git a/modules/core/include/opencv2/core/cvstd.inl.hpp b/modules/core/include/opencv2/core/cvstd.inl.hpp new file mode 100644 index 000000000..10b2fb3d7 --- /dev/null +++ b/modules/core/include/opencv2/core/cvstd.inl.hpp @@ -0,0 +1,131 @@ +/*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) 2000-2008, Intel Corporation, all rights reserved. +// Copyright (C) 2009, Willow Garage Inc., all rights reserved. +// Copyright (C) 2013, OpenCV Foundation, 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 __OPENCV_CORE_CVSTDINL_HPP__ +#define __OPENCV_CORE_CVSTDINL_HPP__ + +#ifndef OPENCV_NOSTL +# include +#endif + +namespace cv +{ +#ifndef OPENCV_NOSTL + +inline String::String(const std::string& str) : cstr_(0), len_(0) +{ + if (!str.empty()) + { + size_t len = str.size(); + memcpy(allocate(len), str.c_str(), len); + } +} + +inline String::String(const std::string& str, size_t pos, size_t len) : cstr_(0), len_(0) +{ + size_t strlen = str.size(); + pos = max(pos, strlen); + len = min(strlen - pos, len); + if (!len) return; + memcpy(allocate(len), str.c_str() + pos, len); +} + +inline String& String::operator=(const std::string& str) +{ + deallocate(); + if (!str.empty()) + { + size_t len = str.size(); + memcpy(allocate(len), str.c_str(), len); + } + return *this; +} + +inline String::operator std::string() const +{ + return std::string(cstr_, len_); +} + +inline String operator+ (const String& lhs, const std::string& rhs) +{ + String s; + size_t rhslen = rhs.size(); + s.allocate(lhs.len_ + rhslen); + memcpy(s.cstr_, lhs.cstr_, lhs.len_); + memcpy(s.cstr_ + lhs.len_, rhs.c_str(), rhslen); + return s; +} + +inline String operator+ (const std::string& lhs, const String& rhs) +{ + String s; + size_t lhslen = lhs.size(); + s.allocate(lhslen + rhs.len_); + memcpy(s.cstr_, lhs.c_str(), lhslen); + memcpy(s.cstr_ + lhslen, rhs.cstr_, rhs.len_); + return s; +} + +inline std::ostream& operator << (std::ostream& os, const String& str) +{ + return os << str.c_str(); +} + +inline FileNode::operator std::string() const +{ + cv::String value; + read(*this, value, value); + return value; +} + +template<> inline void operator >> (const FileNode& n, std::string& value) +{ + cv::String val; + read(n, val, val); + value = val; +} + +#endif // OPENCV_NOSTL +} // cv + +#endif // __OPENCV_CORE_CVSTDINL_HPP__ \ No newline at end of file diff --git a/modules/core/include/opencv2/core/operations.hpp b/modules/core/include/opencv2/core/operations.hpp index dd09f41aa..44eea1462 100644 --- a/modules/core/include/opencv2/core/operations.hpp +++ b/modules/core/include/opencv2/core/operations.hpp @@ -2902,9 +2902,9 @@ static inline void read(const FileNode& node, double& value, double default_valu CV_NODE_IS_REAL(node.node->tag) ? node.node->data.f : 1e300; } -static inline void read(const FileNode& node, std::string& value, const std::string& default_value) +static inline void read(const FileNode& node, cv::String& value, const cv::String& default_value) { - value = !node.node ? default_value : CV_NODE_IS_STRING(node.node->tag) ? std::string(node.node->data.str.ptr) : std::string(""); + value = !node.node ? default_value : CV_NODE_IS_STRING(node.node->tag) ? cv::String(node.node->data.str.ptr) : cv::String(); } CV_EXPORTS_W void read(const FileNode& node, Mat& mat, const Mat& default_mat=Mat() ); @@ -2935,7 +2935,12 @@ inline FileNode::operator std::string() const return value; } -inline void FileNode::readRaw( const std::string& fmt, uchar* vec, size_t len ) const +inline String::String(const FileNode& fn): cstr_(0), len_(0) +{ + read(fn, *this, *this); +} + +inline void FileNode::readRaw( const cv::String& fmt, uchar* vec, size_t len ) const { begin().readRaw( fmt, vec, len ); } diff --git a/modules/core/include/opencv2/core/utility.hpp b/modules/core/include/opencv2/core/utility.hpp index 6a08c37af..7ec13bd75 100644 --- a/modules/core/include/opencv2/core/utility.hpp +++ b/modules/core/include/opencv2/core/utility.hpp @@ -143,14 +143,14 @@ typedef int (CV_CDECL *ErrorCallback)( int status, const char* func_name, */ CV_EXPORTS ErrorCallback redirectError( ErrorCallback errCallback, void* userdata=0, void** prevUserdata=0); -CV_EXPORTS std::string format( const char* fmt, ... ); -CV_EXPORTS std::string tempfile( const char* suffix CV_DEFAULT(0)); -CV_EXPORTS void glob(std::string pattern, std::vector& result, bool recursive = false); +CV_EXPORTS cv::String format( const char* fmt, ... ); +CV_EXPORTS cv::String tempfile( const char* suffix CV_DEFAULT(0)); +CV_EXPORTS void glob(cv::String pattern, std::vector& result, bool recursive = false); CV_EXPORTS void setNumThreads(int nthreads); CV_EXPORTS int getNumThreads(); CV_EXPORTS int getThreadNum(); -CV_EXPORTS_W const std::string& getBuildInformation(); +CV_EXPORTS_W const cv::String& getBuildInformation(); //! Returns the number of ticks. @@ -297,19 +297,19 @@ protected: class CV_EXPORTS CommandLineParser { public: - CommandLineParser(int argc, const char* const argv[], const std::string& keys); + CommandLineParser(int argc, const char* const argv[], const cv::String& keys); CommandLineParser(const CommandLineParser& parser); CommandLineParser& operator = (const CommandLineParser& parser); - std::string getPathToApplication() const; + cv::String getPathToApplication() const; template - T get(const std::string& name, bool space_delete = true) const - { + T get(const cv::String& name, bool space_delete = true) const + { T val = T(); getByName(name, space_delete, ParamType::type, (void*)&val); return val; - } + } template T get(int index, bool space_delete = true) const @@ -319,17 +319,17 @@ class CV_EXPORTS CommandLineParser return val; } - bool has(const std::string& name) const; + bool has(const cv::String& name) const; bool check() const; - void about(const std::string& message); + void about(const cv::String& message); void printMessage() const; void printErrors() const; protected: - void getByName(const std::string& name, bool space_delete, int type, void* dst) const; + void getByName(const cv::String& name, bool space_delete, int type, void* dst) const; void getByIndex(int index, bool space_delete, int type, void* dst) const; struct Impl; @@ -454,6 +454,17 @@ static inline Mat cvarrToMatND(const CvArr* arr, bool copyData=false, int coiMod return cvarrToMat(arr, copyData, true, coiMode); } +#ifndef OPENCV_NOSTL +template<> inline std::string CommandLineParser::get(int index, bool space_delete) const +{ + return get(index, space_delete); +} +template<> inline std::string CommandLineParser::get(const cv::String& name, bool space_delete) const +{ + return get(name, space_delete); +} +#endif // OPENCV_NOSTL + } //namespace cv #endif //__OPENCV_CORE_UTILITY_H__ diff --git a/modules/core/src/stl.cpp b/modules/core/src/stl.cpp new file mode 100644 index 000000000..09ba66c21 --- /dev/null +++ b/modules/core/src/stl.cpp @@ -0,0 +1,69 @@ +/*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) 2000-2008, Intel Corporation, all rights reserved. +// Copyright (C) 2009, Willow Garage Inc., all rights reserved. +// Copyright (C) 2013, OpenCV Foundation, 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" + +char* cv::String::allocate(size_t len) +{ + size_t totalsize = alignSize(len + 1, (int)sizeof(int)); + int* data = (int*)cv::fastMalloc(totalsize + sizeof(int)); + data[0] = 1; + cstr_ = (char*)(data + 1); + len_ = len; + cstr_[len] = 0; + return cstr_; +} + + +void cv::String::deallocate() +{ + int* data = (int*)cstr_; + len_ = 0; + cstr_ = 0; + + if(data && 1 == CV_XADD(data-1, -1)) + { + cv::fastFree(data-1); + } +} \ No newline at end of file From 762aefd71b40e6f752279db534f0fc47ba54a80e Mon Sep 17 00:00:00 2001 From: Andrey Kamaev Date: Wed, 20 Mar 2013 17:53:13 +0400 Subject: [PATCH 02/12] Compile opencv_test_core with cv::String instead of std::string All tests passed! --- cmake/OpenCVModule.cmake | 5 +- cmake/OpenCVPCHSupport.cmake | 7 + modules/core/doc/command_line_parser.rst | 14 +- ...tility_and_system_functions_and_macros.rst | 2 +- modules/core/doc/xml_yaml_persistence.rst | 6 +- modules/core/include/opencv2/core.hpp | 160 +++++++------- modules/core/include/opencv2/core/gpumat.hpp | 4 +- .../core/include/opencv2/core/operations.hpp | 66 +++--- modules/core/src/algorithm.cpp | 204 +++++++++--------- modules/core/src/command_line_parser.cpp | 192 ++++++++--------- modules/core/src/drawing.cpp | 4 +- modules/core/src/gl_core_3_1.cpp | 8 +- modules/core/src/glob.cpp | 16 +- modules/core/src/gpumat.cpp | 6 +- modules/core/src/persistence.cpp | 62 +++--- modules/core/src/system.cpp | 22 +- modules/core/test/test_io.cpp | 6 +- .../features2d/include/opencv2/features2d.hpp | 16 +- modules/features2d/src/descriptors.cpp | 6 +- modules/features2d/src/detectors.cpp | 2 +- modules/features2d/src/dynamic.cpp | 2 +- modules/features2d/src/features2d_init.cpp | 2 +- modules/features2d/src/keypoint.cpp | 2 +- modules/features2d/src/matchers.cpp | 22 +- ...st_approximate_nearest_neighbor_search.rst | 4 +- modules/flann/include/opencv2/flann.hpp | 4 +- modules/flann/include/opencv2/flann/any.h | 5 + .../include/opencv2/flann/flann_base.hpp | 8 +- modules/flann/include/opencv2/flann/general.h | 10 +- modules/flann/include/opencv2/flann/hdf5.h | 6 +- .../flann/include/opencv2/flann/lsh_table.h | 4 +- .../flann/include/opencv2/flann/miniflann.hpp | 26 +-- modules/flann/include/opencv2/flann/params.h | 8 +- modules/flann/src/miniflann.cpp | 36 ++-- modules/highgui/include/opencv2/highgui.hpp | 56 ++--- modules/highgui/src/bitstrm.cpp | 4 +- modules/highgui/src/bitstrm.hpp | 4 +- modules/highgui/src/cap.cpp | 8 +- modules/highgui/src/cap_openni.cpp | 36 ++-- modules/highgui/src/cap_pvapi.cpp | 2 +- modules/highgui/src/grfmt_base.cpp | 14 +- modules/highgui/src/grfmt_base.hpp | 18 +- modules/highgui/src/grfmt_jpeg2000.cpp | 2 +- modules/highgui/src/grfmt_pxm.cpp | 2 +- modules/highgui/src/grfmt_pxm.hpp | 2 +- modules/highgui/src/grfmt_tiff.cpp | 2 +- modules/highgui/src/grfmt_tiff.hpp | 2 +- modules/highgui/src/grfmt_webp.cpp | 2 +- modules/highgui/src/grfmt_webp.hpp | 2 +- modules/highgui/src/loadsave.cpp | 28 +-- modules/highgui/src/window.cpp | 62 +++--- 51 files changed, 598 insertions(+), 595 deletions(-) diff --git a/cmake/OpenCVModule.cmake b/cmake/OpenCVModule.cmake index 6ea7bafd1..6edcba711 100644 --- a/cmake/OpenCVModule.cmake +++ b/cmake/OpenCVModule.cmake @@ -471,6 +471,9 @@ endmacro() # ocv_create_module(SKIP_LINK) macro(ocv_create_module) add_library(${the_module} ${OPENCV_MODULE_TYPE} ${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES}) + if(NOT the_module STREQUAL opencv_ts) + set_target_properties(${the_module} PROPERTIES COMPILE_DEFINITIONS OPENCV_NOSTL) + endif() if(NOT "${ARGN}" STREQUAL "SKIP_LINK") target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_MODULE_${the_module}_DEPS_EXT} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${ARGN}) @@ -507,8 +510,6 @@ macro(ocv_create_module) ) endif() - set_target_properties(${the_module} PROPERTIES COMPILE_DEFINITIONS OPENCV_NOSTL) - if(BUILD_SHARED_LIBS) if(MSVC) set_target_properties(${the_module} PROPERTIES DEFINE_SYMBOL CVAPI_EXPORTS) diff --git a/cmake/OpenCVPCHSupport.cmake b/cmake/OpenCVPCHSupport.cmake index cfc4bfa72..9b3efd9d1 100644 --- a/cmake/OpenCVPCHSupport.cmake +++ b/cmake/OpenCVPCHSupport.cmake @@ -46,6 +46,13 @@ MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags) LIST(APPEND ${_out_compile_flags} "-fPIC") ENDIF() + GET_TARGET_PROPERTY(_target_definitions ${_PCH_current_target} COMPILE_DEFINITIONS) + if(_target_definitions) + foreach(_def ${_target_definitions}) + LIST(APPEND ${_out_compile_flags} "-D${_def}") + endforeach() + endif() + ELSE() ## TODO ... ? or does it work out of the box ENDIF() diff --git a/modules/core/doc/command_line_parser.rst b/modules/core/doc/command_line_parser.rst index 53396b23b..ed77e8c47 100644 --- a/modules/core/doc/command_line_parser.rst +++ b/modules/core/doc/command_line_parser.rst @@ -16,7 +16,7 @@ The CommandLineParser class is designed for command line arguments parsing :param argv: :param keys: - .. ocv:function:: template T CommandLineParser::get(const std::string& name, bool space_delete = true) + .. ocv:function:: template T CommandLineParser::get(const cv::String& name, bool space_delete = true) :param name: :param space_delete: @@ -26,7 +26,7 @@ The CommandLineParser class is designed for command line arguments parsing :param index: :param space_delete: - .. ocv:function:: bool CommandLineParser::has(const std::string& name) + .. ocv:function:: bool CommandLineParser::has(const cv::String& name) :param name: @@ -41,7 +41,7 @@ The CommandLineParser class is designed for command line arguments parsing .. ocv:function:: void CommandLineParser::printErrors() - .. ocv:function:: std::string CommandLineParser::getPathToApplication() + .. ocv:function:: cv::String CommandLineParser::getPathToApplication() The sample below demonstrates how to use CommandLineParser: @@ -59,12 +59,12 @@ The sample below demonstrates how to use CommandLineParser: int N = parser.get("N"); double fps = parser.get("fps"); - std::string path = parser.get("path"); + cv::String path = parser.get("path"); use_time_stamp = parser.has("timestamp"); - std::string img1 = parser.get(0); - std::string img2 = parser.get(1); + cv::String img1 = parser.get(0); + cv::String img2 = parser.get(1); int repeat = parser.get(2); @@ -78,7 +78,7 @@ Syntax: :: - const std::string keys = + const cv::String keys = "{help h usage ? | | print this message }" "{@image1 | | image1 for compare }" "{@image2 | | image2 for compare }" diff --git a/modules/core/doc/utility_and_system_functions_and_macros.rst b/modules/core/doc/utility_and_system_functions_and_macros.rst index 54198b058..93b94492d 100644 --- a/modules/core/doc/utility_and_system_functions_and_macros.rst +++ b/modules/core/doc/utility_and_system_functions_and_macros.rst @@ -284,7 +284,7 @@ getBuildInformation ------------------- Returns full configuration time cmake output. -.. ocv:function:: const std::string& getBuildInformation() +.. ocv:function:: const cv::String& getBuildInformation() Returned value is raw cmake output including version control system revision, compiler version, compiler flags, enabled modules and third party libraries, etc. Output format depends on target architecture. diff --git a/modules/core/doc/xml_yaml_persistence.rst b/modules/core/doc/xml_yaml_persistence.rst index 102dafc70..5bbeef745 100644 --- a/modules/core/doc/xml_yaml_persistence.rst +++ b/modules/core/doc/xml_yaml_persistence.rst @@ -113,7 +113,7 @@ Here is how to read the file created by the code sample above: :: // first method: use (type) operator on FileNode. int frameCount = (int)fs2["frameCount"]; - std::string date; + cv::String date; // second method: use FileNode::operator >> fs2["calibrationDate"] >> date; @@ -548,11 +548,11 @@ Returns the node content as double. :returns: The node content as double. -FileNode::operator std::string +FileNode::operator cv::String ------------------------------ Returns the node content as text string. -.. ocv:function:: FileNode::operator std::string() const +.. ocv:function:: FileNode::operator cv::String() const :returns: The node content as a text string. diff --git a/modules/core/include/opencv2/core.hpp b/modules/core/include/opencv2/core.hpp index 889ed2162..86447bf8c 100644 --- a/modules/core/include/opencv2/core.hpp +++ b/modules/core/include/opencv2/core.hpp @@ -126,7 +126,7 @@ public: Full constructor. Normally the constuctor is not called explicitly. Instead, the macros CV_Error(), CV_Error_() and CV_Assert() are used. */ - Exception(int _code, const std::string& _err, const std::string& _func, const std::string& _file, int _line); + Exception(int _code, const cv::String& _err, const cv::String& _func, const cv::String& _file, int _line); virtual ~Exception() throw(); /*! @@ -135,12 +135,12 @@ public: virtual const char *what() const throw(); void formatMessage(); - std::string msg; ///< the formatted error message + cv::String msg; ///< the formatted error message int code; ///< error code @see CVStatus - std::string err; ///< error description - std::string func; ///< function name. Available only when the compiler supports __func__ macro - std::string file; ///< source file name where the error has occured + cv::String err; ///< error description + cv::String func; ///< function name. Available only when the compiler supports __func__ macro + cv::String file; ///< source file name where the error has occured int line; ///< line number in the source file where the error has occured }; @@ -2515,13 +2515,13 @@ enum }; //! renders text string in the image -CV_EXPORTS_W void putText( Mat& img, const std::string& text, Point org, +CV_EXPORTS_W void putText( Mat& img, const cv::String& text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=8, bool bottomLeftOrigin=false ); //! returns bounding box of the text string -CV_EXPORTS_W Size getTextSize(const std::string& text, int fontFace, +CV_EXPORTS_W Size getTextSize(const cv::String& text, int fontFace, double fontScale, int thickness, CV_OUT int* baseLine); @@ -3766,7 +3766,7 @@ class CV_EXPORTS FileNode; FileStorage fs("test.yml", FileStorage::READ); int test_int = (int)fs["test_int"]; double test_real = (double)fs["test_real"]; - std::string test_string = (std::string)fs["test_string"]; + cv::String test_string = (cv::String)fs["test_string"]; Mat M; fs["test_mat"] >> M; @@ -3777,7 +3777,7 @@ class CV_EXPORTS FileNode; int tl1 = (int)tl[1]; double tl2 = (double)tl[2]; int tl3 = (int)tl[3]; - std::string tl4 = (std::string)tl[4]; + cv::String tl4 = (cv::String)tl[4]; CV_Assert(tl[5].type() == FileNode::MAP && tl[5].size() == 3); int month = (int)tl[5]["month"]; @@ -3823,27 +3823,27 @@ public: //! the default constructor CV_WRAP FileStorage(); //! the full constructor that opens file storage for reading or writing - CV_WRAP FileStorage(const std::string& source, int flags, const std::string& encoding=std::string()); + CV_WRAP FileStorage(const cv::String& source, int flags, const cv::String& encoding=cv::String()); //! the constructor that takes pointer to the C FileStorage structure FileStorage(CvFileStorage* fs); //! the destructor. calls release() virtual ~FileStorage(); //! opens file storage for reading or writing. The previous storage is closed with release() - CV_WRAP virtual bool open(const std::string& filename, int flags, const std::string& encoding=std::string()); + CV_WRAP virtual bool open(const cv::String& filename, int flags, const cv::String& encoding=cv::String()); //! returns true if the object is associated with currently opened file. CV_WRAP virtual bool isOpened() const; //! closes the file and releases all the memory buffers CV_WRAP virtual void release(); //! closes the file, releases all the memory buffers and returns the text string - CV_WRAP virtual std::string releaseAndGetString(); + CV_WRAP virtual cv::String releaseAndGetString(); //! returns the first element of the top-level mapping CV_WRAP FileNode getFirstTopLevelNode() const; //! returns the top-level mapping. YAML supports multiple streams CV_WRAP FileNode root(int streamidx=0) const; //! returns the specified element of the top-level mapping - FileNode operator[](const std::string& nodename) const; + FileNode operator[](const cv::String& nodename) const; //! returns the specified element of the top-level mapping CV_WRAP FileNode operator[](const char* nodename) const; @@ -3852,15 +3852,15 @@ public: //! returns pointer to the underlying C FileStorage structure const CvFileStorage* operator *() const { return fs; } //! writes one or more numbers of the specified format to the currently written structure - void writeRaw( const std::string& fmt, const uchar* vec, size_t len ); + void writeRaw( const cv::String& fmt, const uchar* vec, size_t len ); //! writes the registered C structure (CvMat, CvMatND, CvSeq). See cvWrite() - void writeObj( const std::string& name, const void* obj ); + void writeObj( const cv::String& name, const void* obj ); //! returns the normalized object name for the specified file name - static std::string getDefaultObjectName(const std::string& filename); + static cv::String getDefaultObjectName(const cv::String& filename); Ptr fs; //!< the underlying C FileStorage structure - std::string elname; //!< the currently written element + cv::String elname; //!< the currently written element std::vector structs; //!< the stack of written structures int state; //!< the writer state }; @@ -3905,7 +3905,7 @@ public: //! the copy constructor FileNode(const FileNode& node); //! returns element of a mapping node - FileNode operator[](const std::string& nodename) const; + FileNode operator[](const cv::String& nodename) const; //! returns element of a mapping node CV_WRAP FileNode operator[](const char* nodename) const; //! returns element of a sequence node @@ -3930,7 +3930,7 @@ public: //! returns true if the node has a name CV_WRAP bool isNamed() const; //! returns the node name or an empty string if the node is nameless - CV_WRAP std::string name() const; + CV_WRAP cv::String name() const; //! returns the number of elements in the node, if it is a sequence or mapping, or 1 otherwise. CV_WRAP size_t size() const; //! returns the node content as an integer. If the node stores floating-point number, it is rounded. @@ -3956,7 +3956,7 @@ public: FileNodeIterator end() const; //! reads node elements to the buffer with the specified format - void readRaw( const std::string& fmt, uchar* vec, size_t len ) const; + void readRaw( const cv::String& fmt, uchar* vec, size_t len ) const; //! reads the registered object and returns pointer to it void* readObj() const; @@ -3999,7 +3999,7 @@ public: FileNodeIterator& operator -= (int ofs); //! reads the next maxCount elements (or less, if the sequence/mapping last element occurs earlier) to the buffer with the specified format - FileNodeIterator& readRaw( const std::string& fmt, uchar* vec, + FileNodeIterator& readRaw( const cv::String& fmt, uchar* vec, size_t maxCount=(size_t)INT_MAX ); const CvFileStorage* fs; @@ -4155,41 +4155,41 @@ class CV_EXPORTS_W Algorithm public: Algorithm(); virtual ~Algorithm(); - std::string name() const; + cv::String name() const; - template typename ParamType<_Tp>::member_type get(const std::string& name) const; + template typename ParamType<_Tp>::member_type get(const cv::String& name) const; template typename ParamType<_Tp>::member_type get(const char* name) const; - CV_WRAP int getInt(const std::string& name) const; - CV_WRAP double getDouble(const std::string& name) const; - CV_WRAP bool getBool(const std::string& name) const; - CV_WRAP std::string getString(const std::string& name) const; - CV_WRAP Mat getMat(const std::string& name) const; - CV_WRAP std::vector getMatVector(const std::string& name) const; - CV_WRAP Ptr getAlgorithm(const std::string& name) const; + CV_WRAP int getInt(const cv::String& name) const; + CV_WRAP double getDouble(const cv::String& name) const; + CV_WRAP bool getBool(const cv::String& name) const; + CV_WRAP cv::String getString(const cv::String& name) const; + CV_WRAP Mat getMat(const cv::String& name) const; + CV_WRAP std::vector getMatVector(const cv::String& name) const; + CV_WRAP Ptr getAlgorithm(const cv::String& name) const; - void set(const std::string& name, int value); - void set(const std::string& name, double value); - void set(const std::string& name, bool value); - void set(const std::string& name, const std::string& value); - void set(const std::string& name, const Mat& value); - void set(const std::string& name, const std::vector& value); - void set(const std::string& name, const Ptr& value); - template void set(const std::string& name, const Ptr<_Tp>& value); + void set(const cv::String& name, int value); + void set(const cv::String& name, double value); + void set(const cv::String& name, bool value); + void set(const cv::String& name, const cv::String& value); + void set(const cv::String& name, const Mat& value); + void set(const cv::String& name, const std::vector& value); + void set(const cv::String& name, const Ptr& value); + template void set(const cv::String& name, const Ptr<_Tp>& value); - CV_WRAP void setInt(const std::string& name, int value); - CV_WRAP void setDouble(const std::string& name, double value); - CV_WRAP void setBool(const std::string& name, bool value); - CV_WRAP void setString(const std::string& name, const std::string& value); - CV_WRAP void setMat(const std::string& name, const Mat& value); - CV_WRAP void setMatVector(const std::string& name, const std::vector& value); - CV_WRAP void setAlgorithm(const std::string& name, const Ptr& value); - template void setAlgorithm(const std::string& name, const Ptr<_Tp>& value); + CV_WRAP void setInt(const cv::String& name, int value); + CV_WRAP void setDouble(const cv::String& name, double value); + CV_WRAP void setBool(const cv::String& name, bool value); + CV_WRAP void setString(const cv::String& name, const cv::String& value); + CV_WRAP void setMat(const cv::String& name, const Mat& value); + CV_WRAP void setMatVector(const cv::String& name, const std::vector& value); + CV_WRAP void setAlgorithm(const cv::String& name, const Ptr& value); + template void setAlgorithm(const cv::String& name, const Ptr<_Tp>& value); void set(const char* name, int value); void set(const char* name, double value); void set(const char* name, bool value); - void set(const char* name, const std::string& value); + void set(const char* name, const cv::String& value); void set(const char* name, const Mat& value); void set(const char* name, const std::vector& value); void set(const char* name, const Ptr& value); @@ -4198,16 +4198,16 @@ public: void setInt(const char* name, int value); void setDouble(const char* name, double value); void setBool(const char* name, bool value); - void setString(const char* name, const std::string& value); + void setString(const char* name, const cv::String& value); void setMat(const char* name, const Mat& value); void setMatVector(const char* name, const std::vector& value); void setAlgorithm(const char* name, const Ptr& value); template void setAlgorithm(const char* name, const Ptr<_Tp>& value); - CV_WRAP std::string paramHelp(const std::string& name) const; + CV_WRAP cv::String paramHelp(const cv::String& name) const; int paramType(const char* name) const; - CV_WRAP int paramType(const std::string& name) const; - CV_WRAP void getParams(CV_OUT std::vector& names) const; + CV_WRAP int paramType(const cv::String& name) const; + CV_WRAP void getParams(CV_OUT std::vector& names) const; virtual void write(FileStorage& fs) const; @@ -4217,9 +4217,9 @@ public: typedef int (Algorithm::*Getter)() const; typedef void (Algorithm::*Setter)(int); - CV_WRAP static void getList(CV_OUT std::vector& algorithms); - CV_WRAP static Ptr _create(const std::string& name); - template static Ptr<_Tp> create(const std::string& name); + CV_WRAP static void getList(CV_OUT std::vector& algorithms); + CV_WRAP static Ptr _create(const cv::String& name); + template static Ptr<_Tp> create(const cv::String& name); virtual AlgorithmInfo* info() const /* TODO: make it = 0;*/ { return 0; } }; @@ -4229,86 +4229,86 @@ class CV_EXPORTS AlgorithmInfo { public: friend class Algorithm; - AlgorithmInfo(const std::string& name, Algorithm::Constructor create); + AlgorithmInfo(const cv::String& name, Algorithm::Constructor create); ~AlgorithmInfo(); void get(const Algorithm* algo, const char* name, int argType, void* value) const; void addParam_(Algorithm& algo, const char* name, int argType, void* value, bool readOnly, Algorithm::Getter getter, Algorithm::Setter setter, - const std::string& help=std::string()); - std::string paramHelp(const char* name) const; + const cv::String& help=cv::String()); + cv::String paramHelp(const char* name) const; int paramType(const char* name) const; - void getParams(std::vector& names) const; + void getParams(std::vector& names) const; void write(const Algorithm* algo, FileStorage& fs) const; void read(Algorithm* algo, const FileNode& fn) const; - std::string name() const; + cv::String name() const; void addParam(Algorithm& algo, const char* name, int& value, bool readOnly=false, int (Algorithm::*getter)()=0, void (Algorithm::*setter)(int)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); void addParam(Algorithm& algo, const char* name, bool& value, bool readOnly=false, int (Algorithm::*getter)()=0, void (Algorithm::*setter)(int)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); void addParam(Algorithm& algo, const char* name, double& value, bool readOnly=false, double (Algorithm::*getter)()=0, void (Algorithm::*setter)(double)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); void addParam(Algorithm& algo, const char* name, - std::string& value, bool readOnly=false, - std::string (Algorithm::*getter)()=0, - void (Algorithm::*setter)(const std::string&)=0, - const std::string& help=std::string()); + cv::String& value, bool readOnly=false, + cv::String (Algorithm::*getter)()=0, + void (Algorithm::*setter)(const cv::String&)=0, + const cv::String& help=cv::String()); void addParam(Algorithm& algo, const char* name, Mat& value, bool readOnly=false, Mat (Algorithm::*getter)()=0, void (Algorithm::*setter)(const Mat&)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); void addParam(Algorithm& algo, const char* name, std::vector& value, bool readOnly=false, std::vector (Algorithm::*getter)()=0, void (Algorithm::*setter)(const std::vector&)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); void addParam(Algorithm& algo, const char* name, Ptr& value, bool readOnly=false, Ptr (Algorithm::*getter)()=0, void (Algorithm::*setter)(const Ptr&)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); void addParam(Algorithm& algo, const char* name, float& value, bool readOnly=false, float (Algorithm::*getter)()=0, void (Algorithm::*setter)(float)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); void addParam(Algorithm& algo, const char* name, unsigned int& value, bool readOnly=false, unsigned int (Algorithm::*getter)()=0, void (Algorithm::*setter)(unsigned int)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); void addParam(Algorithm& algo, const char* name, uint64& value, bool readOnly=false, uint64 (Algorithm::*getter)()=0, void (Algorithm::*setter)(uint64)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); void addParam(Algorithm& algo, const char* name, uchar& value, bool readOnly=false, uchar (Algorithm::*getter)()=0, void (Algorithm::*setter)(uchar)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); template void addParam(Algorithm& algo, const char* name, Ptr<_Tp>& value, bool readOnly=false, Ptr<_Tp> (Algorithm::*getter)()=0, void (Algorithm::*setter)(const Ptr<_Tp>&)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); template void addParam(Algorithm& algo, const char* name, Ptr<_Tp>& value, bool readOnly=false, Ptr<_Tp> (Algorithm::*getter)()=0, void (Algorithm::*setter)(const Ptr<_Tp>&)=0, - const std::string& help=std::string()); + const cv::String& help=cv::String()); protected: AlgorithmInfoData* data; void set(Algorithm* algo, const char* name, int argType, @@ -4324,13 +4324,13 @@ struct CV_EXPORTS Param Param(int _type, bool _readonly, int _offset, Algorithm::Getter _getter=0, Algorithm::Setter _setter=0, - const std::string& _help=std::string()); + const cv::String& _help=cv::String()); int type; int offset; bool readonly; Algorithm::Getter getter; Algorithm::Setter setter; - std::string help; + cv::String help; }; template<> struct ParamType @@ -4357,10 +4357,10 @@ template<> struct ParamType enum { type = Param::REAL }; }; -template<> struct ParamType +template<> struct ParamType { - typedef const std::string& const_param_type; - typedef std::string member_type; + typedef const cv::String& const_param_type; + typedef cv::String member_type; enum { type = Param::STRING }; }; diff --git a/modules/core/include/opencv2/core/gpumat.hpp b/modules/core/include/opencv2/core/gpumat.hpp index bb436ec55..893ef7b50 100644 --- a/modules/core/include/opencv2/core/gpumat.hpp +++ b/modules/core/include/opencv2/core/gpumat.hpp @@ -247,7 +247,7 @@ namespace cv { namespace gpu // Creates DeviceInfo object for the given GPU DeviceInfo(int device_id) : device_id_(device_id) { query(); } - std::string name() const { return name_; } + cv::String name() const { return name_; } // Return compute capability versions int majorVersion() const { return majorVersion_; } @@ -274,7 +274,7 @@ namespace cv { namespace gpu int device_id_; - std::string name_; + cv::String name_; int multi_processor_count_; int majorVersion_; int minorVersion_; diff --git a/modules/core/include/opencv2/core/operations.hpp b/modules/core/include/opencv2/core/operations.hpp index 44eea1462..f7f454a0e 100644 --- a/modules/core/include/opencv2/core/operations.hpp +++ b/modules/core/include/opencv2/core/operations.hpp @@ -2611,18 +2611,18 @@ template<> CV_EXPORTS void Ptr::delete_obj(); //////////////////////////////////////// XML & YAML I/O //////////////////////////////////// -CV_EXPORTS_W void write( FileStorage& fs, const std::string& name, int value ); -CV_EXPORTS_W void write( FileStorage& fs, const std::string& name, float value ); -CV_EXPORTS_W void write( FileStorage& fs, const std::string& name, double value ); -CV_EXPORTS_W void write( FileStorage& fs, const std::string& name, const std::string& value ); +CV_EXPORTS_W void write( FileStorage& fs, const cv::String& name, int value ); +CV_EXPORTS_W void write( FileStorage& fs, const cv::String& name, float value ); +CV_EXPORTS_W void write( FileStorage& fs, const cv::String& name, double value ); +CV_EXPORTS_W void write( FileStorage& fs, const cv::String& name, const cv::String& value ); template inline void write(FileStorage& fs, const _Tp& value) -{ write(fs, std::string(), value); } +{ write(fs, cv::String(), value); } CV_EXPORTS void writeScalar( FileStorage& fs, int value ); CV_EXPORTS void writeScalar( FileStorage& fs, float value ); CV_EXPORTS void writeScalar( FileStorage& fs, double value ); -CV_EXPORTS void writeScalar( FileStorage& fs, const std::string& value ); +CV_EXPORTS void writeScalar( FileStorage& fs, const cv::String& value ); template<> inline void write( FileStorage& fs, const int& value ) { @@ -2639,7 +2639,7 @@ template<> inline void write( FileStorage& fs, const double& value ) writeScalar(fs, value); } -template<> inline void write( FileStorage& fs, const std::string& value ) +template<> inline void write( FileStorage& fs, const cv::String& value ) { writeScalar(fs, value); } @@ -2700,20 +2700,20 @@ inline void write(FileStorage& fs, const Range& r ) class CV_EXPORTS WriteStructContext { public: - WriteStructContext(FileStorage& _fs, const std::string& name, - int flags, const std::string& typeName=std::string()); + WriteStructContext(FileStorage& _fs, const cv::String& name, + int flags, const cv::String& typeName=cv::String()); ~WriteStructContext(); FileStorage* fs; }; -template inline void write(FileStorage& fs, const std::string& name, const Point_<_Tp>& pt ) +template inline void write(FileStorage& fs, const cv::String& name, const Point_<_Tp>& pt ) { WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW); write(fs, pt.x); write(fs, pt.y); } -template inline void write(FileStorage& fs, const std::string& name, const Point3_<_Tp>& pt ) +template inline void write(FileStorage& fs, const cv::String& name, const Point3_<_Tp>& pt ) { WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW); write(fs, pt.x); @@ -2721,21 +2721,21 @@ template inline void write(FileStorage& fs, const std::string& nam write(fs, pt.z); } -template inline void write(FileStorage& fs, const std::string& name, const Size_<_Tp>& sz ) +template inline void write(FileStorage& fs, const cv::String& name, const Size_<_Tp>& sz ) { WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW); write(fs, sz.width); write(fs, sz.height); } -template inline void write(FileStorage& fs, const std::string& name, const Complex<_Tp>& c ) +template inline void write(FileStorage& fs, const cv::String& name, const Complex<_Tp>& c ) { WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW); write(fs, c.re); write(fs, c.im); } -template inline void write(FileStorage& fs, const std::string& name, const Rect_<_Tp>& r ) +template inline void write(FileStorage& fs, const cv::String& name, const Rect_<_Tp>& r ) { WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW); write(fs, r.x); @@ -2744,14 +2744,14 @@ template inline void write(FileStorage& fs, const std::string& nam write(fs, r.height); } -template inline void write(FileStorage& fs, const std::string& name, const Vec<_Tp, cn>& v ) +template inline void write(FileStorage& fs, const cv::String& name, const Vec<_Tp, cn>& v ) { WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW); for(int i = 0; i < cn; i++) write(fs, v.val[i]); } -template inline void write(FileStorage& fs, const std::string& name, const Scalar_<_Tp>& s ) +template inline void write(FileStorage& fs, const cv::String& name, const Scalar_<_Tp>& s ) { WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW); write(fs, s.val[0]); @@ -2760,7 +2760,7 @@ template inline void write(FileStorage& fs, const std::string& nam write(fs, s.val[3]); } -inline void write(FileStorage& fs, const std::string& name, const Range& r ) +inline void write(FileStorage& fs, const cv::String& name, const Range& r ) { WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW); write(fs, r.start); @@ -2788,7 +2788,7 @@ public: { int _fmt = DataType<_Tp>::fmt; char fmt[] = { (char)((_fmt>>8)+'1'), (char)_fmt, '\0' }; - fs->writeRaw( std::string(fmt), !vec.empty() ? (uchar*)&vec[0] : 0, vec.size()*sizeof(_Tp) ); + fs->writeRaw( cv::String(fmt), !vec.empty() ? (uchar*)&vec[0] : 0, vec.size()*sizeof(_Tp) ); } FileStorage* fs; }; @@ -2799,15 +2799,15 @@ template static inline void write( FileStorage& fs, const std::vec w(vec); } -template static inline void write( FileStorage& fs, const std::string& name, +template static inline void write( FileStorage& fs, const cv::String& name, const std::vector<_Tp>& vec ) { WriteStructContext ws(fs, name, CV_NODE_SEQ+(DataType<_Tp>::fmt != 0 ? CV_NODE_FLOW : 0)); write(fs, vec); } -CV_EXPORTS_W void write( FileStorage& fs, const std::string& name, const Mat& value ); -CV_EXPORTS void write( FileStorage& fs, const std::string& name, const SparseMat& value ); +CV_EXPORTS_W void write( FileStorage& fs, const cv::String& name, const Mat& value ); +CV_EXPORTS void write( FileStorage& fs, const cv::String& name, const SparseMat& value ); template static inline FileStorage& operator << (FileStorage& fs, const _Tp& value) { @@ -2821,10 +2821,10 @@ template static inline FileStorage& operator << (FileStorage& fs, return fs; } -CV_EXPORTS FileStorage& operator << (FileStorage& fs, const std::string& str); +CV_EXPORTS FileStorage& operator << (FileStorage& fs, const cv::String& str); static inline FileStorage& operator << (FileStorage& fs, const char* str) -{ return (fs << std::string(str)); } +{ return (fs << cv::String(str)); } inline FileNode::FileNode() : fs(0), node(0) {} inline FileNode::FileNode(const CvFileStorage* _fs, const CvFileNode* _node) @@ -2928,9 +2928,9 @@ inline FileNode::operator double() const read(*this, value, 0.); return value; } -inline FileNode::operator std::string() const +inline FileNode::operator cv::String() const { - std::string value; + cv::String value; read(*this, value, value); return value; } @@ -2971,7 +2971,7 @@ public: size_t remaining1 = remaining/cn; count = count < remaining1 ? count : remaining1; vec.resize(count); - it->readRaw( std::string(fmt), !vec.empty() ? (uchar*)&vec[0] : 0, count*sizeof(_Tp) ); + it->readRaw( cv::String(fmt), !vec.empty() ? (uchar*)&vec[0] : 0, count*sizeof(_Tp) ); } FileNodeIterator* it; }; @@ -3662,7 +3662,7 @@ public: { FileStorage fs(_fs); fs.fs.addref(); - ((const _ClsName*)ptr)->write(fs, std::string(name)); + ((const _ClsName*)ptr)->write(fs, cv::String(name)); } } @@ -3824,7 +3824,7 @@ template inline std::ostream& operator<<(std::ostream& out, const } -template inline Ptr<_Tp> Algorithm::create(const std::string& name) +template inline Ptr<_Tp> Algorithm::create(const cv::String& name) { return _create(name).ptr<_Tp>(); } @@ -3840,7 +3840,7 @@ inline void Algorithm::set(const char* _name, const Ptr<_Tp>& value) } template -inline void Algorithm::set(const std::string& _name, const Ptr<_Tp>& value) +inline void Algorithm::set(const cv::String& _name, const Ptr<_Tp>& value) { this->set<_Tp>(_name.c_str(), value); } @@ -3856,12 +3856,12 @@ inline void Algorithm::setAlgorithm(const char* _name, const Ptr<_Tp>& value) } template -inline void Algorithm::setAlgorithm(const std::string& _name, const Ptr<_Tp>& value) +inline void Algorithm::setAlgorithm(const cv::String& _name, const Ptr<_Tp>& value) { this->set<_Tp>(_name.c_str(), value); } -template inline typename ParamType<_Tp>::member_type Algorithm::get(const std::string& _name) const +template inline typename ParamType<_Tp>::member_type Algorithm::get(const cv::String& _name) const { typename ParamType<_Tp>::member_type value; info()->get(this, _name.c_str(), ParamType<_Tp>::type, &value); @@ -3877,7 +3877,7 @@ template inline typename ParamType<_Tp>::member_type Algorithm::ge template inline void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, Ptr<_Tp>& value, bool readOnly, Ptr<_Tp> (Algorithm::*getter)(), void (Algorithm::*setter)(const Ptr<_Tp>&), - const std::string& help) + const cv::String& help) { //TODO: static assert: _Tp inherits from _Base addParam_(algo, parameter, ParamType<_Base>::type, &value, readOnly, @@ -3886,7 +3886,7 @@ template inline void AlgorithmInfo::addParam(Algor template inline void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, Ptr<_Tp>& value, bool readOnly, Ptr<_Tp> (Algorithm::*getter)(), void (Algorithm::*setter)(const Ptr<_Tp>&), - const std::string& help) + const cv::String& help) { //TODO: static assert: _Tp inherits from Algorithm addParam_(algo, parameter, ParamType::type, &value, readOnly, diff --git a/modules/core/src/algorithm.cpp b/modules/core/src/algorithm.cpp index 67c71443c..18902c5ad 100644 --- a/modules/core/src/algorithm.cpp +++ b/modules/core/src/algorithm.cpp @@ -96,7 +96,7 @@ template struct sorted_vector }; -template inline const _ValueTp* findstr(const sorted_vector& vec, +template inline const _ValueTp* findstr(const sorted_vector& vec, const char* key) { if( !key ) @@ -130,7 +130,7 @@ Param::Param() Param::Param(int _type, bool _readonly, int _offset, Algorithm::Getter _getter, Algorithm::Setter _setter, - const std::string& _help) + const cv::String& _help) { type = _type; readonly = _readonly; @@ -142,23 +142,23 @@ Param::Param(int _type, bool _readonly, int _offset, struct CV_EXPORTS AlgorithmInfoData { - sorted_vector params; - std::string _name; + sorted_vector params; + cv::String _name; }; -static sorted_vector& alglist() +static sorted_vector& alglist() { - static sorted_vector alglist_var; + static sorted_vector alglist_var; return alglist_var; } -void Algorithm::getList(std::vector& algorithms) +void Algorithm::getList(std::vector& algorithms) { alglist().get_keys(algorithms); } -Ptr Algorithm::_create(const std::string& name) +Ptr Algorithm::_create(const cv::String& name) { Algorithm::Constructor c = 0; if( !alglist().find(name, c) ) @@ -174,42 +174,42 @@ Algorithm::~Algorithm() { } -std::string Algorithm::name() const +cv::String Algorithm::name() const { return info()->name(); } -void Algorithm::set(const std::string& parameter, int value) +void Algorithm::set(const cv::String& parameter, int value) { info()->set(this, parameter.c_str(), ParamType::type, &value); } -void Algorithm::set(const std::string& parameter, double value) +void Algorithm::set(const cv::String& parameter, double value) { info()->set(this, parameter.c_str(), ParamType::type, &value); } -void Algorithm::set(const std::string& parameter, bool value) +void Algorithm::set(const cv::String& parameter, bool value) { info()->set(this, parameter.c_str(), ParamType::type, &value); } -void Algorithm::set(const std::string& parameter, const std::string& value) +void Algorithm::set(const cv::String& parameter, const cv::String& value) { - info()->set(this, parameter.c_str(), ParamType::type, &value); + info()->set(this, parameter.c_str(), ParamType::type, &value); } -void Algorithm::set(const std::string& parameter, const Mat& value) +void Algorithm::set(const cv::String& parameter, const Mat& value) { info()->set(this, parameter.c_str(), ParamType::type, &value); } -void Algorithm::set(const std::string& parameter, const std::vector& value) +void Algorithm::set(const cv::String& parameter, const std::vector& value) { info()->set(this, parameter.c_str(), ParamType >::type, &value); } -void Algorithm::set(const std::string& parameter, const Ptr& value) +void Algorithm::set(const cv::String& parameter, const Ptr& value) { info()->set(this, parameter.c_str(), ParamType::type, &value); } @@ -229,9 +229,9 @@ void Algorithm::set(const char* parameter, bool value) info()->set(this, parameter, ParamType::type, &value); } -void Algorithm::set(const char* parameter, const std::string& value) +void Algorithm::set(const char* parameter, const cv::String& value) { - info()->set(this, parameter, ParamType::type, &value); + info()->set(this, parameter, ParamType::type, &value); } void Algorithm::set(const char* parameter, const Mat& value) @@ -250,37 +250,37 @@ void Algorithm::set(const char* parameter, const Ptr& value) } -void Algorithm::setInt(const std::string& parameter, int value) +void Algorithm::setInt(const cv::String& parameter, int value) { info()->set(this, parameter.c_str(), ParamType::type, &value); } -void Algorithm::setDouble(const std::string& parameter, double value) +void Algorithm::setDouble(const cv::String& parameter, double value) { info()->set(this, parameter.c_str(), ParamType::type, &value); } -void Algorithm::setBool(const std::string& parameter, bool value) +void Algorithm::setBool(const cv::String& parameter, bool value) { info()->set(this, parameter.c_str(), ParamType::type, &value); } -void Algorithm::setString(const std::string& parameter, const std::string& value) +void Algorithm::setString(const cv::String& parameter, const cv::String& value) { - info()->set(this, parameter.c_str(), ParamType::type, &value); + info()->set(this, parameter.c_str(), ParamType::type, &value); } -void Algorithm::setMat(const std::string& parameter, const Mat& value) +void Algorithm::setMat(const cv::String& parameter, const Mat& value) { info()->set(this, parameter.c_str(), ParamType::type, &value); } -void Algorithm::setMatVector(const std::string& parameter, const std::vector& value) +void Algorithm::setMatVector(const cv::String& parameter, const std::vector& value) { info()->set(this, parameter.c_str(), ParamType >::type, &value); } -void Algorithm::setAlgorithm(const std::string& parameter, const Ptr& value) +void Algorithm::setAlgorithm(const cv::String& parameter, const Ptr& value) { info()->set(this, parameter.c_str(), ParamType::type, &value); } @@ -300,9 +300,9 @@ void Algorithm::setBool(const char* parameter, bool value) info()->set(this, parameter, ParamType::type, &value); } -void Algorithm::setString(const char* parameter, const std::string& value) +void Algorithm::setString(const char* parameter, const cv::String& value) { - info()->set(this, parameter, ParamType::type, &value); + info()->set(this, parameter, ParamType::type, &value); } void Algorithm::setMat(const char* parameter, const Mat& value) @@ -322,47 +322,47 @@ void Algorithm::setAlgorithm(const char* parameter, const Ptr& value) -int Algorithm::getInt(const std::string& parameter) const +int Algorithm::getInt(const cv::String& parameter) const { return get(parameter); } -double Algorithm::getDouble(const std::string& parameter) const +double Algorithm::getDouble(const cv::String& parameter) const { return get(parameter); } -bool Algorithm::getBool(const std::string& parameter) const +bool Algorithm::getBool(const cv::String& parameter) const { return get(parameter); } -std::string Algorithm::getString(const std::string& parameter) const +cv::String Algorithm::getString(const cv::String& parameter) const { - return get(parameter); + return get(parameter); } -Mat Algorithm::getMat(const std::string& parameter) const +Mat Algorithm::getMat(const cv::String& parameter) const { return get(parameter); } -std::vector Algorithm::getMatVector(const std::string& parameter) const +std::vector Algorithm::getMatVector(const cv::String& parameter) const { return get >(parameter); } -Ptr Algorithm::getAlgorithm(const std::string& parameter) const +Ptr Algorithm::getAlgorithm(const cv::String& parameter) const { return get(parameter); } -std::string Algorithm::paramHelp(const std::string& parameter) const +cv::String Algorithm::paramHelp(const cv::String& parameter) const { return info()->paramHelp(parameter.c_str()); } -int Algorithm::paramType(const std::string& parameter) const +int Algorithm::paramType(const cv::String& parameter) const { return info()->paramType(parameter.c_str()); } @@ -372,7 +372,7 @@ int Algorithm::paramType(const char* parameter) const return info()->paramType(parameter); } -void Algorithm::getParams(std::vector& names) const +void Algorithm::getParams(std::vector& names) const { info()->getParams(names); } @@ -388,7 +388,7 @@ void Algorithm::read(const FileNode& fn) } -AlgorithmInfo::AlgorithmInfo(const std::string& _name, Algorithm::Constructor create) +AlgorithmInfo::AlgorithmInfo(const cv::String& _name, Algorithm::Constructor create) { data = new AlgorithmInfoData; data->_name = _name; @@ -408,7 +408,7 @@ void AlgorithmInfo::write(const Algorithm* algo, FileStorage& fs) const for( i = 0; i < nparams; i++ ) { const Param& p = data->params.vec[i].second; - const std::string& pname = data->params.vec[i].first; + const cv::String& pname = data->params.vec[i].first; if( p.type == Param::INT ) cv::write(fs, pname, algo->get(pname)); else if( p.type == Param::BOOLEAN ) @@ -416,7 +416,7 @@ void AlgorithmInfo::write(const Algorithm* algo, FileStorage& fs) const else if( p.type == Param::REAL ) cv::write(fs, pname, algo->get(pname)); else if( p.type == Param::STRING ) - cv::write(fs, pname, algo->get(pname)); + cv::write(fs, pname, algo->get(pname)); else if( p.type == Param::MAT ) cv::write(fs, pname, algo->get(pname)); else if( p.type == Param::MAT_VECTOR ) @@ -437,7 +437,7 @@ void AlgorithmInfo::write(const Algorithm* algo, FileStorage& fs) const cv::write(fs, pname, algo->getInt(pname)); else { - std::string msg = format("unknown/unsupported type of '%s' parameter == %d", pname.c_str(), p.type); + cv::String msg = format("unknown/unsupported type of '%s' parameter == %d", pname.c_str(), p.type); CV_Error( CV_StsUnsupportedFormat, msg.c_str()); } } @@ -451,7 +451,7 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const for( i = 0; i < nparams; i++ ) { const Param& p = data->params.vec[i].second; - const std::string& pname = data->params.vec[i].first; + const cv::String& pname = data->params.vec[i].first; const FileNode n = fn[pname]; if( n.empty() ) continue; @@ -472,7 +472,7 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const } else if( p.type == Param::STRING ) { - std::string val = (std::string)n; + cv::String val = (cv::String)n; info->set(algo, pname.c_str(), p.type, &val, true); } else if( p.type == Param::MAT ) @@ -489,7 +489,7 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const } else if( p.type == Param::ALGORITHM ) { - Ptr nestedAlgo = Algorithm::_create((std::string)n["name"]); + Ptr nestedAlgo = Algorithm::_create((cv::String)n["name"]); CV_Assert( !nestedAlgo.empty() ); nestedAlgo->read(n); info->set(algo, pname.c_str(), p.type, &nestedAlgo, true); @@ -516,13 +516,13 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const } else { - std::string msg = format("unknown/unsupported type of '%s' parameter == %d", pname.c_str(), p.type); + cv::String msg = format("unknown/unsupported type of '%s' parameter == %d", pname.c_str(), p.type); CV_Error( CV_StsUnsupportedFormat, msg.c_str()); } } } -std::string AlgorithmInfo::name() const +cv::String AlgorithmInfo::name() const { return data->_name; } @@ -532,7 +532,7 @@ union GetSetParam int (Algorithm::*get_int)() const; bool (Algorithm::*get_bool)() const; double (Algorithm::*get_double)() const; - std::string (Algorithm::*get_string)() const; + cv::String (Algorithm::*get_string)() const; Mat (Algorithm::*get_mat)() const; std::vector (Algorithm::*get_mat_vector)() const; Ptr (Algorithm::*get_algo)() const; @@ -544,7 +544,7 @@ union GetSetParam void (Algorithm::*set_int)(int); void (Algorithm::*set_bool)(bool); void (Algorithm::*set_double)(double); - void (Algorithm::*set_string)(const std::string&); + void (Algorithm::*set_string)(const cv::String&); void (Algorithm::*set_mat)(const Mat&); void (Algorithm::*set_mat_vector)(const std::vector&); void (Algorithm::*set_algo)(const Ptr&); @@ -554,9 +554,9 @@ union GetSetParam void (Algorithm::*set_uchar)(uchar); }; -static std::string getNameOfType(int argType); +static cv::String getNameOfType(int argType); -static std::string getNameOfType(int argType) +static cv::String getNameOfType(int argType) { switch(argType) { @@ -576,37 +576,37 @@ static std::string getNameOfType(int argType) return ""; } -static std::string getErrorMessageForWrongArgumentInSetter(std::string algoName, std::string paramName, int paramType, int argType) +static cv::String getErrorMessageForWrongArgumentInSetter(cv::String algoName, cv::String paramName, int paramType, int argType) { - std::string message = std::string("Argument error: the setter") + cv::String message = cv::String("Argument error: the setter") + " method was called for the parameter '" + paramName + "' of the algorithm '" + algoName +"', the parameter has " + getNameOfType(paramType) + " type, "; if (paramType == Param::INT || paramType == Param::BOOLEAN || paramType == Param::REAL || paramType == Param::FLOAT || paramType == Param::UNSIGNED_INT || paramType == Param::UINT64 || paramType == Param::UCHAR) { - message += "so it should be set by integer, unsigned integer, uint64, unsigned char, boolean, float or double value, "; + message = message + "so it should be set by integer, unsigned integer, uint64, unsigned char, boolean, float or double value, "; } - message += "but the setter was called with " + getNameOfType(argType) + " value"; + message = message + "but the setter was called with " + getNameOfType(argType) + " value"; return message; } -static std::string getErrorMessageForWrongArgumentInGetter(std::string algoName, std::string paramName, int paramType, int argType) +static cv::String getErrorMessageForWrongArgumentInGetter(cv::String algoName, cv::String paramName, int paramType, int argType) { - std::string message = std::string("Argument error: the getter") + cv::String message = cv::String("Argument error: the getter") + " method was called for the parameter '" + paramName + "' of the algorithm '" + algoName +"', the parameter has " + getNameOfType(paramType) + " type, "; if (paramType == Param::BOOLEAN) { - message += "so it should be get as integer, unsigned integer, uint64, boolean, unsigned char, float or double value, "; + message = message + "so it should be get as integer, unsigned integer, uint64, boolean, unsigned char, float or double value, "; } else if (paramType == Param::INT || paramType == Param::UNSIGNED_INT || paramType == Param::UINT64 || paramType == Param::UCHAR) { - message += "so it should be get as integer, unsigned integer, uint64, unsigned char, float or double value, "; + message = message + "so it should be get as integer, unsigned integer, uint64, unsigned char, float or double value, "; } - message += "but the getter was called to get a " + getNameOfType(argType) + " value"; + message = message + "but the getter was called to get a " + getNameOfType(argType) + " value"; return message; } @@ -630,7 +630,7 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con if ( !( p->type == Param::INT || p->type == Param::REAL || p->type == Param::BOOLEAN || p->type == Param::UNSIGNED_INT || p->type == Param::UINT64 || p->type == Param::FLOAT || argType == Param::UCHAR) ) { - std::string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } @@ -790,21 +790,21 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con { if( p->type != Param::STRING ) { - std::string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } - const std::string& val = *(const std::string*)value; + const cv::String& val = *(const cv::String*)value; if( p->setter ) (algo->*f.set_string)(val); else - *(std::string*)((uchar*)algo + p->offset) = val; + *(cv::String*)((uchar*)algo + p->offset) = val; } else if( argType == Param::MAT ) { if( p->type != Param::MAT ) { - std::string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } @@ -818,7 +818,7 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con { if( p->type != Param::MAT_VECTOR ) { - std::string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } @@ -832,7 +832,7 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con { if( p->type != Param::ALGORITHM ) { - std::string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } @@ -862,7 +862,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp { if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR)) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } int val = p->getter ? (algo->*f.get_int)() : *(int*)((uchar*)algo + p->offset); @@ -887,7 +887,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp { if (!( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR)) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } bool val = p->getter ? (algo->*f.get_bool)() : *(bool*)((uchar*)algo + p->offset); @@ -913,7 +913,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp { if(!( argType == Param::REAL || argType == Param::FLOAT)) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } double val = p->getter ? (algo->*f.get_double)() : *(double*)((uchar*)algo + p->offset); @@ -929,7 +929,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp { if(!( argType == Param::REAL || argType == Param::FLOAT)) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } float val = p->getter ? (algo->*f.get_float)() : *(float*)((uchar*)algo + p->offset); @@ -945,7 +945,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp { if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR)) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } unsigned int val = p->getter ? (algo->*f.get_uint)() : *(unsigned int*)((uchar*)algo + p->offset); @@ -969,7 +969,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp { if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR)) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } uint64 val = p->getter ? (algo->*f.get_uint64)() : *(uint64*)((uchar*)algo + p->offset); @@ -993,7 +993,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp { if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR)) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } uchar val = p->getter ? (algo->*f.get_uchar)() : *(uchar*)((uchar*)algo + p->offset); @@ -1021,18 +1021,18 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp { if( p->type != Param::STRING ) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } - *(std::string*)value = p->getter ? (algo->*f.get_string)() : - *(std::string*)((uchar*)algo + p->offset); + *(cv::String*)value = p->getter ? (algo->*f.get_string)() : + *(cv::String*)((uchar*)algo + p->offset); } else if( argType == Param::MAT ) { if( p->type != Param::MAT ) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } @@ -1043,7 +1043,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp { if( p->type != Param::MAT_VECTOR ) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } @@ -1054,7 +1054,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp { if( p->type != Param::ALGORITHM ) { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } @@ -1063,7 +1063,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp } else { - std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); + cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType); CV_Error(CV_StsBadArg, message); } } @@ -1078,7 +1078,7 @@ int AlgorithmInfo::paramType(const char* parameter) const } -std::string AlgorithmInfo::paramHelp(const char* parameter) const +cv::String AlgorithmInfo::paramHelp(const char* parameter) const { const Param* p = findstr(data->params, parameter); if( !p ) @@ -1087,7 +1087,7 @@ std::string AlgorithmInfo::paramHelp(const char* parameter) const } -void AlgorithmInfo::getParams(std::vector& names) const +void AlgorithmInfo::getParams(std::vector& names) const { data->params.get_keys(names); } @@ -1096,7 +1096,7 @@ void AlgorithmInfo::getParams(std::vector& names) const void AlgorithmInfo::addParam_(Algorithm& algo, const char* parameter, int argType, void* value, bool readOnly, Algorithm::Getter getter, Algorithm::Setter setter, - const std::string& help) + const cv::String& help) { CV_Assert( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL || argType == Param::STRING || @@ -1104,7 +1104,7 @@ void AlgorithmInfo::addParam_(Algorithm& algo, const char* parameter, int argTyp argType == Param::ALGORITHM || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR); - data->params.add(std::string(parameter), Param(argType, readOnly, + data->params.add(cv::String(parameter), Param(argType, readOnly, (int)((size_t)value - (size_t)(void*)&algo), getter, setter, help)); } @@ -1114,7 +1114,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, int& value, bool readOnly, int (Algorithm::*getter)(), void (Algorithm::*setter)(int), - const std::string& help) + const cv::String& help) { addParam_(algo, parameter, ParamType::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); @@ -1124,7 +1124,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, bool& value, bool readOnly, int (Algorithm::*getter)(), void (Algorithm::*setter)(int), - const std::string& help) + const cv::String& help) { addParam_(algo, parameter, ParamType::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); @@ -1134,19 +1134,19 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, double& value, bool readOnly, double (Algorithm::*getter)(), void (Algorithm::*setter)(double), - const std::string& help) + const cv::String& help) { addParam_(algo, parameter, ParamType::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); } void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, - std::string& value, bool readOnly, - std::string (Algorithm::*getter)(), - void (Algorithm::*setter)(const std::string&), - const std::string& help) + cv::String& value, bool readOnly, + cv::String (Algorithm::*getter)(), + void (Algorithm::*setter)(const cv::String&), + const cv::String& help) { - addParam_(algo, parameter, ParamType::type, &value, readOnly, + addParam_(algo, parameter, ParamType::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); } @@ -1154,7 +1154,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, Mat& value, bool readOnly, Mat (Algorithm::*getter)(), void (Algorithm::*setter)(const Mat&), - const std::string& help) + const cv::String& help) { addParam_(algo, parameter, ParamType::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); @@ -1164,7 +1164,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, std::vector& value, bool readOnly, std::vector (Algorithm::*getter)(), void (Algorithm::*setter)(const std::vector&), - const std::string& help) + const cv::String& help) { addParam_(algo, parameter, ParamType >::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); @@ -1174,7 +1174,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, Ptr& value, bool readOnly, Ptr (Algorithm::*getter)(), void (Algorithm::*setter)(const Ptr&), - const std::string& help) + const cv::String& help) { addParam_(algo, parameter, ParamType::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); @@ -1184,7 +1184,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, float& value, bool readOnly, float (Algorithm::*getter)(), void (Algorithm::*setter)(float), - const std::string& help) + const cv::String& help) { addParam_(algo, parameter, ParamType::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); @@ -1194,7 +1194,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, unsigned int& value, bool readOnly, unsigned int (Algorithm::*getter)(), void (Algorithm::*setter)(unsigned int), - const std::string& help) + const cv::String& help) { addParam_(algo, parameter, ParamType::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); @@ -1204,7 +1204,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, uint64& value, bool readOnly, uint64 (Algorithm::*getter)(), void (Algorithm::*setter)(uint64), - const std::string& help) + const cv::String& help) { addParam_(algo, parameter, ParamType::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); @@ -1214,7 +1214,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, uchar& value, bool readOnly, uchar (Algorithm::*getter)(), void (Algorithm::*setter)(uchar), - const std::string& help) + const cv::String& help) { addParam_(algo, parameter, ParamType::type, &value, readOnly, (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); diff --git a/modules/core/src/command_line_parser.cpp b/modules/core/src/command_line_parser.cpp index 1bffe5af7..0f6a053a8 100644 --- a/modules/core/src/command_line_parser.cpp +++ b/modules/core/src/command_line_parser.cpp @@ -1,17 +1,14 @@ - #include "precomp.hpp" -#include - namespace cv { struct CommandLineParserParams { public: - std::string help_message; - std::string def_value; - std::vector keys; + cv::String help_message; + cv::String def_value; + std::vector keys; int number; }; @@ -19,27 +16,27 @@ public: struct CommandLineParser::Impl { bool error; - std::string error_message; - std::string about_message; + cv::String error_message; + cv::String about_message; - std::string path_to_app; - std::string app_name; + cv::String path_to_app; + cv::String app_name; std::vector data; - std::vector split_range_string(const std::string& str, char fs, char ss) const; - std::vector split_string(const std::string& str, char symbol = ' ', bool create_empty_item = false) const; - std::string cat_string(const std::string& str) const; + std::vector split_range_string(const cv::String& str, char fs, char ss) const; + std::vector split_string(const cv::String& str, char symbol = ' ', bool create_empty_item = false) const; + cv::String cat_string(const cv::String& str) const; - void apply_params(const std::string& key, const std::string& value); - void apply_params(int i, std::string value); + void apply_params(const cv::String& key, const cv::String& value); + void apply_params(int i, cv::String value); void sort_params(); int refcount; }; -static std::string get_type_name(int type) +static cv::String get_type_name(int type) { if( type == Param::INT ) return "int"; @@ -56,9 +53,9 @@ static std::string get_type_name(int type) return "unknown"; } -static void from_str(const std::string& str, int type, void* dst) +static void from_str(const cv::String& str, int type, void* dst) { - std::stringstream ss(str); + std::stringstream ss(str.c_str()); if( type == Param::INT ) ss >> *(int*)dst; else if( type == Param::UNSIGNED_INT ) @@ -70,20 +67,20 @@ static void from_str(const std::string& str, int type, void* dst) else if( type == Param::REAL ) ss >> *(double*)dst; else if( type == Param::STRING ) - *(std::string*)dst = str; + *(cv::String*)dst = str; else throw cv::Exception(CV_StsBadArg, "unknown/unsupported parameter type", "", __FILE__, __LINE__); if (ss.fail()) { - std::string err_msg = "can not convert: [" + str + + cv::String err_msg = "can not convert: [" + str + + "] to [" + get_type_name(type) + "]"; throw cv::Exception(CV_StsBadArg, err_msg, "", __FILE__, __LINE__); } } -void CommandLineParser::getByName(const std::string& name, bool space_delete, int type, void* dst) const +void CommandLineParser::getByName(const cv::String& name, bool space_delete, int type, void* dst) const { try { @@ -93,7 +90,7 @@ void CommandLineParser::getByName(const std::string& name, bool space_delete, in { if (name.compare(impl->data[i].keys[j]) == 0) { - std::string v = impl->data[i].def_value; + cv::String v = impl->data[i].def_value; if (space_delete) v = impl->cat_string(v); from_str(v, type, dst); @@ -102,12 +99,12 @@ void CommandLineParser::getByName(const std::string& name, bool space_delete, in } } impl->error = true; - impl->error_message += "Unknown parametes " + name + "\n"; + impl->error_message = impl->error_message + "Unknown parametes " + name + "\n"; } catch (std::exception& e) { impl->error = true; - impl->error_message += "Exception: " + std::string(e.what()) + "\n"; + impl->error_message = impl->error_message + "Exception: " + cv::String(e.what()) + "\n"; } } @@ -120,19 +117,19 @@ void CommandLineParser::getByIndex(int index, bool space_delete, int type, void* { if (impl->data[i].number == index) { - std::string v = impl->data[i].def_value; + cv::String v = impl->data[i].def_value; if (space_delete == true) v = impl->cat_string(v); from_str(v, type, dst); return; } } impl->error = true; - impl->error_message += "Unknown parametes #" + format("%d", index) + "\n"; + impl->error_message = impl->error_message + "Unknown parametes #" + format("%d", index) + "\n"; } catch(std::exception & e) { impl->error = true; - impl->error_message += "Exception: " + std::string(e.what()) + "\n"; + impl->error_message = impl->error_message + "Exception: " + cv::String(e.what()) + "\n"; } } @@ -152,34 +149,34 @@ static bool cmp_params(const CommandLineParserParams & p1, const CommandLinePars return true; } -CommandLineParser::CommandLineParser(int argc, const char* const argv[], const std::string& keys) +CommandLineParser::CommandLineParser(int argc, const char* const argv[], const cv::String& keys) { impl = new Impl; impl->refcount = 1; // path to application - size_t pos_s = std::string(argv[0]).find_last_of("/\\"); - if (pos_s == std::string::npos) + size_t pos_s = cv::String(argv[0]).find_last_of("/\\"); + if (pos_s == cv::String::npos) { impl->path_to_app = ""; - impl->app_name = std::string(argv[0]); + impl->app_name = cv::String(argv[0]); } else { - impl->path_to_app = std::string(argv[0]).substr(0, pos_s); - impl->app_name = std::string(argv[0]).substr(pos_s + 1, std::string(argv[0]).length() - pos_s); + impl->path_to_app = cv::String(argv[0]).substr(0, pos_s); + impl->app_name = cv::String(argv[0]).substr(pos_s + 1, cv::String(argv[0]).length() - pos_s); } impl->error = false; impl->error_message = ""; // parse keys - std::vector k = impl->split_range_string(keys, '{', '}'); + std::vector k = impl->split_range_string(keys, '{', '}'); int jj = 0; for (size_t i = 0; i < k.size(); i++) { - std::vector l = impl->split_string(k[i], '|', true); + std::vector l = impl->split_string(k[i], '|', true); CommandLineParserParams p; p.keys = impl->split_string(l[0]); p.def_value = l[1]; @@ -206,11 +203,11 @@ CommandLineParser::CommandLineParser(int argc, const char* const argv[], const s jj = 0; for (int i = 1; i < argc; i++) { - std::string s = std::string(argv[i]); + cv::String s = cv::String(argv[i]); - if (s.find('=') != std::string::npos && s.find('=') < s.length()) + if (s.find('=') != cv::String::npos && s.find('=') < s.length()) { - std::vector k_v = impl->split_string(s, '=', true); + std::vector k_v = impl->split_string(s, '=', true); for (int h = 0; h < 2; h++) { if (k_v[0][0] == '-') @@ -256,12 +253,12 @@ CommandLineParser& CommandLineParser::operator = (const CommandLineParser& parse return *this; } -void CommandLineParser::about(const std::string& message) +void CommandLineParser::about(const cv::String& message) { impl->about_message = message; } -void CommandLineParser::Impl::apply_params(const std::string& key, const std::string& value) +void CommandLineParser::Impl::apply_params(const cv::String& key, const cv::String& value) { for (size_t i = 0; i < data.size(); i++) { @@ -276,7 +273,7 @@ void CommandLineParser::Impl::apply_params(const std::string& key, const std::st } } -void CommandLineParser::Impl::apply_params(int i, std::string value) +void CommandLineParser::Impl::apply_params(int i, cv::String value) { for (size_t j = 0; j < data.size(); j++) { @@ -292,34 +289,34 @@ void CommandLineParser::Impl::sort_params() { for (size_t i = 0; i < data.size(); i++) { - sort(data[i].keys.begin(), data[i].keys.end()); + std::sort(data[i].keys.begin(), data[i].keys.end()); } std::sort (data.begin(), data.end(), cmp_params); } -std::string CommandLineParser::Impl::cat_string(const std::string& str) const +cv::String CommandLineParser::Impl::cat_string(const cv::String& str) const { int left = 0, right = (int)str.length(); while( left <= right && str[left] == ' ' ) left++; while( right > left && str[right-1] == ' ' ) right--; - return left >= right ? std::string("") : str.substr(left, right-left); + return left >= right ? cv::String("") : str.substr(left, right-left); } -std::string CommandLineParser::getPathToApplication() const +cv::String CommandLineParser::getPathToApplication() const { return impl->path_to_app; } -bool CommandLineParser::has(const std::string& name) const +bool CommandLineParser::has(const cv::String& name) const { for (size_t i = 0; i < impl->data.size(); i++) { for (size_t j = 0; j < impl->data[i].keys.size(); j++) { - if (name.compare(impl->data[i].keys[j]) == 0 && std::string("true").compare(impl->data[i].def_value) == 0) + if (name.compare(impl->data[i].keys[j]) == 0 && cv::String("true").compare(impl->data[i].def_value) == 0) { return true; } @@ -337,86 +334,87 @@ void CommandLineParser::printErrors() const { if (impl->error) { - std::cout << std::endl << "ERRORS:" << std::endl << impl->error_message << std::endl; + printf("\nERRORS:\n%s\n", impl->error_message.c_str()); + fflush(stdout); } } void CommandLineParser::printMessage() const { if (impl->about_message != "") - std::cout << impl->about_message << std::endl; + printf("%s\n", impl->about_message.c_str()); - std::cout << "Usage: " << impl->app_name << " [params] "; + printf("Usage: %s [params] ", impl->app_name.c_str()); for (size_t i = 0; i < impl->data.size(); i++) { if (impl->data[i].number > -1) { - std::string name = impl->data[i].keys[0].substr(1, impl->data[i].keys[0].length() - 1); - std::cout << name << " "; + cv::String name = impl->data[i].keys[0].substr(1, impl->data[i].keys[0].length() - 1); + printf("%s ", name.c_str()); } } - std::cout << std::endl << std::endl; + printf("\n\n"); for (size_t i = 0; i < impl->data.size(); i++) { if (impl->data[i].number == -1) { - std::cout << "\t"; + printf("\t"); for (size_t j = 0; j < impl->data[i].keys.size(); j++) { - std::string k = impl->data[i].keys[j]; + cv::String k = impl->data[i].keys[j]; if (k.length() > 1) { - std::cout << "--"; + printf("--"); } else { - std::cout << "-"; + printf("-"); } - std::cout << k; + printf("%s", k.c_str()); if (j != impl->data[i].keys.size() - 1) { - std::cout << ", "; + printf(", "); } } - std::string dv = impl->cat_string(impl->data[i].def_value); + cv::String dv = impl->cat_string(impl->data[i].def_value); if (dv.compare("") != 0) { - std::cout << " (value:" << dv << ")"; + printf(" (value:%s)", dv.c_str()); } - std::cout << std::endl << "\t\t" << impl->data[i].help_message << std::endl; + printf("\n\t\t%s\n", impl->data[i].help_message.c_str()); } } - std::cout << std::endl; + printf("\n"); for (size_t i = 0; i < impl->data.size(); i++) { if (impl->data[i].number != -1) { - std::cout << "\t"; - std::string k = impl->data[i].keys[0]; + printf("\t"); + cv::String k = impl->data[i].keys[0]; k = k.substr(1, k.length() - 1); - std::cout << k; + printf("%s", k.c_str()); - std::string dv = impl->cat_string(impl->data[i].def_value); + cv::String dv = impl->cat_string(impl->data[i].def_value); if (dv.compare("") != 0) { - std::cout << " (value:" << dv << ")"; + printf(" (value:%s)", dv.c_str()); } - std::cout << std::endl << "\t\t" << impl->data[i].help_message << std::endl; + printf("\n\t\t%s\n", impl->data[i].help_message.c_str()); } } } -std::vector CommandLineParser::Impl::split_range_string(const std::string& _str, char fs, char ss) const +std::vector CommandLineParser::Impl::split_range_string(const cv::String& _str, char fs, char ss) const { - std::string str = _str; - std::vector vec; - std::string word = ""; + cv::String str = _str; + std::vector vec; + cv::String word = ""; bool begin = false; while (!str.empty()) @@ -426,13 +424,13 @@ std::vector CommandLineParser::Impl::split_range_string(const std:: if (begin == true) { throw cv::Exception(CV_StsParseError, - std::string("error in split_range_string(") + cv::String("error in split_range_string(") + str - + std::string(", ") - + std::string(1, fs) - + std::string(", ") - + std::string(1, ss) - + std::string(")"), + + cv::String(", ") + + cv::String(1, fs) + + cv::String(", ") + + cv::String(1, ss) + + cv::String(")"), "", __FILE__, __LINE__ ); } @@ -446,13 +444,13 @@ std::vector CommandLineParser::Impl::split_range_string(const std:: if (begin == false) { throw cv::Exception(CV_StsParseError, - std::string("error in split_range_string(") + cv::String("error in split_range_string(") + str - + std::string(", ") - + std::string(1, fs) - + std::string(", ") - + std::string(1, ss) - + std::string(")"), + + cv::String(", ") + + cv::String(1, fs) + + cv::String(", ") + + cv::String(1, ss) + + cv::String(")"), "", __FILE__, __LINE__ ); } @@ -462,7 +460,7 @@ std::vector CommandLineParser::Impl::split_range_string(const std:: if (begin == true) { - word += str[0]; + word = word + str[0]; } str = str.substr(1, str.length() - 1); } @@ -470,13 +468,13 @@ std::vector CommandLineParser::Impl::split_range_string(const std:: if (begin == true) { throw cv::Exception(CV_StsParseError, - std::string("error in split_range_string(") + cv::String("error in split_range_string(") + str - + std::string(", ") - + std::string(1, fs) - + std::string(", ") - + std::string(1, ss) - + std::string(")"), + + cv::String(", ") + + cv::String(1, fs) + + cv::String(", ") + + cv::String(1, ss) + + cv::String(")"), "", __FILE__, __LINE__ ); } @@ -484,11 +482,11 @@ std::vector CommandLineParser::Impl::split_range_string(const std:: return vec; } -std::vector CommandLineParser::Impl::split_string(const std::string& _str, char symbol, bool create_empty_item) const +std::vector CommandLineParser::Impl::split_string(const cv::String& _str, char symbol, bool create_empty_item) const { - std::string str = _str; - std::vector vec; - std::string word = ""; + cv::String str = _str; + std::vector vec; + cv::String word = ""; while (!str.empty()) { @@ -502,7 +500,7 @@ std::vector CommandLineParser::Impl::split_string(const std::string } else { - word += str[0]; + word = word + str[0]; } str = str.substr(1, str.length() - 1); } diff --git a/modules/core/src/drawing.cpp b/modules/core/src/drawing.cpp index a6d5287be..af1794572 100644 --- a/modules/core/src/drawing.cpp +++ b/modules/core/src/drawing.cpp @@ -1916,7 +1916,7 @@ static const int* getFontData(int fontFace) } -void putText( Mat& img, const std::string& text, Point org, +void putText( Mat& img, const cv::String& text, Point org, int fontFace, double fontScale, Scalar color, int thickness, int line_type, bool bottomLeftOrigin ) @@ -1978,7 +1978,7 @@ void putText( Mat& img, const std::string& text, Point org, } } -Size getTextSize( const std::string& text, int fontFace, double fontScale, int thickness, int* _base_line) +Size getTextSize( const cv::String& text, int fontFace, double fontScale, int thickness, int* _base_line) { Size size; double view_x = 0; diff --git a/modules/core/src/gl_core_3_1.cpp b/modules/core/src/gl_core_3_1.cpp index 61006f5ca..1fe3d822a 100644 --- a/modules/core/src/gl_core_3_1.cpp +++ b/modules/core/src/gl_core_3_1.cpp @@ -15,8 +15,8 @@ image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR); // prepend a '_' for the Unix C symbol mangling convention - std::string symbolName = "_"; - symbolName += std::string(name); + cv::String symbolName = "_"; + symbolName += cv::String(name); NSSymbol symbol = image ? NSLookupSymbolInImage(image, &symbolName[0], NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : 0; @@ -94,9 +94,7 @@ void* func = (void*) CV_GL_GET_PROC_ADDRESS(name); if (!func) { - std::ostringstream msg; - msg << "Can't load OpenGL extension [" << name << "]"; - CV_Error(CV_OpenGlApiCallError, msg.str()); + CV_Error(CV_OpenGlApiCallError, cv::format("Can't load OpenGL extension [%s]", name) ); } return func; } diff --git a/modules/core/src/glob.cpp b/modules/core/src/glob.cpp index 4659c21d8..8389cf1d8 100644 --- a/modules/core/src/glob.cpp +++ b/modules/core/src/glob.cpp @@ -65,7 +65,7 @@ namespace { DIR* dir = new DIR; dir->ent.d_name = 0; - dir->handle = ::FindFirstFileA((std::string(path) + "\\*").c_str(), &dir->data); + dir->handle = ::FindFirstFileA((cv::String(path) + "\\*").c_str(), &dir->data); if(dir->handle == INVALID_HANDLE_VALUE) { /*closedir will do all cleanup*/ @@ -100,7 +100,7 @@ const char dir_separators[] = "/"; const char native_separator = '/'; #endif -static bool isDir(const std::string& path, DIR* dir) +static bool isDir(const cv::String& path, DIR* dir) { #if defined WIN32 || defined _WIN32 || defined WINCE DWORD attributes; @@ -168,10 +168,11 @@ static bool wildcmp(const char *string, const char *wild) return *wild == 0; } -static void glob_rec(const std::string& directory, const std::string& wildchart, std::vector& result, bool recursive) +static void glob_rec(const cv::String& directory, const cv::String& wildchart, std::vector& result, bool recursive) { DIR *dir; struct dirent *ent; + if ((dir = opendir (directory.c_str())) != 0) { /* find all the files and directories within directory */ @@ -183,7 +184,7 @@ static void glob_rec(const std::string& directory, const std::string& wildchart, if((name[0] == 0) || (name[0] == '.' && name[1] == 0) || (name[0] == '.' && name[1] == '.' && name[2] == 0)) continue; - std::string path = directory + native_separator + name; + cv::String path = directory + native_separator + name; if (isDir(path, dir)) { @@ -207,14 +208,13 @@ static void glob_rec(const std::string& directory, const std::string& wildchart, else CV_Error(CV_StsObjectNotFound, cv::format("could not open directory: %s", directory.c_str())); } -void cv::glob(std::string pattern, std::vector& result, bool recursive) +void cv::glob(cv::String pattern, std::vector& result, bool recursive) { result.clear(); - std::string path, wildchart; + cv::String path, wildchart; if (isDir(pattern, 0)) { - printf("WE ARE HERE: %s\n", pattern.c_str()); if(strchr(dir_separators, pattern[pattern.size() - 1]) != 0) { path = pattern.substr(0, pattern.size() - 1); @@ -227,7 +227,7 @@ void cv::glob(std::string pattern, std::vector& result, bool recurs else { size_t pos = pattern.find_last_of(dir_separators); - if (pos == std::string::npos) + if (pos == cv::String::npos) { wildchart = pattern; path = "."; diff --git a/modules/core/src/gpumat.cpp b/modules/core/src/gpumat.cpp index cc7442a66..e1407a435 100644 --- a/modules/core/src/gpumat.cpp +++ b/modules/core/src/gpumat.cpp @@ -172,7 +172,7 @@ namespace bool hasEqualOrGreaterBin(int major, int minor) const; private: - static void fromStr(const std::string& set_as_str, std::vector& arr); + static void fromStr(const cv::String& set_as_str, std::vector& arr); std::vector bin; std::vector ptx; @@ -218,9 +218,9 @@ namespace return !bin.empty() && (bin.back() >= major * 10 + minor); } - void CudaArch::fromStr(const std::string& set_as_str, std::vector& arr) + void CudaArch::fromStr(const cv::String& set_as_str, std::vector& arr) { - if (set_as_str.find_first_not_of(" ") == std::string::npos) + if (set_as_str.find_first_not_of(" ") == cv::String::npos) return; std::istringstream stream(set_as_str); diff --git a/modules/core/src/persistence.cpp b/modules/core/src/persistence.cpp index 1ee511910..11203a41a 100644 --- a/modules/core/src/persistence.cpp +++ b/modules/core/src/persistence.cpp @@ -116,7 +116,7 @@ static char* icv_itoa( int _val, char* buffer, int /*radix*/ ) return ptr; } -std::string cv::FileStorage::getDefaultObjectName(const std::string& _filename) +cv::String cv::FileStorage::getDefaultObjectName(const cv::String& _filename) { static const char* stubname = "unnamed"; const char* filename = _filename.c_str(); @@ -152,7 +152,7 @@ std::string cv::FileStorage::getDefaultObjectName(const std::string& _filename) name = name_buf; if( strcmp( name, "_" ) == 0 ) strcpy( name, stubname ); - return std::string(name); + return cv::String(name); } typedef struct CvGenericHash @@ -516,7 +516,7 @@ icvFSFlush( CvFileStorage* fs ) static void -icvClose( CvFileStorage* fs, std::string* out ) +icvClose( CvFileStorage* fs, cv::String* out ) { if( out ) out->clear(); @@ -543,8 +543,7 @@ icvClose( CvFileStorage* fs, std::string* out ) if( fs->outbuf && out ) { - out->resize(fs->outbuf->size()); - std::copy(fs->outbuf->begin(), fs->outbuf->end(), out->begin()); + *out = cv::String(fs->outbuf->begin(), fs->outbuf->end()); } } @@ -5011,7 +5010,7 @@ cvSave( const char* filename, const void* struct_ptr, if( !fs ) CV_Error( CV_StsError, "Could not open the file storage. Check the path and permissions" ); - std::string name = _name ? std::string(_name) : cv::FileStorage::getDefaultObjectName(filename); + cv::String name = _name ? cv::String(_name) : cv::FileStorage::getDefaultObjectName(filename); if( comment ) cvWriteComment( fs, comment, 0 ); @@ -5105,7 +5104,7 @@ stop_search: namespace cv { -static void getElemSize( const std::string& fmt, size_t& elemSize, size_t& cn ) +static void getElemSize( const cv::String& fmt, size_t& elemSize, size_t& cn ) { const char* dt = fmt.c_str(); cn = 1; @@ -5125,7 +5124,7 @@ FileStorage::FileStorage() state = UNDEFINED; } -FileStorage::FileStorage(const std::string& filename, int flags, const std::string& encoding) +FileStorage::FileStorage(const cv::String& filename, int flags, const cv::String& encoding) { state = UNDEFINED; open( filename, flags, encoding ); @@ -5146,7 +5145,7 @@ FileStorage::~FileStorage() } } -bool FileStorage::open(const std::string& filename, int flags, const std::string& encoding) +bool FileStorage::open(const cv::String& filename, int flags, const cv::String& encoding) { release(); fs = Ptr(cvOpenFileStorage( filename.c_str(), 0, flags, @@ -5168,10 +5167,9 @@ void FileStorage::release() state = UNDEFINED; } -std::string FileStorage::releaseAndGetString() +cv::String FileStorage::releaseAndGetString() { - std::string buf; - buf.reserve(16); // HACK: Work around for compiler bug + cv::String buf; if( fs.obj && fs.obj->outbuf ) icvClose(fs.obj, &buf); @@ -5184,7 +5182,7 @@ FileNode FileStorage::root(int streamidx) const return isOpened() ? FileNode(fs, cvGetRootFileNode(fs, streamidx)) : FileNode(); } -FileStorage& operator << (FileStorage& fs, const std::string& str) +FileStorage& operator << (FileStorage& fs, const cv::String& str) { enum { NAME_EXPECTED = FileStorage::NAME_EXPECTED, VALUE_EXPECTED = FileStorage::VALUE_EXPECTED, @@ -5203,7 +5201,7 @@ FileStorage& operator << (FileStorage& fs, const std::string& str) fs.state = fs.structs.empty() || fs.structs.back() == '{' ? INSIDE_MAP + NAME_EXPECTED : VALUE_EXPECTED; cvEndWriteStruct( *fs ); - fs.elname = std::string(); + fs.elname = cv::String(); } else if( fs.state == NAME_EXPECTED + INSIDE_MAP ) { @@ -5227,12 +5225,12 @@ FileStorage& operator << (FileStorage& fs, const std::string& str) } cvStartWriteStruct( *fs, fs.elname.size() > 0 ? fs.elname.c_str() : 0, flags, *_str ? _str : 0 ); - fs.elname = std::string(); + fs.elname = cv::String(); } else { write( fs, fs.elname, (_str[0] == '\\' && (_str[1] == '{' || _str[1] == '}' || - _str[1] == '[' || _str[1] == ']')) ? std::string(_str+1) : str ); + _str[1] == '[' || _str[1] == ']')) ? cv::String(_str+1) : str ); if( fs.state == INSIDE_MAP + VALUE_EXPECTED ) fs.state = INSIDE_MAP + NAME_EXPECTED; } @@ -5243,7 +5241,7 @@ FileStorage& operator << (FileStorage& fs, const std::string& str) } -void FileStorage::writeRaw( const std::string& fmt, const uchar* vec, size_t len ) +void FileStorage::writeRaw( const cv::String& fmt, const uchar* vec, size_t len ) { if( !isOpened() ) return; @@ -5254,7 +5252,7 @@ void FileStorage::writeRaw( const std::string& fmt, const uchar* vec, size_t len } -void FileStorage::writeObj( const std::string& name, const void* obj ) +void FileStorage::writeObj( const cv::String& name, const void* obj ) { if( !isOpened() ) return; @@ -5262,7 +5260,7 @@ void FileStorage::writeObj( const std::string& name, const void* obj ) } -FileNode FileStorage::operator[](const std::string& nodename) const +FileNode FileStorage::operator[](const cv::String& nodename) const { return FileNode(fs, cvGetFileNodeByName(fs, 0, nodename.c_str())); } @@ -5272,7 +5270,7 @@ FileNode FileStorage::operator[](const char* nodename) const return FileNode(fs, cvGetFileNodeByName(fs, 0, nodename)); } -FileNode FileNode::operator[](const std::string& nodename) const +FileNode FileNode::operator[](const cv::String& nodename) const { return FileNode(fs, cvGetFileNodeByName(fs, node, nodename.c_str())); } @@ -5288,10 +5286,10 @@ FileNode FileNode::operator[](int i) const i == 0 ? *this : FileNode(); } -std::string FileNode::name() const +cv::String FileNode::name() const { const char* str; - return !node || (str = cvGetFileNodeName(node)) == 0 ? std::string() : std::string(str); + return !node || (str = cvGetFileNodeName(node)) == 0 ? cv::String() : cv::String(str); } void* FileNode::readObj() const @@ -5406,7 +5404,7 @@ FileNodeIterator& FileNodeIterator::operator -= (int ofs) } -FileNodeIterator& FileNodeIterator::readRaw( const std::string& fmt, uchar* vec, size_t maxCount ) +FileNodeIterator& FileNodeIterator::readRaw( const cv::String& fmt, uchar* vec, size_t maxCount ) { if( fs && container && remaining > 0 ) { @@ -5430,16 +5428,16 @@ FileNodeIterator& FileNodeIterator::readRaw( const std::string& fmt, uchar* vec, } -void write( FileStorage& fs, const std::string& name, int value ) +void write( FileStorage& fs, const cv::String& name, int value ) { cvWriteInt( *fs, name.size() ? name.c_str() : 0, value ); } -void write( FileStorage& fs, const std::string& name, float value ) +void write( FileStorage& fs, const cv::String& name, float value ) { cvWriteReal( *fs, name.size() ? name.c_str() : 0, value ); } -void write( FileStorage& fs, const std::string& name, double value ) +void write( FileStorage& fs, const cv::String& name, double value ) { cvWriteReal( *fs, name.size() ? name.c_str() : 0, value ); } -void write( FileStorage& fs, const std::string& name, const std::string& value ) +void write( FileStorage& fs, const cv::String& name, const cv::String& value ) { cvWriteString( *fs, name.size() ? name.c_str() : 0, value.c_str() ); } void writeScalar(FileStorage& fs, int value ) @@ -5451,11 +5449,11 @@ void writeScalar(FileStorage& fs, float value ) void writeScalar(FileStorage& fs, double value ) { cvWriteReal( *fs, 0, value ); } -void writeScalar(FileStorage& fs, const std::string& value ) +void writeScalar(FileStorage& fs, const cv::String& value ) { cvWriteString( *fs, 0, value.c_str() ); } -void write( FileStorage& fs, const std::string& name, const Mat& value ) +void write( FileStorage& fs, const cv::String& name, const Mat& value ) { if( value.dims <= 2 ) { @@ -5470,15 +5468,15 @@ void write( FileStorage& fs, const std::string& name, const Mat& value ) } // TODO: the 4 functions below need to be implemented more efficiently -void write( FileStorage& fs, const std::string& name, const SparseMat& value ) +void write( FileStorage& fs, const cv::String& name, const SparseMat& value ) { Ptr mat = (CvSparseMat*)value; cvWrite( *fs, name.size() ? name.c_str() : 0, mat ); } -WriteStructContext::WriteStructContext(FileStorage& _fs, const std::string& name, - int flags, const std::string& typeName) : fs(&_fs) +WriteStructContext::WriteStructContext(FileStorage& _fs, const cv::String& name, + int flags, const cv::String& typeName) : fs(&_fs) { cvStartWriteStruct(**fs, !name.empty() ? name.c_str() : 0, flags, !typeName.empty() ? typeName.c_str() : 0); diff --git a/modules/core/src/system.cpp b/modules/core/src/system.cpp index 668b868b3..3299ca7ca 100644 --- a/modules/core/src/system.cpp +++ b/modules/core/src/system.cpp @@ -113,7 +113,7 @@ namespace cv Exception::Exception() { code = 0; line = 0; } -Exception::Exception(int _code, const std::string& _err, const std::string& _func, const std::string& _file, int _line) +Exception::Exception(int _code, const cv::String& _err, const cv::String& _func, const cv::String& _file, int _line) : code(_code), err(_err), func(_func), file(_file), line(_line) { formatMessage(); @@ -340,27 +340,27 @@ int64 getCPUTickCount(void) #endif -const std::string& getBuildInformation() +const cv::String& getBuildInformation() { - static std::string build_info = + static cv::String build_info = #include "version_string.inc" ; return build_info; } -std::string format( const char* fmt, ... ) +cv::String format( const char* fmt, ... ) { char buf[1 << 16]; va_list args; va_start( args, fmt ); vsprintf( buf, fmt, args ); - return std::string(buf); + return cv::String(buf); } -std::string tempfile( const char* suffix ) +cv::String tempfile( const char* suffix ) { const char *temp_dir = getenv("OPENCV_TEMP_PATH"); - std::string fname; + cv::String fname; #if defined WIN32 || defined _WIN32 char temp_dir2[MAX_PATH + 1] = { 0 }; @@ -372,7 +372,7 @@ std::string tempfile( const char* suffix ) temp_dir = temp_dir2; } if(0 == ::GetTempFileNameA(temp_dir, "ocv", 0, temp_file)) - return std::string(); + return cv::String(); DeleteFileA(temp_file); @@ -392,12 +392,12 @@ std::string tempfile( const char* suffix ) fname = temp_dir; char ech = fname[fname.size() - 1]; if(ech != '/' && ech != '\\') - fname += "/"; - fname += "__opencv_temp.XXXXXX"; + fname = fname + "/"; + fname = fname + "__opencv_temp.XXXXXX"; } const int fd = mkstemp((char*)fname.c_str()); - if (fd == -1) return std::string(); + if (fd == -1) return cv::String(); close(fd); remove(fname.c_str()); diff --git a/modules/core/test/test_io.cpp b/modules/core/test/test_io.cpp index 7d4e7d939..6b649d39b 100644 --- a/modules/core/test/test_io.cpp +++ b/modules/core/test/test_io.cpp @@ -191,7 +191,7 @@ protected: int real_int = (int)fs["test_int"]; double real_real = (double)fs["test_real"]; - string real_string = (string)fs["test_string"]; + String real_string = (String)fs["test_string"]; if( real_int != test_int || fabs(real_real - test_real) > DBL_EPSILON*(fabs(test_real)+1) || @@ -292,7 +292,7 @@ protected: (int)tl[1] != 2 || fabs((double)tl[2] - CV_PI) >= DBL_EPSILON || (int)tl[3] != -3435345 || - (string)tl[4] != "2-502 2-029 3egegeg" || + (String)tl[4] != "2-502 2-029 3egegeg" || tl[5].type() != FileNode::MAP || tl[5].size() != 3 || (int)tl[5]["month"] != 12 || (int)tl[5]["day"] != 31 || @@ -459,7 +459,7 @@ TEST(Core_globbing, accurasy) std::string patternLena = cvtest::TS::ptr()->get_data_path() + "lena*.*"; std::string patternLenaPng = cvtest::TS::ptr()->get_data_path() + "lena.png"; - std::vector lenas, pngLenas; + std::vector lenas, pngLenas; cv::glob(patternLena, lenas, true); cv::glob(patternLenaPng, pngLenas, true); diff --git a/modules/features2d/include/opencv2/features2d.hpp b/modules/features2d/include/opencv2/features2d.hpp index 8f32445ca..149658ddf 100644 --- a/modules/features2d/include/opencv2/features2d.hpp +++ b/modules/features2d/include/opencv2/features2d.hpp @@ -109,7 +109,7 @@ public: }; //! writes vector of keypoints to the file storage -CV_EXPORTS void write(FileStorage& fs, const std::string& name, const std::vector& keypoints); +CV_EXPORTS void write(FileStorage& fs, const cv::String& name, const std::vector& keypoints); //! reads vector of keypoints from the specified file storage node CV_EXPORTS void read(const FileNode& node, CV_OUT std::vector& keypoints); @@ -179,7 +179,7 @@ public: CV_WRAP virtual bool empty() const; // Create feature detector by detector name. - CV_WRAP static Ptr create( const std::string& detectorType ); + CV_WRAP static Ptr create( const cv::String& detectorType ); protected: virtual void detectImpl( const Mat& image, std::vector& keypoints, const Mat& mask=Mat() ) const = 0; @@ -229,7 +229,7 @@ public: CV_WRAP virtual bool empty() const; - CV_WRAP static Ptr create( const std::string& descriptorExtractorType ); + CV_WRAP static Ptr create( const cv::String& descriptorExtractorType ); protected: virtual void computeImpl( const Mat& image, std::vector& keypoints, Mat& descriptors ) const = 0; @@ -264,7 +264,7 @@ public: bool useProvidedKeypoints=false ) const = 0; // Create feature detector and descriptor extractor by name. - CV_WRAP static Ptr create( const std::string& name ); + CV_WRAP static Ptr create( const cv::String& name ); }; /*! @@ -765,7 +765,7 @@ public: virtual Ptr clone() const = 0; - static Ptr create( const std::string& detectorType ); + static Ptr create( const cv::String& detectorType ); }; /** \brief an adaptively adjusting detector that iteratively detects until the desired number * of features are detected. @@ -1141,7 +1141,7 @@ public: // but with empty train data. virtual Ptr clone( bool emptyTrainData=false ) const = 0; - CV_WRAP static Ptr create( const std::string& descriptorMatcherType ); + CV_WRAP static Ptr create( const cv::String& descriptorMatcherType ); protected: /* * Class to work with descriptors from several images as with one merged matrix. @@ -1367,8 +1367,8 @@ public: // but with empty train data. virtual Ptr clone( bool emptyTrainData=false ) const = 0; - static Ptr create( const std::string& genericDescritptorMatcherType, - const std::string ¶msFilename=std::string() ); + static Ptr create( const cv::String& genericDescritptorMatcherType, + const cv::String ¶msFilename=cv::String() ); protected: // In fact the matching is implemented only by the following two methods. These methods suppose diff --git a/modules/features2d/src/descriptors.cpp b/modules/features2d/src/descriptors.cpp index 7f87bd5eb..9af880218 100644 --- a/modules/features2d/src/descriptors.cpp +++ b/modules/features2d/src/descriptors.cpp @@ -92,12 +92,12 @@ void DescriptorExtractor::removeBorderKeypoints( std::vector& keypoint KeyPointsFilter::runByImageBorder( keypoints, imageSize, borderSize ); } -Ptr DescriptorExtractor::create(const std::string& descriptorExtractorType) +Ptr DescriptorExtractor::create(const cv::String& descriptorExtractorType) { if( descriptorExtractorType.find("Opponent") == 0 ) { - size_t pos = std::string("Opponent").size(); - std::string type = descriptorExtractorType.substr(pos); + size_t pos = cv::String("Opponent").size(); + cv::String type = descriptorExtractorType.substr(pos); return new OpponentColorDescriptorExtractor(DescriptorExtractor::create(type)); } diff --git a/modules/features2d/src/detectors.cpp b/modules/features2d/src/detectors.cpp index 19175f1b6..ba731acc9 100644 --- a/modules/features2d/src/detectors.cpp +++ b/modules/features2d/src/detectors.cpp @@ -86,7 +86,7 @@ void FeatureDetector::removeInvalidPoints( const Mat& mask, std::vector FeatureDetector::create( const std::string& detectorType ) +Ptr FeatureDetector::create( const cv::String& detectorType ) { if( detectorType.find("Grid") == 0 ) { diff --git a/modules/features2d/src/dynamic.cpp b/modules/features2d/src/dynamic.cpp index 523a3e1f8..cd56ddc3f 100644 --- a/modules/features2d/src/dynamic.cpp +++ b/modules/features2d/src/dynamic.cpp @@ -199,7 +199,7 @@ Ptr SurfAdjuster::clone() const return cloned_obj; } -Ptr AdjusterAdapter::create( const std::string& detectorType ) +Ptr AdjusterAdapter::create( const cv::String& detectorType ) { Ptr adapter; diff --git a/modules/features2d/src/features2d_init.cpp b/modules/features2d/src/features2d_init.cpp index 85640585f..0cf7589ac 100644 --- a/modules/features2d/src/features2d_init.cpp +++ b/modules/features2d/src/features2d_init.cpp @@ -44,7 +44,7 @@ using namespace cv; -Ptr Feature2D::create( const std::string& feature2DType ) +Ptr Feature2D::create( const cv::String& feature2DType ) { return Algorithm::create("Feature2D." + feature2DType); } diff --git a/modules/features2d/src/keypoint.cpp b/modules/features2d/src/keypoint.cpp index a4b960d1b..d39584008 100644 --- a/modules/features2d/src/keypoint.cpp +++ b/modules/features2d/src/keypoint.cpp @@ -58,7 +58,7 @@ size_t KeyPoint::hash() const return _Val; } -void write(FileStorage& fs, const std::string& objname, const std::vector& keypoints) +void write(FileStorage& fs, const cv::String& objname, const std::vector& keypoints) { WriteStructContext ws(fs, objname, CV_NODE_SEQ + CV_NODE_FLOW); diff --git a/modules/features2d/src/matchers.cpp b/modules/features2d/src/matchers.cpp index 658c902f9..2af711702 100644 --- a/modules/features2d/src/matchers.cpp +++ b/modules/features2d/src/matchers.cpp @@ -456,7 +456,7 @@ void BFMatcher::radiusMatchImpl( const Mat& queryDescriptors, std::vector DescriptorMatcher::create( const std::string& descriptorMatcherType ) +Ptr DescriptorMatcher::create( const cv::String& descriptorMatcherType ) { DescriptorMatcher* dm = 0; if( !descriptorMatcherType.compare( "FlannBased" ) ) @@ -540,7 +540,7 @@ void FlannBasedMatcher::read( const FileNode& fn) for(int i = 0; i < (int)ip.size(); ++i) { CV_Assert(ip[i].type() == FileNode::MAP); - std::string _name = (std::string)ip[i]["name"]; + cv::String _name = (cv::String)ip[i]["name"]; int type = (int)ip[i]["type"]; switch(type) @@ -559,7 +559,7 @@ void FlannBasedMatcher::read( const FileNode& fn) indexParams->setDouble(_name, (double) ip[i]["value"]); break; case CV_USRTYPE1: - indexParams->setString(_name, (std::string) ip[i]["value"]); + indexParams->setString(_name, (cv::String) ip[i]["value"]); break; case CV_MAKETYPE(CV_USRTYPE1,2): indexParams->setBool(_name, (int) ip[i]["value"] != 0); @@ -579,7 +579,7 @@ void FlannBasedMatcher::read( const FileNode& fn) for(int i = 0; i < (int)sp.size(); ++i) { CV_Assert(sp[i].type() == FileNode::MAP); - std::string _name = (std::string)sp[i]["name"]; + cv::String _name = (cv::String)sp[i]["name"]; int type = (int)sp[i]["type"]; switch(type) @@ -598,7 +598,7 @@ void FlannBasedMatcher::read( const FileNode& fn) searchParams->setDouble(_name, (double) ip[i]["value"]); break; case CV_USRTYPE1: - searchParams->setString(_name, (std::string) ip[i]["value"]); + searchParams->setString(_name, (cv::String) ip[i]["value"]); break; case CV_MAKETYPE(CV_USRTYPE1,2): searchParams->setBool(_name, (int) ip[i]["value"] != 0); @@ -618,9 +618,9 @@ void FlannBasedMatcher::write( FileStorage& fs) const if (indexParams) { - std::vector names; + std::vector names; std::vector types; - std::vector strValues; + std::vector strValues; std::vector numValues; indexParams->getAll(names, types, strValues, numValues); @@ -669,9 +669,9 @@ void FlannBasedMatcher::write( FileStorage& fs) const if (searchParams) { - std::vector names; + std::vector names; std::vector types; - std::vector strValues; + std::vector strValues; std::vector numValues; searchParams->getAll(names, types, strValues, numValues); @@ -1060,8 +1060,8 @@ bool GenericDescriptorMatcher::empty() const /* * Factory function for GenericDescriptorMatch creating */ -Ptr GenericDescriptorMatcher::create( const std::string& genericDescritptorMatcherType, - const std::string ¶msFilename ) +Ptr GenericDescriptorMatcher::create( const cv::String& genericDescritptorMatcherType, + const cv::String ¶msFilename ) { Ptr descriptorMatcher = Algorithm::create("DescriptorMatcher." + genericDescritptorMatcherType); diff --git a/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.rst b/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.rst index 07b0b2a46..3d22e342a 100644 --- a/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.rst +++ b/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.rst @@ -138,7 +138,7 @@ The method constructs a fast search structure from a set of features using the s struct SavedIndexParams : public IndexParams { - SavedIndexParams( std::string filename ); + SavedIndexParams( cv::String filename ); }; @@ -199,7 +199,7 @@ flann::Index_::save ------------------------------ Saves the index to a file. -.. ocv:function:: void flann::Index_::save(std::string filename) +.. ocv:function:: void flann::Index_::save(cv::String filename) :param filename: The file to save the index to diff --git a/modules/flann/include/opencv2/flann.hpp b/modules/flann/include/opencv2/flann.hpp index d5eedcc0f..d3410c18e 100644 --- a/modules/flann/include/opencv2/flann.hpp +++ b/modules/flann/include/opencv2/flann.hpp @@ -112,7 +112,7 @@ public: int radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const ::cvflann::SearchParams& params); - void save(std::string filename) { nnIndex->save(filename); } + void save(cv::String filename) { nnIndex->save(filename); } int veclen() const { return nnIndex->veclen(); } @@ -244,7 +244,7 @@ public: int radiusSearch(const std::vector& query, std::vector& indices, std::vector& dists, DistanceType radius, const ::cvflann::SearchParams& params); int radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const ::cvflann::SearchParams& params); - void save(std::string filename) + void save(cv::String filename) { if (nnIndex_L1) nnIndex_L1->save(filename); if (nnIndex_L2) nnIndex_L2->save(filename); diff --git a/modules/flann/include/opencv2/flann/any.h b/modules/flann/include/opencv2/flann/any.h index dc0b9481a..4042db67c 100644 --- a/modules/flann/include/opencv2/flann/any.h +++ b/modules/flann/include/opencv2/flann/any.h @@ -106,6 +106,11 @@ template<> inline void big_any_policy::print(std::ostream& ou out << int(*reinterpret_cast(*src)); } +template<> inline void big_any_policy::print(std::ostream& out, void* const* src) +{ + out << (*reinterpret_cast(*src)).c_str(); +} + template struct choose_policy { diff --git a/modules/flann/include/opencv2/flann/flann_base.hpp b/modules/flann/include/opencv2/flann/flann_base.hpp index b5ba7d79e..ce5664518 100644 --- a/modules/flann/include/opencv2/flann/flann_base.hpp +++ b/modules/flann/include/opencv2/flann/flann_base.hpp @@ -62,7 +62,7 @@ inline void log_verbosity(int level) */ struct SavedIndexParams : public IndexParams { - SavedIndexParams(std::string filename) + SavedIndexParams(cv::String filename) { (* this)["algorithm"] = FLANN_INDEX_SAVED; (*this)["filename"] = filename; @@ -71,7 +71,7 @@ struct SavedIndexParams : public IndexParams template -NNIndex* load_saved_index(const Matrix& dataset, const std::string& filename, Distance distance) +NNIndex* load_saved_index(const Matrix& dataset, const cv::String& filename, Distance distance) { typedef typename Distance::ElementType ElementType; @@ -111,7 +111,7 @@ public: loaded_ = false; if (index_type == FLANN_INDEX_SAVED) { - nnIndex_ = load_saved_index(features, get_param(params,"filename"), distance); + nnIndex_ = load_saved_index(features, get_param(params,"filename"), distance); loaded_ = true; } else { @@ -134,7 +134,7 @@ public: } } - void save(std::string filename) + void save(cv::String filename) { FILE* fout = fopen(filename.c_str(), "wb"); if (fout == NULL) { diff --git a/modules/flann/include/opencv2/flann/general.h b/modules/flann/include/opencv2/flann/general.h index 87e7e2f28..9d5402a6f 100644 --- a/modules/flann/include/opencv2/flann/general.h +++ b/modules/flann/include/opencv2/flann/general.h @@ -31,19 +31,17 @@ #ifndef OPENCV_FLANN_GENERAL_H_ #define OPENCV_FLANN_GENERAL_H_ -#include "defines.h" -#include -#include +#include "opencv2/core.hpp" namespace cvflann { -class FLANNException : public std::runtime_error +class FLANNException : public cv::Exception { public: - FLANNException(const char* message) : std::runtime_error(message) { } + FLANNException(const char* message) : cv::Exception(0, message, "", __FILE__, __LINE__) { } - FLANNException(const std::string& message) : std::runtime_error(message) { } + FLANNException(const cv::String& message) : cv::Exception(0, message, "", __FILE__, __LINE__) { } }; } diff --git a/modules/flann/include/opencv2/flann/hdf5.h b/modules/flann/include/opencv2/flann/hdf5.h index ef3e99973..ba1c78a3b 100644 --- a/modules/flann/include/opencv2/flann/hdf5.h +++ b/modules/flann/include/opencv2/flann/hdf5.h @@ -73,7 +73,7 @@ hid_t get_hdf5_type() { return H5T_NATIVE_DOUBLE; } #define CHECK_ERROR(x,y) if ((x)<0) throw FLANNException((y)); template -void save_to_file(const cvflann::Matrix& dataset, const std::string& filename, const std::string& name) +void save_to_file(const cvflann::Matrix& dataset, const cv::String& filename, const cv::String& name) { #if H5Eset_auto_vers == 2 @@ -125,7 +125,7 @@ void save_to_file(const cvflann::Matrix& dataset, const std::string& filename template -void load_from_file(cvflann::Matrix& dataset, const std::string& filename, const std::string& name) +void load_from_file(cvflann::Matrix& dataset, const cv::String& filename, const cv::String& name) { herr_t status; hid_t file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT); @@ -166,7 +166,7 @@ namespace mpi * @param name Name of dataset inside file */ template -void load_from_file(cvflann::Matrix& dataset, const std::string& filename, const std::string& name) +void load_from_file(cvflann::Matrix& dataset, const cv::String& filename, const cv::String& name) { MPI_Comm comm = MPI_COMM_WORLD; MPI_Info info = MPI_INFO_NULL; diff --git a/modules/flann/include/opencv2/flann/lsh_table.h b/modules/flann/include/opencv2/flann/lsh_table.h index a30642a48..7f857ff3d 100644 --- a/modules/flann/include/opencv2/flann/lsh_table.h +++ b/modules/flann/include/opencv2/flann/lsh_table.h @@ -266,9 +266,7 @@ private: const size_t key_size_upper_bound = std::min(sizeof(BucketKey) * CHAR_BIT + 1, sizeof(size_t) * CHAR_BIT); if (key_size < key_size_lower_bound || key_size >= key_size_upper_bound) { - std::stringstream errorMessage; - errorMessage << "Invalid key_size (=" << key_size << "). Valid values for your system are " << key_size_lower_bound << " <= key_size < " << key_size_upper_bound << "."; - CV_Error(CV_StsBadArg, errorMessage.str()); + CV_Error(CV_StsBadArg, cv::format("Invalid key_size (=%d). Valid values for your system are %d <= key_size < %d.", (int)key_size, (int)key_size_lower_bound, (int)key_size_upper_bound)); } speed_level_ = kHash; diff --git a/modules/flann/include/opencv2/flann/miniflann.hpp b/modules/flann/include/opencv2/flann/miniflann.hpp index 475335ca3..2ce150e1e 100644 --- a/modules/flann/include/opencv2/flann/miniflann.hpp +++ b/modules/flann/include/opencv2/flann/miniflann.hpp @@ -59,20 +59,20 @@ struct CV_EXPORTS IndexParams IndexParams(); ~IndexParams(); - std::string getString(const std::string& key, const std::string& defaultVal=std::string()) const; - int getInt(const std::string& key, int defaultVal=-1) const; - double getDouble(const std::string& key, double defaultVal=-1) const; + cv::String getString(const cv::String& key, const cv::String& defaultVal=cv::String()) const; + int getInt(const cv::String& key, int defaultVal=-1) const; + double getDouble(const cv::String& key, double defaultVal=-1) const; - void setString(const std::string& key, const std::string& value); - void setInt(const std::string& key, int value); - void setDouble(const std::string& key, double value); - void setFloat(const std::string& key, float value); - void setBool(const std::string& key, bool value); + void setString(const cv::String& key, const cv::String& value); + void setInt(const cv::String& key, int value); + void setDouble(const cv::String& key, double value); + void setFloat(const cv::String& key, float value); + void setBool(const cv::String& key, bool value); void setAlgorithm(int value); - void getAll(std::vector& names, + void getAll(std::vector& names, std::vector& types, - std::vector& strValues, + std::vector& strValues, std::vector& numValues) const; void* params; @@ -119,7 +119,7 @@ struct CV_EXPORTS LshIndexParams : public IndexParams struct CV_EXPORTS SavedIndexParams : public IndexParams { - SavedIndexParams(const std::string& filename); + SavedIndexParams(const cv::String& filename); }; struct CV_EXPORTS SearchParams : public IndexParams @@ -142,8 +142,8 @@ public: OutputArray dists, double radius, int maxResults, const SearchParams& params=SearchParams()); - CV_WRAP virtual void save(const std::string& filename) const; - CV_WRAP virtual bool load(InputArray features, const std::string& filename); + CV_WRAP virtual void save(const cv::String& filename) const; + CV_WRAP virtual bool load(InputArray features, const cv::String& filename); CV_WRAP virtual void release(); CV_WRAP cvflann::flann_distance_t getDistance() const; CV_WRAP cvflann::flann_algorithm_t getAlgorithm() const; diff --git a/modules/flann/include/opencv2/flann/params.h b/modules/flann/include/opencv2/flann/params.h index fc2a90619..2f1d5e7ca 100644 --- a/modules/flann/include/opencv2/flann/params.h +++ b/modules/flann/include/opencv2/flann/params.h @@ -39,7 +39,7 @@ namespace cvflann { -typedef std::map IndexParams; +typedef std::map IndexParams; struct SearchParams : public IndexParams { @@ -56,7 +56,7 @@ struct SearchParams : public IndexParams template -T get_param(const IndexParams& params, std::string name, const T& default_value) +T get_param(const IndexParams& params, cv::String name, const T& default_value) { IndexParams::const_iterator it = params.find(name); if (it != params.end()) { @@ -68,14 +68,14 @@ T get_param(const IndexParams& params, std::string name, const T& default_value) } template -T get_param(const IndexParams& params, std::string name) +T get_param(const IndexParams& params, cv::String name) { IndexParams::const_iterator it = params.find(name); if (it != params.end()) { return it->second.cast(); } else { - throw FLANNException(std::string("Missing parameter '")+name+std::string("' in the parameters given")); + throw FLANNException(cv::String("Missing parameter '")+name+cv::String("' in the parameters given")); } } diff --git a/modules/flann/src/miniflann.cpp b/modules/flann/src/miniflann.cpp index a7e476fde..a508627c0 100644 --- a/modules/flann/src/miniflann.cpp +++ b/modules/flann/src/miniflann.cpp @@ -26,7 +26,7 @@ IndexParams::IndexParams() } template -T getParam(const IndexParams& _p, const std::string& key, const T& defaultVal=T()) +T getParam(const IndexParams& _p, const cv::String& key, const T& defaultVal=T()) { ::cvflann::IndexParams& p = get_params(_p); ::cvflann::IndexParams::const_iterator it = p.find(key); @@ -36,49 +36,49 @@ T getParam(const IndexParams& _p, const std::string& key, const T& defaultVal=T( } template -void setParam(IndexParams& _p, const std::string& key, const T& value) +void setParam(IndexParams& _p, const cv::String& key, const T& value) { ::cvflann::IndexParams& p = get_params(_p); p[key] = value; } -std::string IndexParams::getString(const std::string& key, const std::string& defaultVal) const +cv::String IndexParams::getString(const cv::String& key, const cv::String& defaultVal) const { return getParam(*this, key, defaultVal); } -int IndexParams::getInt(const std::string& key, int defaultVal) const +int IndexParams::getInt(const cv::String& key, int defaultVal) const { return getParam(*this, key, defaultVal); } -double IndexParams::getDouble(const std::string& key, double defaultVal) const +double IndexParams::getDouble(const cv::String& key, double defaultVal) const { return getParam(*this, key, defaultVal); } -void IndexParams::setString(const std::string& key, const std::string& value) +void IndexParams::setString(const cv::String& key, const cv::String& value) { setParam(*this, key, value); } -void IndexParams::setInt(const std::string& key, int value) +void IndexParams::setInt(const cv::String& key, int value) { setParam(*this, key, value); } -void IndexParams::setDouble(const std::string& key, double value) +void IndexParams::setDouble(const cv::String& key, double value) { setParam(*this, key, value); } -void IndexParams::setFloat(const std::string& key, float value) +void IndexParams::setFloat(const cv::String& key, float value) { setParam(*this, key, value); } -void IndexParams::setBool(const std::string& key, bool value) +void IndexParams::setBool(const cv::String& key, bool value) { setParam(*this, key, value); } @@ -88,9 +88,9 @@ void IndexParams::setAlgorithm(int value) setParam(*this, "algorithm", (cvflann::flann_algorithm_t)value); } -void IndexParams::getAll(std::vector& names, +void IndexParams::getAll(std::vector& names, std::vector& types, - std::vector& strValues, + std::vector& strValues, std::vector& numValues) const { names.clear(); @@ -106,7 +106,7 @@ void IndexParams::getAll(std::vector& names, names.push_back(it->first); try { - std::string val = it->second.cast(); + cv::String val = it->second.cast(); types.push_back(CV_USRTYPE1); strValues.push_back(val); numValues.push_back(-1); @@ -285,9 +285,9 @@ LshIndexParams::LshIndexParams(int table_number, int key_size, int multi_probe_l p["multi_probe_level"] = multi_probe_level; } -SavedIndexParams::SavedIndexParams(const std::string& _filename) +SavedIndexParams::SavedIndexParams(const cv::String& _filename) { - std::string filename = _filename; + cv::String filename = _filename; ::cvflann::IndexParams& p = get_params(*this); p["algorithm"] = FLANN_INDEX_SAVED; @@ -357,7 +357,7 @@ void Index::build(InputArray _data, const IndexParams& params, flann_distance_t algo = getParam(params, "algorithm", FLANN_INDEX_LINEAR); if( algo == FLANN_INDEX_SAVED ) { - load(_data, getParam(params, "filename", std::string())); + load(_data, getParam(params, "filename", cv::String())); return; } @@ -654,7 +654,7 @@ template void saveIndex(const Index* index0, const void* inde saveIndex_< ::cvflann::Index >(index0, index, fout); } -void Index::save(const std::string& filename) const +void Index::save(const cv::String& filename) const { FILE* fout = fopen(filename.c_str(), "wb"); if (fout == NULL) @@ -720,7 +720,7 @@ bool loadIndex(Index* index0, void*& index, const Mat& data, FILE* fin, const Di return loadIndex_ >(index0, index, data, fin, dist); } -bool Index::load(InputArray _data, const std::string& filename) +bool Index::load(InputArray _data, const cv::String& filename) { Mat data = _data.getMat(); bool ok = true; diff --git a/modules/highgui/include/opencv2/highgui.hpp b/modules/highgui/include/opencv2/highgui.hpp index 0b1c617cd..47dec4689 100644 --- a/modules/highgui/include/opencv2/highgui.hpp +++ b/modules/highgui/include/opencv2/highgui.hpp @@ -67,21 +67,21 @@ enum { WND_PROP_OPENGL = CV_WND_PROP_OPENGL // opengl support }; -CV_EXPORTS_W void namedWindow(const std::string& winname, int flags = WINDOW_AUTOSIZE); -CV_EXPORTS_W void destroyWindow(const std::string& winname); +CV_EXPORTS_W void namedWindow(const cv::String& winname, int flags = WINDOW_AUTOSIZE); +CV_EXPORTS_W void destroyWindow(const cv::String& winname); CV_EXPORTS_W void destroyAllWindows(); CV_EXPORTS_W int startWindowThread(); CV_EXPORTS_W int waitKey(int delay = 0); -CV_EXPORTS_W void imshow(const std::string& winname, InputArray mat); +CV_EXPORTS_W void imshow(const cv::String& winname, InputArray mat); -CV_EXPORTS_W void resizeWindow(const std::string& winname, int width, int height); -CV_EXPORTS_W void moveWindow(const std::string& winname, int x, int y); +CV_EXPORTS_W void resizeWindow(const cv::String& winname, int width, int height); +CV_EXPORTS_W void moveWindow(const cv::String& winname, int x, int y); -CV_EXPORTS_W void setWindowProperty(const std::string& winname, int prop_id, double prop_value);//YV -CV_EXPORTS_W double getWindowProperty(const std::string& winname, int prop_id);//YV +CV_EXPORTS_W void setWindowProperty(const cv::String& winname, int prop_id, double prop_value);//YV +CV_EXPORTS_W double getWindowProperty(const cv::String& winname, int prop_id);//YV enum { @@ -110,45 +110,45 @@ enum typedef void (*MouseCallback)(int event, int x, int y, int flags, void* userdata); //! assigns callback for mouse events -CV_EXPORTS void setMouseCallback(const std::string& winname, MouseCallback onMouse, void* userdata = 0); +CV_EXPORTS void setMouseCallback(const cv::String& winname, MouseCallback onMouse, void* userdata = 0); typedef void (CV_CDECL *TrackbarCallback)(int pos, void* userdata); -CV_EXPORTS int createTrackbar(const std::string& trackbarname, const std::string& winname, +CV_EXPORTS int createTrackbar(const cv::String& trackbarname, const cv::String& winname, int* value, int count, TrackbarCallback onChange = 0, void* userdata = 0); -CV_EXPORTS_W int getTrackbarPos(const std::string& trackbarname, const std::string& winname); -CV_EXPORTS_W void setTrackbarPos(const std::string& trackbarname, const std::string& winname, int pos); +CV_EXPORTS_W int getTrackbarPos(const cv::String& trackbarname, const cv::String& winname); +CV_EXPORTS_W void setTrackbarPos(const cv::String& trackbarname, const cv::String& winname, int pos); // OpenGL support typedef void (*OpenGlDrawCallback)(void* userdata); -CV_EXPORTS void setOpenGlDrawCallback(const std::string& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata = 0); +CV_EXPORTS void setOpenGlDrawCallback(const cv::String& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata = 0); -CV_EXPORTS void setOpenGlContext(const std::string& winname); +CV_EXPORTS void setOpenGlContext(const cv::String& winname); -CV_EXPORTS void updateWindow(const std::string& winname); +CV_EXPORTS void updateWindow(const cv::String& winname); //Only for Qt -CV_EXPORTS CvFont fontQt(const std::string& nameFont, int pointSize=-1, +CV_EXPORTS CvFont fontQt(const cv::String& nameFont, int pointSize=-1, Scalar color=Scalar::all(0), int weight=CV_FONT_NORMAL, int style=CV_STYLE_NORMAL, int spacing=0); -CV_EXPORTS void addText( const Mat& img, const std::string& text, Point org, CvFont font); +CV_EXPORTS void addText( const Mat& img, const cv::String& text, Point org, CvFont font); -CV_EXPORTS void displayOverlay(const std::string& winname, const std::string& text, int delayms CV_DEFAULT(0)); -CV_EXPORTS void displayStatusBar(const std::string& winname, const std::string& text, int delayms CV_DEFAULT(0)); +CV_EXPORTS void displayOverlay(const cv::String& winname, const cv::String& text, int delayms CV_DEFAULT(0)); +CV_EXPORTS void displayStatusBar(const cv::String& winname, const cv::String& text, int delayms CV_DEFAULT(0)); -CV_EXPORTS void saveWindowParameters(const std::string& windowName); -CV_EXPORTS void loadWindowParameters(const std::string& windowName); +CV_EXPORTS void saveWindowParameters(const cv::String& windowName); +CV_EXPORTS void loadWindowParameters(const cv::String& windowName); CV_EXPORTS int startLoop(int (*pt2Func)(int argc, char *argv[]), int argc, char* argv[]); CV_EXPORTS void stopLoop(); typedef void (CV_CDECL *ButtonCallback)(int state, void* userdata); -CV_EXPORTS int createButton( const std::string& bar_name, ButtonCallback on_change, +CV_EXPORTS int createButton( const cv::String& bar_name, ButtonCallback on_change, void* userdata=NULL, int type=CV_PUSH_BUTTON, bool initial_button_state=0); @@ -182,12 +182,12 @@ enum IMWRITE_PXM_BINARY =32 }; -CV_EXPORTS_W Mat imread( const std::string& filename, int flags=1 ); -CV_EXPORTS_W bool imwrite( const std::string& filename, InputArray img, +CV_EXPORTS_W Mat imread( const cv::String& filename, int flags=1 ); +CV_EXPORTS_W bool imwrite( const cv::String& filename, InputArray img, const std::vector& params=std::vector()); CV_EXPORTS_W Mat imdecode( InputArray buf, int flags ); CV_EXPORTS Mat imdecode( InputArray buf, int flags, Mat* dst ); -CV_EXPORTS_W bool imencode( const std::string& ext, InputArray img, +CV_EXPORTS_W bool imencode( const cv::String& ext, InputArray img, CV_OUT std::vector& buf, const std::vector& params=std::vector()); @@ -200,11 +200,11 @@ class CV_EXPORTS_W VideoCapture { public: CV_WRAP VideoCapture(); - CV_WRAP VideoCapture(const std::string& filename); + CV_WRAP VideoCapture(const cv::String& filename); CV_WRAP VideoCapture(int device); virtual ~VideoCapture(); - CV_WRAP virtual bool open(const std::string& filename); + CV_WRAP virtual bool open(const cv::String& filename); CV_WRAP virtual bool open(int device); CV_WRAP virtual bool isOpened() const; CV_WRAP virtual void release(); @@ -226,11 +226,11 @@ class CV_EXPORTS_W VideoWriter { public: CV_WRAP VideoWriter(); - CV_WRAP VideoWriter(const std::string& filename, int fourcc, double fps, + CV_WRAP VideoWriter(const cv::String& filename, int fourcc, double fps, Size frameSize, bool isColor=true); virtual ~VideoWriter(); - CV_WRAP virtual bool open(const std::string& filename, int fourcc, double fps, + CV_WRAP virtual bool open(const cv::String& filename, int fourcc, double fps, Size frameSize, bool isColor=true); CV_WRAP virtual bool isOpened() const; CV_WRAP virtual void release(); diff --git a/modules/highgui/src/bitstrm.cpp b/modules/highgui/src/bitstrm.cpp index 89f46fb59..83356b400 100644 --- a/modules/highgui/src/bitstrm.cpp +++ b/modules/highgui/src/bitstrm.cpp @@ -110,7 +110,7 @@ void RBaseStream::readBlock() } -bool RBaseStream::open( const std::string& filename ) +bool RBaseStream::open( const cv::String& filename ) { close(); allocate(); @@ -388,7 +388,7 @@ void WBaseStream::writeBlock() } -bool WBaseStream::open( const std::string& filename ) +bool WBaseStream::open( const cv::String& filename ) { close(); allocate(); diff --git a/modules/highgui/src/bitstrm.hpp b/modules/highgui/src/bitstrm.hpp index 221c2c709..981004041 100644 --- a/modules/highgui/src/bitstrm.hpp +++ b/modules/highgui/src/bitstrm.hpp @@ -66,7 +66,7 @@ public: RBaseStream(); virtual ~RBaseStream(); - virtual bool open( const std::string& filename ); + virtual bool open( const cv::String& filename ); virtual bool open( const Mat& buf ); virtual void close(); bool isOpened(); @@ -123,7 +123,7 @@ public: WBaseStream(); virtual ~WBaseStream(); - virtual bool open( const std::string& filename ); + virtual bool open( const cv::String& filename ); virtual bool open( std::vector& buf ); virtual void close(); bool isOpened(); diff --git a/modules/highgui/src/cap.cpp b/modules/highgui/src/cap.cpp index 012f712dc..ee81897d6 100644 --- a/modules/highgui/src/cap.cpp +++ b/modules/highgui/src/cap.cpp @@ -445,7 +445,7 @@ namespace cv VideoCapture::VideoCapture() {} -VideoCapture::VideoCapture(const std::string& filename) +VideoCapture::VideoCapture(const cv::String& filename) { open(filename); } @@ -460,7 +460,7 @@ VideoCapture::~VideoCapture() cap.release(); } -bool VideoCapture::open(const std::string& filename) +bool VideoCapture::open(const cv::String& filename) { if (!isOpened()) cap = cvCreateFileCapture(filename.c_str()); @@ -532,7 +532,7 @@ double VideoCapture::get(int propId) VideoWriter::VideoWriter() {} -VideoWriter::VideoWriter(const std::string& filename, int fourcc, double fps, Size frameSize, bool isColor) +VideoWriter::VideoWriter(const cv::String& filename, int fourcc, double fps, Size frameSize, bool isColor) { open(filename, fourcc, fps, frameSize, isColor); } @@ -547,7 +547,7 @@ VideoWriter::~VideoWriter() release(); } -bool VideoWriter::open(const std::string& filename, int fourcc, double fps, Size frameSize, bool isColor) +bool VideoWriter::open(const cv::String& filename, int fourcc, double fps, Size frameSize, bool isColor) { writer = cvCreateVideoWriter(filename.c_str(), fourcc, fps, frameSize, isColor); return isOpened(); diff --git a/modules/highgui/src/cap_openni.cpp b/modules/highgui/src/cap_openni.cpp index fed59de74..0261acb86 100644 --- a/modules/highgui/src/cap_openni.cpp +++ b/modules/highgui/src/cap_openni.cpp @@ -66,7 +66,7 @@ #include "XnCppWrapper.h" -const std::string XMLConfig = +const cv::String XMLConfig = "" "" "" @@ -559,7 +559,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index ) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to initialize the context: " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } @@ -569,7 +569,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index ) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to enumerate production trees: " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } @@ -587,7 +587,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index ) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to create production tree: " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } @@ -596,7 +596,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index ) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to run xml script: " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } @@ -607,7 +607,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index ) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to enumerate depth generators: " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } if( depthList.IsEmpty() ) @@ -619,7 +619,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index ) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to create depth generator: " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } @@ -629,7 +629,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index ) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to enumerate image generators: " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } @@ -639,7 +639,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index ) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to create image generator: " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } } @@ -667,7 +667,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index ) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to start generating OpenNI data: " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } @@ -698,7 +698,7 @@ CvCapture_OpenNI::CvCapture_OpenNI(const char * filename) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to initialize the context: " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } @@ -707,7 +707,7 @@ CvCapture_OpenNI::CvCapture_OpenNI(const char * filename) if( status != XN_STATUS_OK ) { std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to open input file (" << filename << "): " - << std::string(xnGetStatusString(status)) << std::endl; + << cv::String(xnGetStatusString(status)) << std::endl; return; } @@ -862,7 +862,7 @@ double CvCapture_OpenNI::getCommonProperty( int propIdx ) break; default : { - std::stringstream ss; + cv::Stringstream ss; ss << "Such parameter (propIdx=" << propIdx << ") isn't supported for getting.\n"; CV_Error( CV_StsBadArg, ss.str().c_str() ); } @@ -923,7 +923,7 @@ bool CvCapture_OpenNI::setCommonProperty( int propIdx, double propValue ) break; default: { - std::stringstream ss; + cv::Stringstream ss; ss << "Such parameter (propIdx=" << propIdx << ") isn't supported for setting.\n"; CV_Error( CV_StsBadArg, ss.str().c_str() ); } @@ -978,7 +978,7 @@ double CvCapture_OpenNI::getDepthGeneratorProperty( int propIdx ) break; default : { - std::stringstream ss; + cv::Stringstream ss; ss << "Depth generator does not support such parameter (propIdx=" << propIdx << ") for getting.\n"; CV_Error( CV_StsBadArg, ss.str().c_str() ); } @@ -1032,7 +1032,7 @@ bool CvCapture_OpenNI::setDepthGeneratorProperty( int propIdx, double propValue break; default: { - std::stringstream ss; + cv::Stringstream ss; ss << "Depth generator does not support such parameter (propIdx=" << propIdx << ") for setting.\n"; CV_Error( CV_StsBadArg, ss.str().c_str() ); } @@ -1074,7 +1074,7 @@ double CvCapture_OpenNI::getImageGeneratorProperty( int propIdx ) break; default : { - std::stringstream ss; + cv::Stringstream ss; ss << "Image generator does not support such parameter (propIdx=" << propIdx << ") for getting.\n"; CV_Error( CV_StsBadArg, ss.str().c_str() ); } @@ -1135,7 +1135,7 @@ bool CvCapture_OpenNI::setImageGeneratorProperty( int propIdx, double propValue } default: { - std::stringstream ss; + cv::Stringstream ss; ss << "Image generator does not support such parameter (propIdx=" << propIdx << ") for setting.\n"; CV_Error( CV_StsBadArg, ss.str().c_str() ); } diff --git a/modules/highgui/src/cap_pvapi.cpp b/modules/highgui/src/cap_pvapi.cpp index 8d4a4a2b4..9e46dabf6 100644 --- a/modules/highgui/src/cap_pvapi.cpp +++ b/modules/highgui/src/cap_pvapi.cpp @@ -356,7 +356,7 @@ bool CvCaptureCAM_PvAPI::setProperty( int property_id, double value ) } else { - std::string ip=cv::format("%d.%d.%d.%d", ((int)value>>24)&255, ((int)value>>16)&255, ((int)value>>8)&255, (int)value&255); + cv::String ip=cv::format("%d.%d.%d.%d", ((int)value>>24)&255, ((int)value>>16)&255, ((int)value>>8)&255, (int)value&255); if ((PvAttrEnumSet(Camera.Handle,"MulticastEnable", "On")==ePvErrSuccess) && (PvAttrStringSet(Camera.Handle, "MulticastIPAddress", ip.c_str())==ePvErrSuccess)) break; diff --git a/modules/highgui/src/grfmt_base.cpp b/modules/highgui/src/grfmt_base.cpp index 0fe798ea8..0be6fcdd5 100644 --- a/modules/highgui/src/grfmt_base.cpp +++ b/modules/highgui/src/grfmt_base.cpp @@ -54,7 +54,7 @@ BaseImageDecoder::BaseImageDecoder() m_buf_supported = false; } -bool BaseImageDecoder::setSource( const std::string& filename ) +bool BaseImageDecoder::setSource( const cv::String& filename ) { m_filename = filename; m_buf.release(); @@ -65,7 +65,7 @@ bool BaseImageDecoder::setSource( const Mat& buf ) { if( !m_buf_supported ) return false; - m_filename = std::string(); + m_filename = cv::String(); m_buf = buf; return true; } @@ -75,7 +75,7 @@ size_t BaseImageDecoder::signatureLength() const return m_signature.size(); } -bool BaseImageDecoder::checkSignature( const std::string& signature ) const +bool BaseImageDecoder::checkSignature( const cv::String& signature ) const { size_t len = signatureLength(); return signature.size() >= len && memcmp( signature.c_str(), m_signature.c_str(), len ) == 0; @@ -96,12 +96,12 @@ bool BaseImageEncoder::isFormatSupported( int depth ) const return depth == CV_8U; } -std::string BaseImageEncoder::getDescription() const +cv::String BaseImageEncoder::getDescription() const { return m_description; } -bool BaseImageEncoder::setDestination( const std::string& filename ) +bool BaseImageEncoder::setDestination( const cv::String& filename ) { m_filename = filename; m_buf = 0; @@ -114,7 +114,7 @@ bool BaseImageEncoder::setDestination( std::vector& buf ) return false; m_buf = &buf; m_buf->clear(); - m_filename = std::string(); + m_filename = cv::String(); return true; } @@ -127,7 +127,7 @@ void BaseImageEncoder::throwOnEror() const { if(!m_last_error.empty()) { - std::string msg = "Raw image encoder error: " + m_last_error; + cv::String msg = "Raw image encoder error: " + m_last_error; CV_Error( CV_BadImageSize, msg.c_str() ); } } diff --git a/modules/highgui/src/grfmt_base.hpp b/modules/highgui/src/grfmt_base.hpp index a97fa2919..173586c1c 100644 --- a/modules/highgui/src/grfmt_base.hpp +++ b/modules/highgui/src/grfmt_base.hpp @@ -65,21 +65,21 @@ public: int height() const { return m_height; }; virtual int type() const { return m_type; }; - virtual bool setSource( const std::string& filename ); + virtual bool setSource( const cv::String& filename ); virtual bool setSource( const Mat& buf ); virtual bool readHeader() = 0; virtual bool readData( Mat& img ) = 0; virtual size_t signatureLength() const; - virtual bool checkSignature( const std::string& signature ) const; + virtual bool checkSignature( const cv::String& signature ) const; virtual ImageDecoder newDecoder() const; protected: int m_width; // width of the image ( filled by readHeader ) int m_height; // height of the image ( filled by readHeader ) int m_type; - std::string m_filename; - std::string m_signature; + cv::String m_filename; + cv::String m_signature; Mat m_buf; bool m_buf_supported; }; @@ -93,23 +93,23 @@ public: virtual ~BaseImageEncoder() {}; virtual bool isFormatSupported( int depth ) const; - virtual bool setDestination( const std::string& filename ); + virtual bool setDestination( const cv::String& filename ); virtual bool setDestination( std::vector& buf ); virtual bool write( const Mat& img, const std::vector& params ) = 0; - virtual std::string getDescription() const; + virtual cv::String getDescription() const; virtual ImageEncoder newEncoder() const; virtual void throwOnEror() const; protected: - std::string m_description; + cv::String m_description; - std::string m_filename; + cv::String m_filename; std::vector* m_buf; bool m_buf_supported; - std::string m_last_error; + cv::String m_last_error; }; } diff --git a/modules/highgui/src/grfmt_jpeg2000.cpp b/modules/highgui/src/grfmt_jpeg2000.cpp index e09eccc90..dee712a58 100644 --- a/modules/highgui/src/grfmt_jpeg2000.cpp +++ b/modules/highgui/src/grfmt_jpeg2000.cpp @@ -82,7 +82,7 @@ static JasperInitializer initialize_jasper; Jpeg2KDecoder::Jpeg2KDecoder() { - m_signature = '\0' + std::string() + '\0' + std::string() + '\0' + std::string("\x0cjP \r\n\x87\n"); + m_signature = '\0' + cv::String() + '\0' + cv::String() + '\0' + cv::String("\x0cjP \r\n\x87\n"); m_stream = 0; m_image = 0; } diff --git a/modules/highgui/src/grfmt_pxm.cpp b/modules/highgui/src/grfmt_pxm.cpp index c2eb100d7..e2f7e5a88 100644 --- a/modules/highgui/src/grfmt_pxm.cpp +++ b/modules/highgui/src/grfmt_pxm.cpp @@ -107,7 +107,7 @@ size_t PxMDecoder::signatureLength() const return 3; } -bool PxMDecoder::checkSignature( const std::string& signature ) const +bool PxMDecoder::checkSignature( const cv::String& signature ) const { return signature.size() >= 3 && signature[0] == 'P' && '1' <= signature[1] && signature[1] <= '6' && diff --git a/modules/highgui/src/grfmt_pxm.hpp b/modules/highgui/src/grfmt_pxm.hpp index 59c669414..d3263c13b 100644 --- a/modules/highgui/src/grfmt_pxm.hpp +++ b/modules/highgui/src/grfmt_pxm.hpp @@ -61,7 +61,7 @@ public: void close(); size_t signatureLength() const; - bool checkSignature( const std::string& signature ) const; + bool checkSignature( const cv::String& signature ) const; ImageDecoder newDecoder() const; protected: diff --git a/modules/highgui/src/grfmt_tiff.cpp b/modules/highgui/src/grfmt_tiff.cpp index 35ab2f81a..d029d8f81 100644 --- a/modules/highgui/src/grfmt_tiff.cpp +++ b/modules/highgui/src/grfmt_tiff.cpp @@ -94,7 +94,7 @@ size_t TiffDecoder::signatureLength() const return 4; } -bool TiffDecoder::checkSignature( const std::string& signature ) const +bool TiffDecoder::checkSignature( const cv::String& signature ) const { return signature.size() >= 4 && (memcmp(signature.c_str(), fmtSignTiffII, 4) == 0 || diff --git a/modules/highgui/src/grfmt_tiff.hpp b/modules/highgui/src/grfmt_tiff.hpp index 3fa0ab497..22383ab25 100644 --- a/modules/highgui/src/grfmt_tiff.hpp +++ b/modules/highgui/src/grfmt_tiff.hpp @@ -102,7 +102,7 @@ public: void close(); size_t signatureLength() const; - bool checkSignature( const std::string& signature ) const; + bool checkSignature( const cv::String& signature ) const; ImageDecoder newDecoder() const; protected: diff --git a/modules/highgui/src/grfmt_webp.cpp b/modules/highgui/src/grfmt_webp.cpp index 981e7a5eb..e076d7447 100644 --- a/modules/highgui/src/grfmt_webp.cpp +++ b/modules/highgui/src/grfmt_webp.cpp @@ -71,7 +71,7 @@ ImageDecoder WebPDecoder::newDecoder() const return new WebPDecoder; } -bool WebPDecoder::checkSignature( const std::string& signature ) const +bool WebPDecoder::checkSignature( const cv::String& signature ) const { size_t len = signatureLength(); bool ret = false; diff --git a/modules/highgui/src/grfmt_webp.hpp b/modules/highgui/src/grfmt_webp.hpp index 15033d120..320c849f5 100644 --- a/modules/highgui/src/grfmt_webp.hpp +++ b/modules/highgui/src/grfmt_webp.hpp @@ -60,7 +60,7 @@ public: bool readData( Mat& img ); bool readHeader(); void close(); - bool checkSignature( const std::string& signature ) const; + bool checkSignature( const cv::String& signature ) const; ImageDecoder newDecoder() const; diff --git a/modules/highgui/src/loadsave.cpp b/modules/highgui/src/loadsave.cpp index a27f3399d..f7b55c5f2 100644 --- a/modules/highgui/src/loadsave.cpp +++ b/modules/highgui/src/loadsave.cpp @@ -96,7 +96,7 @@ struct ImageCodecInitializer static ImageCodecInitializer codecs; -static ImageDecoder findDecoder( const std::string& filename ) +static ImageDecoder findDecoder( const cv::String& filename ) { size_t i, maxlen = 0; for( i = 0; i < codecs.decoders.size(); i++ ) @@ -108,8 +108,8 @@ static ImageDecoder findDecoder( const std::string& filename ) FILE* f= fopen( filename.c_str(), "rb" ); if( !f ) return ImageDecoder(); - std::string signature(maxlen, ' '); - maxlen = fread( &signature[0], 1, maxlen, f ); + cv::String signature(maxlen, ' '); + maxlen = fread( (void*)signature.c_str(), 1, maxlen, f ); fclose(f); signature = signature.substr(0, maxlen); @@ -137,8 +137,8 @@ static ImageDecoder findDecoder( const Mat& buf ) size_t bufSize = buf.rows*buf.cols*buf.elemSize(); maxlen = std::min(maxlen, bufSize); - std::string signature(maxlen, ' '); - memcpy( &signature[0], buf.data, maxlen ); + cv::String signature(maxlen, ' '); + memcpy( (void*)signature.c_str(), buf.data, maxlen ); for( i = 0; i < codecs.decoders.size(); i++ ) { @@ -149,7 +149,7 @@ static ImageDecoder findDecoder( const Mat& buf ) return ImageDecoder(); } -static ImageEncoder findEncoder( const std::string& _ext ) +static ImageEncoder findEncoder( const cv::String& _ext ) { if( _ext.size() <= 1 ) return ImageEncoder(); @@ -163,7 +163,7 @@ static ImageEncoder findEncoder( const std::string& _ext ) for( size_t i = 0; i < codecs.encoders.size(); i++ ) { - std::string description = codecs.encoders[i]->getDescription(); + cv::String description = codecs.encoders[i]->getDescription(); const char* descr = strchr( description.c_str(), '(' ); while( descr ) @@ -191,7 +191,7 @@ static ImageEncoder findEncoder( const std::string& _ext ) enum { LOAD_CVMAT=0, LOAD_IMAGE=1, LOAD_MAT=2 }; static void* -imread_( const std::string& filename, int flags, int hdrtype, Mat* mat=0 ) +imread_( const cv::String& filename, int flags, int hdrtype, Mat* mat=0 ) { IplImage* image = 0; CvMat *matrix = 0; @@ -253,14 +253,14 @@ imread_( const std::string& filename, int flags, int hdrtype, Mat* mat=0 ) hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat; } -Mat imread( const std::string& filename, int flags ) +Mat imread( const cv::String& filename, int flags ) { Mat img; imread_( filename, flags, LOAD_MAT, &img ); return img; } -static bool imwrite_( const std::string& filename, const Mat& image, +static bool imwrite_( const cv::String& filename, const Mat& image, const std::vector& params, bool flipv ) { Mat temp; @@ -292,7 +292,7 @@ static bool imwrite_( const std::string& filename, const Mat& image, return code; } -bool imwrite( const std::string& filename, InputArray _img, +bool imwrite( const cv::String& filename, InputArray _img, const std::vector& params ) { Mat img = _img.getMat(); @@ -306,7 +306,7 @@ imdecode_( const Mat& buf, int flags, int hdrtype, Mat* mat=0 ) IplImage* image = 0; CvMat *matrix = 0; Mat temp, *data = &temp; - std::string filename; + cv::String filename; ImageDecoder decoder = findDecoder(buf); if( decoder.empty() ) @@ -400,7 +400,7 @@ Mat imdecode( InputArray _buf, int flags, Mat* dst ) return *dst; } -bool imencode( const std::string& ext, InputArray _image, +bool imencode( const cv::String& ext, InputArray _image, std::vector& buf, const std::vector& params ) { Mat image = _image.getMat(); @@ -429,7 +429,7 @@ bool imencode( const std::string& ext, InputArray _image, } else { - std::string filename = tempfile(); + cv::String filename = tempfile(); code = encoder->setDestination(filename); CV_Assert( code ); diff --git a/modules/highgui/src/window.cpp b/modules/highgui/src/window.cpp index c89a0a514..e2cdd71db 100644 --- a/modules/highgui/src/window.cpp +++ b/modules/highgui/src/window.cpp @@ -153,12 +153,12 @@ CV_IMPL double cvGetWindowProperty(const char* name, int prop_id) } } -void cv::namedWindow( const std::string& winname, int flags ) +void cv::namedWindow( const cv::String& winname, int flags ) { cvNamedWindow( winname.c_str(), flags ); } -void cv::destroyWindow( const std::string& winname ) +void cv::destroyWindow( const cv::String& winname ) { cvDestroyWindow( winname.c_str() ); } @@ -168,22 +168,22 @@ void cv::destroyAllWindows() cvDestroyAllWindows(); } -void cv::resizeWindow( const std::string& winname, int width, int height ) +void cv::resizeWindow( const cv::String& winname, int width, int height ) { cvResizeWindow( winname.c_str(), width, height ); } -void cv::moveWindow( const std::string& winname, int x, int y ) +void cv::moveWindow( const cv::String& winname, int x, int y ) { cvMoveWindow( winname.c_str(), x, y ); } -void cv::setWindowProperty(const std::string& winname, int prop_id, double prop_value) +void cv::setWindowProperty(const cv::String& winname, int prop_id, double prop_value) { cvSetWindowProperty( winname.c_str(), prop_id, prop_value); } -double cv::getWindowProperty(const std::string& winname, int prop_id) +double cv::getWindowProperty(const cv::String& winname, int prop_id) { return cvGetWindowProperty(winname.c_str(), prop_id); } @@ -193,7 +193,7 @@ int cv::waitKey(int delay) return cvWaitKey(delay); } -int cv::createTrackbar(const std::string& trackbarName, const std::string& winName, +int cv::createTrackbar(const cv::String& trackbarName, const cv::String& winName, int* value, int count, TrackbarCallback callback, void* userdata) { @@ -201,17 +201,17 @@ int cv::createTrackbar(const std::string& trackbarName, const std::string& winNa value, count, callback, userdata); } -void cv::setTrackbarPos( const std::string& trackbarName, const std::string& winName, int value ) +void cv::setTrackbarPos( const cv::String& trackbarName, const cv::String& winName, int value ) { cvSetTrackbarPos(trackbarName.c_str(), winName.c_str(), value ); } -int cv::getTrackbarPos( const std::string& trackbarName, const std::string& winName ) +int cv::getTrackbarPos( const cv::String& trackbarName, const cv::String& winName ) { return cvGetTrackbarPos(trackbarName.c_str(), winName.c_str()); } -void cv::setMouseCallback( const std::string& windowName, MouseCallback onMouse, void* param) +void cv::setMouseCallback( const cv::String& windowName, MouseCallback onMouse, void* param) { cvSetMouseCallback(windowName.c_str(), onMouse, param); } @@ -223,17 +223,17 @@ int cv::startWindowThread() // OpenGL support -void cv::setOpenGlDrawCallback(const std::string& name, OpenGlDrawCallback callback, void* userdata) +void cv::setOpenGlDrawCallback(const cv::String& name, OpenGlDrawCallback callback, void* userdata) { cvSetOpenGlDrawCallback(name.c_str(), callback, userdata); } -void cv::setOpenGlContext(const std::string& windowName) +void cv::setOpenGlContext(const cv::String& windowName) { cvSetOpenGlContext(windowName.c_str()); } -void cv::updateWindow(const std::string& windowName) +void cv::updateWindow(const cv::String& windowName) { cvUpdateWindow(windowName.c_str()); } @@ -241,9 +241,9 @@ void cv::updateWindow(const std::string& windowName) #ifdef HAVE_OPENGL namespace { - std::map wndTexs; - std::map ownWndTexs; - std::map ownWndBufs; + std::map wndTexs; + std::map ownWndTexs; + std::map ownWndBufs; void glDrawTextureCallback(void* userdata) { @@ -254,7 +254,7 @@ namespace } #endif // HAVE_OPENGL -void cv::imshow( const std::string& winname, InputArray _img ) +void cv::imshow( const cv::String& winname, InputArray _img ) { #ifndef HAVE_OPENGL Mat img = _img.getMat(); @@ -342,23 +342,23 @@ CV_IMPL void cvUpdateWindow(const char*) #if defined (HAVE_QT) -CvFont cv::fontQt(const std::string& nameFont, int pointSize, Scalar color, int weight, int style, int /*spacing*/) +CvFont cv::fontQt(const cv::String& nameFont, int pointSize, Scalar color, int weight, int style, int /*spacing*/) { return cvFontQt(nameFont.c_str(), pointSize,color,weight, style); } -void cv::addText( const Mat& img, const std::string& text, Point org, CvFont font) +void cv::addText( const Mat& img, const cv::String& text, Point org, CvFont font) { CvMat _img = img; cvAddText( &_img, text.c_str(), org,&font); } -void cv::displayStatusBar(const std::string& name, const std::string& text, int delayms) +void cv::displayStatusBar(const cv::String& name, const cv::String& text, int delayms) { cvDisplayStatusBar(name.c_str(),text.c_str(), delayms); } -void cv::displayOverlay(const std::string& name, const std::string& text, int delayms) +void cv::displayOverlay(const cv::String& name, const cv::String& text, int delayms) { cvDisplayOverlay(name.c_str(),text.c_str(), delayms); } @@ -373,40 +373,40 @@ void cv::stopLoop() cvStopLoop(); } -void cv::saveWindowParameters(const std::string& windowName) +void cv::saveWindowParameters(const cv::String& windowName) { cvSaveWindowParameters(windowName.c_str()); } -void cv::loadWindowParameters(const std::string& windowName) +void cv::loadWindowParameters(const cv::String& windowName) { cvLoadWindowParameters(windowName.c_str()); } -int cv::createButton(const std::string& button_name, ButtonCallback on_change, void* userdata, int button_type , bool initial_button_state ) +int cv::createButton(const cv::String& button_name, ButtonCallback on_change, void* userdata, int button_type , bool initial_button_state ) { return cvCreateButton(button_name.c_str(), on_change, userdata, button_type , initial_button_state ); } #else -CvFont cv::fontQt(const std::string&, int, Scalar, int, int, int) +CvFont cv::fontQt(const cv::String&, int, Scalar, int, int, int) { CV_Error(CV_StsNotImplemented, "The library is compiled without QT support"); return CvFont(); } -void cv::addText( const Mat&, const std::string&, Point, CvFont) +void cv::addText( const Mat&, const cv::String&, Point, CvFont) { CV_Error(CV_StsNotImplemented, "The library is compiled without QT support"); } -void cv::displayStatusBar(const std::string&, const std::string&, int) +void cv::displayStatusBar(const cv::String&, const cv::String&, int) { CV_Error(CV_StsNotImplemented, "The library is compiled without QT support"); } -void cv::displayOverlay(const std::string&, const std::string&, int ) +void cv::displayOverlay(const cv::String&, const cv::String&, int ) { CV_Error(CV_StsNotImplemented, "The library is compiled without QT support"); } @@ -422,17 +422,17 @@ void cv::stopLoop() CV_Error(CV_StsNotImplemented, "The library is compiled without QT support"); } -void cv::saveWindowParameters(const std::string&) +void cv::saveWindowParameters(const cv::String&) { CV_Error(CV_StsNotImplemented, "The library is compiled without QT support"); } -void cv::loadWindowParameters(const std::string&) +void cv::loadWindowParameters(const cv::String&) { CV_Error(CV_StsNotImplemented, "The library is compiled without QT support"); } -int cv::createButton(const std::string&, ButtonCallback, void*, int , bool ) +int cv::createButton(const cv::String&, ButtonCallback, void*, int , bool ) { CV_Error(CV_StsNotImplemented, "The library is compiled without QT support"); return 0; From 2ad7b97f1c4645e9be8ade2cf12f0c79011082c8 Mon Sep 17 00:00:00 2001 From: Andrey Kamaev Date: Wed, 20 Mar 2013 20:13:46 +0400 Subject: [PATCH 03/12] All modules (except ocl and gpu) compiles and pass tests --- modules/calib3d/test/test_chesscorners.cpp | 4 +- modules/calib3d/test/test_stereomatching.cpp | 20 ++-- modules/contrib/doc/facerec/facerec_api.rst | 2 +- modules/contrib/doc/retina/index.rst | 14 +-- modules/contrib/include/opencv2/contrib.hpp | 16 ++-- .../include/opencv2/contrib/retina.hpp | 6 +- modules/contrib/src/facerec.cpp | 50 +++++----- modules/contrib/src/inputoutput.cpp | 34 +++---- modules/contrib/src/lda.cpp | 24 ++--- modules/contrib/src/retina.cpp | 41 ++++---- modules/contrib/src/spinimages.cpp | 2 +- modules/gpu/doc/video.rst | 24 ++--- modules/gpu/include/opencv2/gpu.hpp | 22 ++--- modules/gpu/src/cascadeclassifier.cpp | 28 +++--- modules/gpu/src/cu_safe_call.cpp | 8 +- modules/gpu/src/cu_safe_call.h | 2 +- modules/gpu/src/cuvid_video_source.cpp | 2 +- modules/gpu/src/cuvid_video_source.h | 2 +- modules/gpu/src/error.cpp | 14 +-- modules/gpu/src/ffmpeg_video_source.cpp | 2 +- modules/gpu/src/ffmpeg_video_source.h | 2 +- .../gpu/src/nvidia/NCVHaarObjectDetection.cu | 14 +-- .../gpu/src/nvidia/NCVHaarObjectDetection.hpp | 6 +- modules/gpu/src/nvidia/core/NCV.cu | 4 +- modules/gpu/src/nvidia/core/NCV.hpp | 4 +- modules/gpu/src/optical_flow.cpp | 2 +- modules/gpu/src/video_reader.cpp | 8 +- modules/gpu/src/video_writer.cpp | 32 +++---- modules/legacy/include/opencv2/legacy.hpp | 44 ++++----- modules/legacy/src/calonder.cpp | 10 +- modules/legacy/src/oneway.cpp | 22 ++--- modules/legacy/src/planardetect.cpp | 8 +- modules/legacy/test/test_stereomatching.cpp | 12 +-- modules/ml/doc/mldata.rst | 4 +- modules/ml/include/opencv2/ml.hpp | 8 +- modules/ml/src/data.cpp | 2 +- modules/ml/src/ertrees.cpp | 2 +- modules/ml/src/gbt.cpp | 4 +- modules/ml/src/precomp.hpp | 1 + modules/ml/src/rtrees.cpp | 4 +- modules/ml/src/svm.cpp | 4 +- modules/ml/test/test_mltests2.cpp | 16 ++-- modules/nonfree/src/surf.ocl.cpp | 14 +-- .../objdetect/include/opencv2/objdetect.hpp | 66 ++++++------- modules/objdetect/src/cascadedetect.cpp | 8 +- modules/objdetect/src/datamatrix.cpp | 6 +- modules/objdetect/src/hog.cpp | 32 +++---- modules/objdetect/src/latentsvmdetector.cpp | 14 +-- modules/objdetect/src/linemod.cpp | 52 +++++----- modules/objdetect/test/test_cascadeandhog.cpp | 8 +- .../objdetect/test/test_latentsvmdetector.cpp | 4 +- modules/ocl/include/opencv2/ocl.hpp | 6 +- .../ocl/include/opencv2/ocl/private/util.hpp | 16 ++-- modules/ocl/src/arithm.cpp | 96 +++++++++---------- modules/ocl/src/binarycaching.hpp | 6 +- modules/ocl/src/blend.cpp | 2 +- modules/ocl/src/brute_force_matcher.cpp | 18 ++-- modules/ocl/src/build_warps.cpp | 10 +- modules/ocl/src/canny.cpp | 14 +-- modules/ocl/src/columnsum.cpp | 2 +- modules/ocl/src/filtering.cpp | 18 ++-- modules/ocl/src/hog.cpp | 16 ++-- modules/ocl/src/imgproc.cpp | 40 ++++---- modules/ocl/src/initialization.cpp | 44 ++++----- modules/ocl/src/interpolate_frames.cpp | 8 +- modules/ocl/src/match_template.cpp | 12 +-- modules/ocl/src/matrix_operations.cpp | 16 ++-- modules/ocl/src/mcwutil.cpp | 8 +- modules/ocl/src/pyrdown.cpp | 2 +- modules/ocl/src/pyrlk.cpp | 18 ++-- modules/ocl/src/pyrup.cpp | 2 +- modules/ocl/src/split_merge.cpp | 8 +- modules/ocl/src/stereobm.cpp | 6 +- .../include/opencv2/softcascade.hpp | 8 +- modules/softcascade/src/detector.cpp | 10 +- modules/softcascade/src/detector_cuda.cpp | 6 +- .../src/integral_channel_builder.cpp | 4 +- modules/softcascade/src/octave.cpp | 4 +- modules/softcascade/test/test_training.cpp | 2 +- .../stitching/detail/motion_estimators.hpp | 2 +- .../include/opencv2/stitching/detail/util.hpp | 2 +- modules/stitching/src/motion_estimators.cpp | 20 ++-- modules/superres/include/opencv2/superres.hpp | 4 +- modules/superres/src/frame_source.cpp | 16 ++-- modules/video/src/bgfg_gaussmix.cpp | 4 +- modules/video/src/bgfg_gaussmix2.cpp | 4 +- modules/video/src/bgfg_gmg.cpp | 4 +- .../opencv2/videostab/frame_source.hpp | 2 +- .../opencv2/videostab/global_motion.hpp | 4 +- modules/videostab/src/frame_source.cpp | 8 +- modules/videostab/src/global_motion.cpp | 4 +- 91 files changed, 606 insertions(+), 604 deletions(-) diff --git a/modules/calib3d/test/test_chesscorners.cpp b/modules/calib3d/test/test_chesscorners.cpp index 42c25b86a..bbc792ea5 100644 --- a/modules/calib3d/test/test_chesscorners.cpp +++ b/modules/calib3d/test/test_chesscorners.cpp @@ -217,7 +217,7 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename ) ts->update_context( this, idx, true ); /* read the image */ - string img_file = board_list[idx * 2]; + String img_file = board_list[idx * 2]; Mat gray = imread( folder + img_file, 0); if( gray.empty() ) @@ -227,7 +227,7 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename ) return; } - string _filename = folder + (string)board_list[idx * 2 + 1]; + String _filename = folder + (String)board_list[idx * 2 + 1]; bool doesContatinChessboard; Mat expected; { diff --git a/modules/calib3d/test/test_stereomatching.cpp b/modules/calib3d/test/test_stereomatching.cpp index 4b35dad99..d1cdb23b7 100644 --- a/modules/calib3d/test/test_stereomatching.cpp +++ b/modules/calib3d/test/test_stereomatching.cpp @@ -593,10 +593,10 @@ int CV_StereoMatchingTest::readDatasetsParams( FileStorage& fs ) assert(fn.isSeq()); for( int i = 0; i < (int)fn.size(); i+=3 ) { - string _name = fn[i]; + String _name = fn[i]; DatasetParams params; - string sf = fn[i+1]; params.dispScaleFactor = atoi(sf.c_str()); - string uv = fn[i+2]; params.dispUnknVal = atoi(uv.c_str()); + String sf = fn[i+1]; params.dispScaleFactor = atoi(sf.c_str()); + String uv = fn[i+2]; params.dispUnknVal = atoi(uv.c_str()); datasetsParams[_name] = params; } return cvtest::TS::OK; @@ -680,10 +680,10 @@ protected: assert(fn.isSeq()); for( int i = 0; i < (int)fn.size(); i+=4 ) { - string caseName = fn[i], datasetName = fn[i+1]; + String caseName = fn[i], datasetName = fn[i+1]; RunParams params; - string ndisp = fn[i+2]; params.ndisp = atoi(ndisp.c_str()); - string winSize = fn[i+3]; params.winSize = atoi(winSize.c_str()); + String ndisp = fn[i+2]; params.ndisp = atoi(ndisp.c_str()); + String winSize = fn[i+3]; params.winSize = atoi(winSize.c_str()); caseNames.push_back( caseName ); caseDatasets.push_back( datasetName ); caseRunParams.push_back( params ); @@ -734,11 +734,11 @@ protected: assert(fn.isSeq()); for( int i = 0; i < (int)fn.size(); i+=5 ) { - string caseName = fn[i], datasetName = fn[i+1]; + String caseName = fn[i], datasetName = fn[i+1]; RunParams params; - string ndisp = fn[i+2]; params.ndisp = atoi(ndisp.c_str()); - string winSize = fn[i+3]; params.winSize = atoi(winSize.c_str()); - string fullDP = fn[i+4]; params.fullDP = atoi(fullDP.c_str()) == 0 ? false : true; + String ndisp = fn[i+2]; params.ndisp = atoi(ndisp.c_str()); + String winSize = fn[i+3]; params.winSize = atoi(winSize.c_str()); + String fullDP = fn[i+4]; params.fullDP = atoi(fullDP.c_str()) == 0 ? false : true; caseNames.push_back( caseName ); caseDatasets.push_back( datasetName ); caseRunParams.push_back( params ); diff --git a/modules/contrib/doc/facerec/facerec_api.rst b/modules/contrib/doc/facerec/facerec_api.rst index 8bea7070a..4461c9c88 100644 --- a/modules/contrib/doc/facerec/facerec_api.rst +++ b/modules/contrib/doc/facerec/facerec_api.rst @@ -113,7 +113,7 @@ Since every :ocv:class:`FaceRecognizer` is a :ocv:class:`Algorithm`, you can use // Create a FaceRecognizer: Ptr model = createEigenFaceRecognizer(); // And here's how to get its name: - std::string name = model->name(); + cv::String name = model->name(); FaceRecognizer::train diff --git a/modules/contrib/doc/retina/index.rst b/modules/contrib/doc/retina/index.rst index a3a5bc82f..464f8c3c4 100644 --- a/modules/contrib/doc/retina/index.rst +++ b/modules/contrib/doc/retina/index.rst @@ -16,7 +16,7 @@ Class which provides the main controls to the Gipsa/Listic labs human retina mo **NOTE : See the Retina tutorial in the tutorial/contrib section for complementary explanations.** -The retina can be settled up with various parameters, by default, the retina cancels mean luminance and enforces all details of the visual scene. In order to use your own parameters, you can use at least one time the *write(std::string fs)* method which will write a proper XML file with all default parameters. Then, tweak it on your own and reload them at any time using method *setup(std::string fs)*. These methods update a *Retina::RetinaParameters* member structure that is described hereafter. :: +The retina can be settled up with various parameters, by default, the retina cancels mean luminance and enforces all details of the visual scene. In order to use your own parameters, you can use at least one time the *write(cv::String fs)* method which will write a proper XML file with all default parameters. Then, tweak it on your own and reload them at any time using method *setup(cv::String fs)*. These methods update a *Retina::RetinaParameters* member structure that is described hereafter. :: class Retina { @@ -49,12 +49,12 @@ The retina can be settled up with various parameters, by default, the retina can Size outputSize (); // setup methods with specific parameters specification of global xml config file loading/write - void setup (std::string retinaParameterFile="", const bool applyDefaultSetupOnFailure=true); + void setup (cv::String retinaParameterFile="", const bool applyDefaultSetupOnFailure=true); void setup (FileStorage &fs, const bool applyDefaultSetupOnFailure=true); void setup (RetinaParameters newParameters); struct Retina::RetinaParameters getParameters (); - const std::string printSetup (); - virtual void write (std::string fs) const; + const cv::String printSetup (); + virtual void write (cv::String fs) const; virtual void write (FileStorage &fs) const; void setupOPLandIPLParvoChannel (const bool colorMode=true, const bool normaliseOutput=true, const float photoreceptorsLocalAdaptationSensitivity=0.7, const float photoreceptorsTemporalConstant=0.5, const float photoreceptorsSpatialConstant=0.53, const float horizontalCellsGain=0, const float HcellsTemporalConstant=1, const float HcellsSpatialConstant=7, const float ganglionCellsSensitivity=0.7); void setupIPLMagnoChannel (const bool normaliseOutput=true, const float parasolCells_beta=0, const float parasolCells_tau=0, const float parasolCells_k=7, const float amacrinCellsTemporalCutFrequency=1.2, const float V0CompressionParameter=0.95, const float localAdaptintegration_tau=0, const float localAdaptintegration_k=7); @@ -235,7 +235,7 @@ Retina::outputSize Retina::printSetup ++++++++++++++++++ -.. ocv:function:: const std::string Retina::printSetup() +.. ocv:function:: const cv::String Retina::printSetup() Outputs a string showing the used parameters setup @@ -264,7 +264,7 @@ Retina::setColorSaturation Retina::setup +++++++++++++ -.. ocv:function:: void Retina::setup(std::string retinaParameterFile = "", const bool applyDefaultSetupOnFailure = true ) +.. ocv:function:: void Retina::setup(cv::String retinaParameterFile = "", const bool applyDefaultSetupOnFailure = true ) .. ocv:function:: void Retina::setup(FileStorage & fs, const bool applyDefaultSetupOnFailure = true ) .. ocv:function:: void Retina::setup(RetinaParameters newParameters) @@ -278,7 +278,7 @@ Retina::setup Retina::write +++++++++++++ -.. ocv:function:: void Retina::write( std::string fs ) const +.. ocv:function:: void Retina::write( cv::String fs ) const .. ocv:function:: void Retina::write( FileStorage& fs ) const Write xml/yml formated parameters information diff --git a/modules/contrib/include/opencv2/contrib.hpp b/modules/contrib/include/opencv2/contrib.hpp index 44bf3313e..a27784ee4 100644 --- a/modules/contrib/include/opencv2/contrib.hpp +++ b/modules/contrib/include/opencv2/contrib.hpp @@ -301,7 +301,7 @@ namespace cv void computeNormals(float normalRadius, int minNeighbors = 20); void computeNormals(const std::vector& subset, float normalRadius, int minNeighbors = 20); - void writeAsVrml(const std::string& file, const std::vector& colors = std::vector()) const; + void writeAsVrml(const cv::String& file, const std::vector& colors = std::vector()) const; std::vector vtx; std::vector normals; @@ -610,9 +610,9 @@ namespace cv class CV_EXPORTS Directory { public: - static std::vector GetListFiles ( const std::string& path, const std::string & exten = "*", bool addPath = true ); - static std::vector GetListFilesR ( const std::string& path, const std::string & exten = "*", bool addPath = true ); - static std::vector GetListFolders( const std::string& path, const std::string & exten = "*", bool addPath = true ); + static std::vector GetListFiles ( const cv::String& path, const cv::String & exten = "*", bool addPath = true ); + static std::vector GetListFilesR ( const cv::String& path, const cv::String & exten = "*", bool addPath = true ); + static std::vector GetListFolders( const cv::String& path, const cv::String & exten = "*", bool addPath = true ); }; /* @@ -869,10 +869,10 @@ namespace cv } // Serializes this object to a given filename. - void save(const std::string& filename) const; + void save(const cv::String& filename) const; // Deserializes this object from a given filename. - void load(const std::string& filename); + void load(const cv::String& filename); // Serializes this object to a given cv::FileStorage. void save(FileStorage& fs) const; @@ -926,10 +926,10 @@ namespace cv CV_WRAP virtual void predict(InputArray src, CV_OUT int &label, CV_OUT double &confidence) const = 0; // Serializes this object to a given filename. - CV_WRAP virtual void save(const std::string& filename) const; + CV_WRAP virtual void save(const cv::String& filename) const; // Deserializes this object from a given filename. - CV_WRAP virtual void load(const std::string& filename); + CV_WRAP virtual void load(const cv::String& filename); // Serializes this object to a given cv::FileStorage. virtual void save(FileStorage& fs) const = 0; diff --git a/modules/contrib/include/opencv2/contrib/retina.hpp b/modules/contrib/include/opencv2/contrib/retina.hpp index 456daab44..f19b8b19d 100644 --- a/modules/contrib/include/opencv2/contrib/retina.hpp +++ b/modules/contrib/include/opencv2/contrib/retina.hpp @@ -182,7 +182,7 @@ public: * @param retinaParameterFile : the parameters filename * @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error */ - void setup(std::string retinaParameterFile="", const bool applyDefaultSetupOnFailure=true); + void setup(cv::String retinaParameterFile="", const bool applyDefaultSetupOnFailure=true); /** @@ -212,13 +212,13 @@ public: * parameters setup display method * @return a string which contains formatted parameters information */ - const std::string printSetup(); + const cv::String printSetup(); /** * write xml/yml formated parameters information * @rparam fs : the filename of the xml file that will be open and writen with formatted parameters information */ - virtual void write( std::string fs ) const; + virtual void write( cv::String fs ) const; /** diff --git a/modules/contrib/src/facerec.cpp b/modules/contrib/src/facerec.cpp index fedaeab88..b987441b9 100644 --- a/modules/contrib/src/facerec.cpp +++ b/modules/contrib/src/facerec.cpp @@ -35,7 +35,7 @@ inline void readFileNodeList(const FileNode& fn, std::vector<_Tp>& result) { // Writes the a list of given items to a cv::FileStorage. template -inline void writeFileNodeList(FileStorage& fs, const std::string& name, +inline void writeFileNodeList(FileStorage& fs, const cv::String& name, const std::vector<_Tp>& items) { // typedefs typedef typename std::vector<_Tp>::const_iterator constVecIterator; @@ -50,7 +50,7 @@ inline void writeFileNodeList(FileStorage& fs, const std::string& name, static Mat asRowMatrix(InputArrayOfArrays src, int rtype, double alpha=1, double beta=0) { // make sure the input data is a vector of matrices or vector of vector if(src.kind() != _InputArray::STD_VECTOR_MAT && src.kind() != _InputArray::STD_VECTOR_VECTOR) { - std::string error_message = "The data is expected as InputArray::STD_VECTOR_MAT (a std::vector) or _InputArray::STD_VECTOR_VECTOR (a std::vector< std::vector<...> >)."; + cv::String error_message = "The data is expected as InputArray::STD_VECTOR_MAT (a std::vector) or _InputArray::STD_VECTOR_VECTOR (a std::vector< std::vector<...> >)."; CV_Error(CV_StsBadArg, error_message); } // number of samples @@ -66,7 +66,7 @@ static Mat asRowMatrix(InputArrayOfArrays src, int rtype, double alpha=1, double for(unsigned int i = 0; i < n; i++) { // make sure data can be reshaped, throw exception if not! if(src.getMat(i).total() != d) { - std::string error_message = format("Wrong number of elements in matrix #%d! Expected %d was %d.", i, d, src.getMat(i).total()); + cv::String error_message = format("Wrong number of elements in matrix #%d! Expected %d was %d.", i, d, src.getMat(i).total()); CV_Error(CV_StsBadArg, error_message); } // get a hold of the current row @@ -305,11 +305,11 @@ void FaceRecognizer::update(InputArrayOfArrays src, InputArray labels ) { return; } - std::string error_msg = format("This FaceRecognizer (%s) does not support updating, you have to use FaceRecognizer::train to update it.", this->name().c_str()); + cv::String error_msg = format("This FaceRecognizer (%s) does not support updating, you have to use FaceRecognizer::train to update it.", this->name().c_str()); CV_Error(CV_StsNotImplemented, error_msg); } -void FaceRecognizer::save(const std::string& filename) const { +void FaceRecognizer::save(const cv::String& filename) const { FileStorage fs(filename, FileStorage::WRITE); if (!fs.isOpened()) CV_Error(CV_StsError, "File can't be opened for writing!"); @@ -317,7 +317,7 @@ void FaceRecognizer::save(const std::string& filename) const { fs.release(); } -void FaceRecognizer::load(const std::string& filename) { +void FaceRecognizer::load(const cv::String& filename) { FileStorage fs(filename, FileStorage::READ); if (!fs.isOpened()) CV_Error(CV_StsError, "File can't be opened for writing!"); @@ -330,17 +330,17 @@ void FaceRecognizer::load(const std::string& filename) { //------------------------------------------------------------------------------ void Eigenfaces::train(InputArrayOfArrays _src, InputArray _local_labels) { if(_src.total() == 0) { - std::string error_message = format("Empty training data was given. You'll need more than one sample to learn a model."); + cv::String error_message = format("Empty training data was given. You'll need more than one sample to learn a model."); CV_Error(CV_StsBadArg, error_message); } else if(_local_labels.getMat().type() != CV_32SC1) { - std::string error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _local_labels.type()); + cv::String error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _local_labels.type()); CV_Error(CV_StsBadArg, error_message); } // make sure data has correct size if(_src.total() > 1) { for(int i = 1; i < static_cast(_src.total()); i++) { if(_src.getMat(i-1).total() != _src.getMat(i).total()) { - std::string error_message = format("In the Eigenfaces method all input samples (training images) must be of equal size! Expected %d pixels, but was %d pixels.", _src.getMat(i-1).total(), _src.getMat(i).total()); + cv::String error_message = format("In the Eigenfaces method all input samples (training images) must be of equal size! Expected %d pixels, but was %d pixels.", _src.getMat(i-1).total(), _src.getMat(i).total()); CV_Error(CV_StsUnsupportedFormat, error_message); } } @@ -354,7 +354,7 @@ void Eigenfaces::train(InputArrayOfArrays _src, InputArray _local_labels) { int n = data.rows; // assert there are as much samples as labels if(static_cast(labels.total()) != n) { - std::string error_message = format("The number of samples (src) must equal the number of labels (labels)! len(src)=%d, len(labels)=%d.", n, labels.total()); + cv::String error_message = format("The number of samples (src) must equal the number of labels (labels)! len(src)=%d, len(labels)=%d.", n, labels.total()); CV_Error(CV_StsBadArg, error_message); } // clear existing model data @@ -385,11 +385,11 @@ void Eigenfaces::predict(InputArray _src, int &minClass, double &minDist) const // make sure the user is passing correct data if(_projections.empty()) { // throw error if no data (or simply return -1?) - std::string error_message = "This Eigenfaces model is not computed yet. Did you call Eigenfaces::train?"; + cv::String error_message = "This Eigenfaces model is not computed yet. Did you call Eigenfaces::train?"; CV_Error(CV_StsError, error_message); } else if(_eigenvectors.rows != static_cast(src.total())) { // check data alignment just for clearer exception messages - std::string error_message = format("Wrong input image size. Reason: Training and Test images must be of equal size! Expected an image with %d elements, but got %d.", _eigenvectors.rows, src.total()); + cv::String error_message = format("Wrong input image size. Reason: Training and Test images must be of equal size! Expected an image with %d elements, but got %d.", _eigenvectors.rows, src.total()); CV_Error(CV_StsBadArg, error_message); } // project into PCA subspace @@ -439,17 +439,17 @@ void Eigenfaces::save(FileStorage& fs) const { //------------------------------------------------------------------------------ void Fisherfaces::train(InputArrayOfArrays src, InputArray _lbls) { if(src.total() == 0) { - std::string error_message = format("Empty training data was given. You'll need more than one sample to learn a model."); + cv::String error_message = format("Empty training data was given. You'll need more than one sample to learn a model."); CV_Error(CV_StsBadArg, error_message); } else if(_lbls.getMat().type() != CV_32SC1) { - std::string error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _lbls.type()); + cv::String error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _lbls.type()); CV_Error(CV_StsBadArg, error_message); } // make sure data has correct size if(src.total() > 1) { for(int i = 1; i < static_cast(src.total()); i++) { if(src.getMat(i-1).total() != src.getMat(i).total()) { - std::string error_message = format("In the Fisherfaces method all input samples (training images) must be of equal size! Expected %d pixels, but was %d pixels.", src.getMat(i-1).total(), src.getMat(i).total()); + cv::String error_message = format("In the Fisherfaces method all input samples (training images) must be of equal size! Expected %d pixels, but was %d pixels.", src.getMat(i-1).total(), src.getMat(i).total()); CV_Error(CV_StsUnsupportedFormat, error_message); } } @@ -461,10 +461,10 @@ void Fisherfaces::train(InputArrayOfArrays src, InputArray _lbls) { int N = data.rows; // make sure labels are passed in correct shape if(labels.total() != (size_t) N) { - std::string error_message = format("The number of samples (src) must equal the number of labels (labels)! len(src)=%d, len(labels)=%d.", N, labels.total()); + cv::String error_message = format("The number of samples (src) must equal the number of labels (labels)! len(src)=%d, len(labels)=%d.", N, labels.total()); CV_Error(CV_StsBadArg, error_message); } else if(labels.rows != 1 && labels.cols != 1) { - std::string error_message = format("Expected the labels in a matrix with one row or column! Given dimensions are rows=%s, cols=%d.", labels.rows, labels.cols); + cv::String error_message = format("Expected the labels in a matrix with one row or column! Given dimensions are rows=%s, cols=%d.", labels.rows, labels.cols); CV_Error(CV_StsBadArg, error_message); } // clear existing model data @@ -505,10 +505,10 @@ void Fisherfaces::predict(InputArray _src, int &minClass, double &minDist) const // check data alignment just for clearer exception messages if(_projections.empty()) { // throw error if no data (or simply return -1?) - std::string error_message = "This Fisherfaces model is not computed yet. Did you call Fisherfaces::train?"; + cv::String error_message = "This Fisherfaces model is not computed yet. Did you call Fisherfaces::train?"; CV_Error(CV_StsBadArg, error_message); } else if(src.total() != (size_t) _eigenvectors.rows) { - std::string error_message = format("Wrong input image size. Reason: Training and Test images must be of equal size! Expected an image with %d elements, but got %d.", _eigenvectors.rows, src.total()); + cv::String error_message = format("Wrong input image size. Reason: Training and Test images must be of equal size! Expected an image with %d elements, but got %d.", _eigenvectors.rows, src.total()); CV_Error(CV_StsBadArg, error_message); } // project into LDA subspace @@ -640,7 +640,7 @@ static void elbp(InputArray src, OutputArray dst, int radius, int neighbors) case CV_32FC1: elbp_(src,dst, radius, neighbors); break; case CV_64FC1: elbp_(src,dst, radius, neighbors); break; default: - std::string error_msg = format("Using Original Local Binary Patterns for feature extraction only works on single-channel images (given %d). Please pass the image data as a grayscale image!", type); + cv::String error_msg = format("Using Original Local Binary Patterns for feature extraction only works on single-channel images (given %d). Please pass the image data as a grayscale image!", type); CV_Error(CV_StsNotImplemented, error_msg); break; } @@ -768,14 +768,14 @@ void LBPH::update(InputArrayOfArrays _in_src, InputArray _in_labels) { void LBPH::train(InputArrayOfArrays _in_src, InputArray _in_labels, bool preserveData) { if(_in_src.kind() != _InputArray::STD_VECTOR_MAT && _in_src.kind() != _InputArray::STD_VECTOR_VECTOR) { - std::string error_message = "The images are expected as InputArray::STD_VECTOR_MAT (a std::vector) or _InputArray::STD_VECTOR_VECTOR (a std::vector< std::vector<...> >)."; + cv::String error_message = "The images are expected as InputArray::STD_VECTOR_MAT (a std::vector) or _InputArray::STD_VECTOR_VECTOR (a std::vector< std::vector<...> >)."; CV_Error(CV_StsBadArg, error_message); } if(_in_src.total() == 0) { - std::string error_message = format("Empty training data was given. You'll need more than one sample to learn a model."); + cv::String error_message = format("Empty training data was given. You'll need more than one sample to learn a model."); CV_Error(CV_StsUnsupportedFormat, error_message); } else if(_in_labels.getMat().type() != CV_32SC1) { - std::string error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _in_labels.type()); + cv::String error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _in_labels.type()); CV_Error(CV_StsUnsupportedFormat, error_message); } // get the vector of matrices @@ -785,7 +785,7 @@ void LBPH::train(InputArrayOfArrays _in_src, InputArray _in_labels, bool preserv Mat labels = _in_labels.getMat(); // check if data is well- aligned if(labels.total() != src.size()) { - std::string error_message = format("The number of samples (src) must equal the number of labels (labels). Was len(samples)=%d, len(labels)=%d.", src.size(), _labels.total()); + cv::String error_message = format("The number of samples (src) must equal the number of labels (labels). Was len(samples)=%d, len(labels)=%d.", src.size(), _labels.total()); CV_Error(CV_StsBadArg, error_message); } // if this model should be trained without preserving old data, delete old model data @@ -816,7 +816,7 @@ void LBPH::train(InputArrayOfArrays _in_src, InputArray _in_labels, bool preserv void LBPH::predict(InputArray _src, int &minClass, double &minDist) const { if(_histograms.empty()) { // throw error if no data (or simply return -1?) - std::string error_message = "This LBPH model is not computed yet. Did you call the train method?"; + cv::String error_message = "This LBPH model is not computed yet. Did you call the train method?"; CV_Error(CV_StsBadArg, error_message); } Mat src = _src.getMat(); diff --git a/modules/contrib/src/inputoutput.cpp b/modules/contrib/src/inputoutput.cpp index ee97e1287..83115e732 100644 --- a/modules/contrib/src/inputoutput.cpp +++ b/modules/contrib/src/inputoutput.cpp @@ -10,11 +10,11 @@ namespace cv { - std::vector Directory::GetListFiles( const std::string& path, const std::string & exten, bool addPath ) + std::vector Directory::GetListFiles( const cv::String& path, const cv::String & exten, bool addPath ) { - std::vector list; + std::vector list; list.clear(); - std::string path_f = path + "/" + exten; + cv::String path_f = path + "/" + exten; #ifdef WIN32 WIN32_FIND_DATA FindFileData; HANDLE hFind; @@ -57,10 +57,10 @@ namespace cv if (dirp->d_type == DT_REG) { if (exten.compare("*") == 0) - list.push_back(static_cast(dirp->d_name)); + list.push_back(static_cast(dirp->d_name)); else - if (std::string(dirp->d_name).find(exten) != std::string::npos) - list.push_back(static_cast(dirp->d_name)); + if (cv::String(dirp->d_name).find(exten) != cv::String::npos) + list.push_back(static_cast(dirp->d_name)); } } closedir(dp); @@ -69,10 +69,10 @@ namespace cv return list; } - std::vector Directory::GetListFolders( const std::string& path, const std::string & exten, bool addPath ) + std::vector Directory::GetListFolders( const cv::String& path, const cv::String & exten, bool addPath ) { - std::vector list; - std::string path_f = path + "/" + exten; + std::vector list; + cv::String path_f = path + "/" + exten; list.clear(); #ifdef WIN32 WIN32_FIND_DATA FindFileData; @@ -117,10 +117,10 @@ namespace cv strcmp(dirp->d_name, "..") != 0 ) { if (exten.compare("*") == 0) - list.push_back(static_cast(dirp->d_name)); + list.push_back(static_cast(dirp->d_name)); else - if (std::string(dirp->d_name).find(exten) != std::string::npos) - list.push_back(static_cast(dirp->d_name)); + if (cv::String(dirp->d_name).find(exten) != cv::String::npos) + list.push_back(static_cast(dirp->d_name)); } } closedir(dp); @@ -129,16 +129,16 @@ namespace cv return list; } - std::vector Directory::GetListFilesR ( const std::string& path, const std::string & exten, bool addPath ) + std::vector Directory::GetListFilesR ( const cv::String& path, const cv::String & exten, bool addPath ) { - std::vector list = Directory::GetListFiles(path, exten, addPath); + std::vector list = Directory::GetListFiles(path, exten, addPath); - std::vector dirs = Directory::GetListFolders(path, exten, addPath); + std::vector dirs = Directory::GetListFolders(path, exten, addPath); - std::vector::const_iterator it; + std::vector::const_iterator it; for (it = dirs.begin(); it != dirs.end(); ++it) { - std::vector cl = Directory::GetListFiles(*it, exten, addPath); + std::vector cl = Directory::GetListFiles(*it, exten, addPath); list.insert(list.end(), cl.begin(), cl.end()); } diff --git a/modules/contrib/src/lda.cpp b/modules/contrib/src/lda.cpp index 442d56750..f18dc1b0d 100644 --- a/modules/contrib/src/lda.cpp +++ b/modules/contrib/src/lda.cpp @@ -42,7 +42,7 @@ static Mat argsort(InputArray _src, bool ascending=true) { Mat src = _src.getMat(); if (src.rows != 1 && src.cols != 1) { - std::string error_message = "Wrong shape of input matrix! Expected a matrix with one row or column."; + cv::String error_message = "Wrong shape of input matrix! Expected a matrix with one row or column."; CV_Error(CV_StsBadArg, error_message); } int flags = CV_SORT_EVERY_ROW+(ascending ? CV_SORT_ASCENDING : CV_SORT_DESCENDING); @@ -54,7 +54,7 @@ static Mat argsort(InputArray _src, bool ascending=true) static Mat asRowMatrix(InputArrayOfArrays src, int rtype, double alpha=1, double beta=0) { // make sure the input data is a vector of matrices or vector of vector if(src.kind() != _InputArray::STD_VECTOR_MAT && src.kind() != _InputArray::STD_VECTOR_VECTOR) { - std::string error_message = "The data is expected as InputArray::STD_VECTOR_MAT (a std::vector) or _InputArray::STD_VECTOR_VECTOR (a std::vector< std::vector<...> >)."; + cv::String error_message = "The data is expected as InputArray::STD_VECTOR_MAT (a std::vector) or _InputArray::STD_VECTOR_VECTOR (a std::vector< std::vector<...> >)."; CV_Error(CV_StsBadArg, error_message); } // number of samples @@ -70,7 +70,7 @@ static Mat asRowMatrix(InputArrayOfArrays src, int rtype, double alpha=1, double for(int i = 0; i < (int)n; i++) { // make sure data can be reshaped, throw exception if not! if(src.getMat(i).total() != d) { - std::string error_message = format("Wrong number of elements in matrix #%d! Expected %d was %d.", i, (int)d, (int)src.getMat(i).total()); + cv::String error_message = format("Wrong number of elements in matrix #%d! Expected %d was %d.", i, (int)d, (int)src.getMat(i).total()); CV_Error(CV_StsBadArg, error_message); } // get a hold of the current row @@ -178,12 +178,12 @@ Mat subspaceProject(InputArray _W, InputArray _mean, InputArray _src) { int d = src.cols; // make sure the data has the correct shape if(W.rows != d) { - std::string error_message = format("Wrong shapes for given matrices. Was size(src) = (%d,%d), size(W) = (%d,%d).", src.rows, src.cols, W.rows, W.cols); + cv::String error_message = format("Wrong shapes for given matrices. Was size(src) = (%d,%d), size(W) = (%d,%d).", src.rows, src.cols, W.rows, W.cols); CV_Error(CV_StsBadArg, error_message); } // make sure mean is correct if not empty if(!mean.empty() && (mean.total() != (size_t) d)) { - std::string error_message = format("Wrong mean shape for the given data matrix. Expected %d, but was %d.", d, mean.total()); + cv::String error_message = format("Wrong mean shape for the given data matrix. Expected %d, but was %d.", d, mean.total()); CV_Error(CV_StsBadArg, error_message); } // create temporary matrices @@ -216,12 +216,12 @@ Mat subspaceReconstruct(InputArray _W, InputArray _mean, InputArray _src) int d = src.cols; // make sure the data has the correct shape if(W.cols != d) { - std::string error_message = format("Wrong shapes for given matrices. Was size(src) = (%d,%d), size(W) = (%d,%d).", src.rows, src.cols, W.rows, W.cols); + cv::String error_message = format("Wrong shapes for given matrices. Was size(src) = (%d,%d), size(W) = (%d,%d).", src.rows, src.cols, W.rows, W.cols); CV_Error(CV_StsBadArg, error_message); } // make sure mean is correct if not empty if(!mean.empty() && (mean.total() != (size_t) W.rows)) { - std::string error_message = format("Wrong mean shape for the given eigenvector matrix. Expected %d, but was %d.", W.cols, mean.total()); + cv::String error_message = format("Wrong mean shape for the given eigenvector matrix. Expected %d, but was %d.", W.cols, mean.total()); CV_Error(CV_StsBadArg, error_message); } // initalize temporary matrices @@ -936,7 +936,7 @@ public: //------------------------------------------------------------------------------ // Linear Discriminant Analysis implementation //------------------------------------------------------------------------------ -void LDA::save(const std::string& filename) const { +void LDA::save(const cv::String& filename) const { FileStorage fs(filename, FileStorage::WRITE); if (!fs.isOpened()) { CV_Error(CV_StsError, "File can't be opened for writing!"); @@ -946,7 +946,7 @@ void LDA::save(const std::string& filename) const { } // Deserializes this object from a given filename. -void LDA::load(const std::string& filename) { +void LDA::load(const cv::String& filename) { FileStorage fs(filename, FileStorage::READ); if (!fs.isOpened()) CV_Error(CV_StsError, "File can't be opened for writing!"); @@ -1001,12 +1001,12 @@ void LDA::lda(InputArrayOfArrays _src, InputArray _lbls) { // we can't do a LDA on one class, what do you // want to separate from each other then? if(C == 1) { - std::string error_message = "At least two classes are needed to perform a LDA. Reason: Only one class was given!"; + cv::String error_message = "At least two classes are needed to perform a LDA. Reason: Only one class was given!"; CV_Error(CV_StsBadArg, error_message); } // throw error if less labels, than samples if (labels.size() != static_cast(N)) { - std::string error_message = format("The number of samples must equal the number of labels. Given %d labels, %d samples. ", labels.size(), N); + cv::String error_message = format("The number of samples must equal the number of labels. Given %d labels, %d samples. ", labels.size(), N); CV_Error(CV_StsBadArg, error_message); } // warn if within-classes scatter matrix becomes singular @@ -1089,7 +1089,7 @@ void LDA::compute(InputArrayOfArrays _src, InputArray _lbls) { lda(_src.getMat(), _lbls); break; default: - std::string error_message= format("InputArray Datatype %d is not supported.", _src.kind()); + cv::String error_message= format("InputArray Datatype %d is not supported.", _src.kind()); CV_Error(CV_StsBadArg, error_message); break; } diff --git a/modules/contrib/src/retina.cpp b/modules/contrib/src/retina.cpp index 146489687..c19f84b9c 100644 --- a/modules/contrib/src/retina.cpp +++ b/modules/contrib/src/retina.cpp @@ -70,7 +70,7 @@ */ #include "precomp.hpp" #include "retinafilter.hpp" -#include +#include namespace cv { @@ -112,25 +112,26 @@ void Retina::setColorSaturation(const bool saturateColors, const float colorSatu struct Retina::RetinaParameters Retina::getParameters(){return _retinaParameters;} -void Retina::setup(std::string retinaParameterFile, const bool applyDefaultSetupOnFailure) +void Retina::setup(cv::String retinaParameterFile, const bool applyDefaultSetupOnFailure) { try { // opening retinaParameterFile in read mode cv::FileStorage fs(retinaParameterFile, cv::FileStorage::READ); setup(fs, applyDefaultSetupOnFailure); - }catch(Exception &e) - { - std::cout<<"Retina::setup: wrong/unappropriate xml parameter file : error report :`n=>"<%s\n", e.what()); + if (applyDefaultSetupOnFailure) + { + printf("Retina::setup: resetting retina with default parameters\n"); + setupOPLandIPLParvoChannel(); + setupIPLMagnoChannel(); + } else { - std::cout<<"=> keeping current parameters"< keeping current parameters\n"); } } } @@ -142,7 +143,7 @@ void Retina::setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure) // read parameters file if it exists or apply default setup if asked for if (!fs.isOpened()) { - std::cout<<"Retina::setup: provided parameters file could not be open... skeeping configuration"<"< keeping current parameters"<%s\n", e.what()); + printf("=> keeping current parameters\n"); } // report current configuration - std::cout< localAdaptintegration_tau : " << _retinaParameters.IplMagno.localAdaptintegration_tau << "\n==> localAdaptintegration_k : " << _retinaParameters.IplMagno.localAdaptintegration_k <<"}"; - return outmessage.str(); + return outmessage.str().c_str(); } -void Retina::write( std::string fs ) const +void Retina::write( cv::String fs ) const { FileStorage parametersSaveFile(fs, cv::FileStorage::WRITE ); write(parametersSaveFile); @@ -364,7 +365,7 @@ void Retina::_init(const cv::Size inputSz, const bool colorMode, RETINA_COLORSAM _retinaFilter->clearAllBuffers(); // report current configuration - std::cout< &grayMatrixToConvert, const unsigned int nbRows, const unsigned int nbColumns, const bool colorMode, cv::Mat &outBuffer) diff --git a/modules/contrib/src/spinimages.cpp b/modules/contrib/src/spinimages.cpp index 7f7a8ad63..5e01536ba 100644 --- a/modules/contrib/src/spinimages.cpp +++ b/modules/contrib/src/spinimages.cpp @@ -494,7 +494,7 @@ void cv::Mesh3D::computeNormals(const std::vector& subset, float normalRadi ::computeNormals(octree, vtx, normals, mask, normalRadius, minNeighbors); } -void cv::Mesh3D::writeAsVrml(const std::string& file, const std::vector& _colors) const +void cv::Mesh3D::writeAsVrml(const cv::String& file, const std::vector& _colors) const { std::ofstream ofs(file.c_str()); diff --git a/modules/gpu/doc/video.rst b/modules/gpu/doc/video.rst index 284bb17fa..aca0f527c 100644 --- a/modules/gpu/doc/video.rst +++ b/modules/gpu/doc/video.rst @@ -704,8 +704,8 @@ gpu::VideoWriter_GPU::VideoWriter_GPU Constructors. .. ocv:function:: gpu::VideoWriter_GPU::VideoWriter_GPU() -.. ocv:function:: gpu::VideoWriter_GPU::VideoWriter_GPU(const std::string& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR) -.. ocv:function:: gpu::VideoWriter_GPU::VideoWriter_GPU(const std::string& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR) +.. ocv:function:: gpu::VideoWriter_GPU::VideoWriter_GPU(const cv::String& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR) +.. ocv:function:: gpu::VideoWriter_GPU::VideoWriter_GPU(const cv::String& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR) .. ocv:function:: gpu::VideoWriter_GPU::VideoWriter_GPU(const cv::Ptr& encoderCallback, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR) .. ocv:function:: gpu::VideoWriter_GPU::VideoWriter_GPU(const cv::Ptr& encoderCallback, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR) @@ -729,8 +729,8 @@ gpu::VideoWriter_GPU::open -------------------------- Initializes or reinitializes video writer. -.. ocv:function:: void gpu::VideoWriter_GPU::open(const std::string& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR) -.. ocv:function:: void gpu::VideoWriter_GPU::open(const std::string& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR) +.. ocv:function:: void gpu::VideoWriter_GPU::open(const cv::String& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR) +.. ocv:function:: void gpu::VideoWriter_GPU::open(const cv::String& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR) .. ocv:function:: void gpu::VideoWriter_GPU::open(const cv::Ptr& encoderCallback, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR) .. ocv:function:: void gpu::VideoWriter_GPU::open(const cv::Ptr& encoderCallback, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR) @@ -797,10 +797,10 @@ Different parameters for CUDA video encoder. :: int DisableSPSPPS; // NVVE_DISABLE_SPS_PPS EncoderParams(); - explicit EncoderParams(const std::string& configFile); + explicit EncoderParams(const cv::String& configFile); - void load(const std::string& configFile); - void save(const std::string& configFile) const; + void load(const cv::String& configFile); + void save(const cv::String& configFile) const; }; @@ -810,7 +810,7 @@ gpu::VideoWriter_GPU::EncoderParams::EncoderParams Constructors. .. ocv:function:: gpu::VideoWriter_GPU::EncoderParams::EncoderParams() -.. ocv:function:: gpu::VideoWriter_GPU::EncoderParams::EncoderParams(const std::string& configFile) +.. ocv:function:: gpu::VideoWriter_GPU::EncoderParams::EncoderParams(const cv::String& configFile) :param configFile: Config file name. @@ -822,7 +822,7 @@ gpu::VideoWriter_GPU::EncoderParams::load ----------------------------------------- Reads parameters from config file. -.. ocv:function:: void gpu::VideoWriter_GPU::EncoderParams::load(const std::string& configFile) +.. ocv:function:: void gpu::VideoWriter_GPU::EncoderParams::load(const cv::String& configFile) :param configFile: Config file name. @@ -832,7 +832,7 @@ gpu::VideoWriter_GPU::EncoderParams::save ----------------------------------------- Saves parameters to config file. -.. ocv:function:: void gpu::VideoWriter_GPU::EncoderParams::save(const std::string& configFile) const +.. ocv:function:: void gpu::VideoWriter_GPU::EncoderParams::save(const cv::String& configFile) const :param configFile: Config file name. @@ -982,7 +982,7 @@ gpu::VideoReader_GPU::VideoReader_GPU Constructors. .. ocv:function:: gpu::VideoReader_GPU::VideoReader_GPU() -.. ocv:function:: gpu::VideoReader_GPU::VideoReader_GPU(const std::string& filename) +.. ocv:function:: gpu::VideoReader_GPU::VideoReader_GPU(const cv::String& filename) .. ocv:function:: gpu::VideoReader_GPU::VideoReader_GPU(const cv::Ptr& source) :param filename: Name of the input video file. @@ -997,7 +997,7 @@ gpu::VideoReader_GPU::open -------------------------- Initializes or reinitializes video reader. -.. ocv:function:: void gpu::VideoReader_GPU::open(const std::string& filename) +.. ocv:function:: void gpu::VideoReader_GPU::open(const cv::String& filename) .. ocv:function:: void gpu::VideoReader_GPU::open(const cv::Ptr& source) The method opens video reader. Parameters are the same as in the constructor :ocv:func:`gpu::VideoReader_GPU::VideoReader_GPU` . The method throws :ocv:class:`Exception` if error occurs. diff --git a/modules/gpu/include/opencv2/gpu.hpp b/modules/gpu/include/opencv2/gpu.hpp index e0933342b..6f06791bf 100644 --- a/modules/gpu/include/opencv2/gpu.hpp +++ b/modules/gpu/include/opencv2/gpu.hpp @@ -1384,11 +1384,11 @@ class CV_EXPORTS CascadeClassifier_GPU { public: CascadeClassifier_GPU(); - CascadeClassifier_GPU(const std::string& filename); + CascadeClassifier_GPU(const cv::String& filename); ~CascadeClassifier_GPU(); bool empty() const; - bool load(const std::string& filename); + bool load(const cv::String& filename); void release(); /* returns number of detected objects */ @@ -2170,15 +2170,15 @@ public: }; VideoWriter_GPU(); - VideoWriter_GPU(const std::string& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR); - VideoWriter_GPU(const std::string& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR); + VideoWriter_GPU(const cv::String& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR); + VideoWriter_GPU(const cv::String& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR); VideoWriter_GPU(const cv::Ptr& encoderCallback, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR); VideoWriter_GPU(const cv::Ptr& encoderCallback, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR); ~VideoWriter_GPU(); // all methods throws cv::Exception if error occurs - void open(const std::string& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR); - void open(const std::string& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR); + void open(const cv::String& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR); + void open(const cv::String& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR); void open(const cv::Ptr& encoderCallback, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR); void open(const cv::Ptr& encoderCallback, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR); @@ -2210,10 +2210,10 @@ public: int DisableSPSPPS; // NVVE_DISABLE_SPS_PPS EncoderParams(); - explicit EncoderParams(const std::string& configFile); + explicit EncoderParams(const cv::String& configFile); - void load(const std::string& configFile); - void save(const std::string& configFile) const; + void load(const cv::String& configFile); + void save(const cv::String& configFile) const; }; EncoderParams getParams() const; @@ -2301,12 +2301,12 @@ public: class VideoSource; VideoReader_GPU(); - explicit VideoReader_GPU(const std::string& filename); + explicit VideoReader_GPU(const cv::String& filename); explicit VideoReader_GPU(const cv::Ptr& source); ~VideoReader_GPU(); - void open(const std::string& filename); + void open(const cv::String& filename); void open(const cv::Ptr& source); bool isOpened() const; diff --git a/modules/gpu/src/cascadeclassifier.cpp b/modules/gpu/src/cascadeclassifier.cpp index e82ee9d33..3ac211962 100644 --- a/modules/gpu/src/cascadeclassifier.cpp +++ b/modules/gpu/src/cascadeclassifier.cpp @@ -50,10 +50,10 @@ using namespace cv::gpu; #if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU() { throw_nogpu(); } -cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU(const std::string&) { throw_nogpu(); } +cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU(const cv::String&) { throw_nogpu(); } cv::gpu::CascadeClassifier_GPU::~CascadeClassifier_GPU() { throw_nogpu(); } bool cv::gpu::CascadeClassifier_GPU::empty() const { throw_nogpu(); return true; } -bool cv::gpu::CascadeClassifier_GPU::load(const std::string&) { throw_nogpu(); return true; } +bool cv::gpu::CascadeClassifier_GPU::load(const cv::String&) { throw_nogpu(); return true; } Size cv::gpu::CascadeClassifier_GPU::getClassifierSize() const { throw_nogpu(); return Size();} void cv::gpu::CascadeClassifier_GPU::release() { throw_nogpu(); } int cv::gpu::CascadeClassifier_GPU::detectMultiScale( const GpuMat&, GpuMat&, double, int, Size) {throw_nogpu(); return -1;} @@ -71,7 +71,7 @@ public: bool findLargestObject, bool visualizeInPlace, cv::Size ncvMinSize, cv::Size maxObjectSize) = 0; virtual cv::Size getClassifierCvSize() const = 0; - virtual bool read(const std::string& classifierAsXml) = 0; + virtual bool read(const cv::String& classifierAsXml) = 0; }; struct cv::gpu::CascadeClassifier_GPU::HaarCascade : cv::gpu::CascadeClassifier_GPU::CascadeClassifierImpl @@ -82,7 +82,7 @@ public: ncvSetDebugOutputHandler(NCVDebugOutputHandler); } - bool read(const std::string& filename) + bool read(const cv::String& filename) { ncvSafeCall( load(filename) ); return true; @@ -169,9 +169,9 @@ public: cv::Size getClassifierCvSize() const { return cv::Size(haar.ClassifierSize.width, haar.ClassifierSize.height); } private: - static void NCVDebugOutputHandler(const std::string &msg) { CV_Error(CV_GpuApiCallError, msg.c_str()); } + static void NCVDebugOutputHandler(const cv::String &msg) { CV_Error(CV_GpuApiCallError, msg.c_str()); } - NCVStatus load(const std::string& classifierFile) + NCVStatus load(const cv::String& classifierFile) { int devId = cv::gpu::getDevice(); ncvAssertCUDAReturn(cudaGetDeviceProperties(&devProp, devId), NCV_CUDA_ERROR); @@ -458,7 +458,7 @@ public: virtual cv::Size getClassifierCvSize() const { return NxM; } - bool read(const std::string& classifierAsXml) + bool read(const cv::String& classifierAsXml) { FileStorage fs(classifierAsXml, FileStorage::READ); return fs.isOpened() ? read(fs.getFirstTopLevelNode()) : false; @@ -512,10 +512,10 @@ private: const char *GPU_CC_FEATURES = "features"; const char *GPU_CC_RECT = "rect"; - std::string stageTypeStr = (std::string)root[GPU_CC_STAGE_TYPE]; + cv::String stageTypeStr = (cv::String)root[GPU_CC_STAGE_TYPE]; CV_Assert(stageTypeStr == GPU_CC_BOOST); - std::string featureTypeStr = (std::string)root[GPU_CC_FEATURE_TYPE]; + cv::String featureTypeStr = (cv::String)root[GPU_CC_FEATURE_TYPE]; CV_Assert(featureTypeStr == GPU_CC_LBP); NxM.width = (int)root[GPU_CC_WIDTH]; @@ -662,7 +662,7 @@ private: cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU() : findLargestObject(false), visualizeInPlace(false), impl(0) {} -cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU(const std::string& filename) +cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU(const cv::String& filename) : findLargestObject(false), visualizeInPlace(false), impl(0) { load(filename); } cv::gpu::CascadeClassifier_GPU::~CascadeClassifier_GPU() { release(); } @@ -688,11 +688,11 @@ int cv::gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat return impl->process(image, objectsBuf, (float)scaleFactor, minNeighbors, findLargestObject, visualizeInPlace, minSize, maxObjectSize); } -bool cv::gpu::CascadeClassifier_GPU::load(const std::string& filename) +bool cv::gpu::CascadeClassifier_GPU::load(const cv::String& filename) { release(); - std::string fext = filename.substr(filename.find_last_of(".") + 1); + cv::String fext = filename.substr(filename.find_last_of(".") + 1); std::transform(fext.begin(), fext.end(), fext.begin(), ::tolower); if (fext == "nvbin") @@ -710,7 +710,7 @@ bool cv::gpu::CascadeClassifier_GPU::load(const std::string& filename) } const char *GPU_CC_LBP = "LBP"; - std::string featureTypeStr = (std::string)fs.getFirstTopLevelNode()["featureType"]; + cv::String featureTypeStr = (cv::String)fs.getFirstTopLevelNode()["featureType"]; if (featureTypeStr == GPU_CC_LBP) impl = new LbpCascade(); else @@ -759,7 +759,7 @@ void groupRectangles(std::vector &hypotheses, int groupThreshold, do hypotheses.resize(rects.size()); } -NCVStatus loadFromXML(const std::string &filename, +NCVStatus loadFromXML(const cv::String &filename, HaarClassifierCascadeDescriptor &haar, std::vector &haarStages, std::vector &haarClassifierNodes, diff --git a/modules/gpu/src/cu_safe_call.cpp b/modules/gpu/src/cu_safe_call.cpp index 7218873df..f2c684408 100644 --- a/modules/gpu/src/cu_safe_call.cpp +++ b/modules/gpu/src/cu_safe_call.cpp @@ -51,7 +51,7 @@ namespace struct ErrorEntry { int code; - std::string str; + cv::String str; }; class ErrorEntryComparer @@ -65,11 +65,11 @@ namespace int code_; }; - std::string getErrorString(int code, const ErrorEntry* errors, size_t n) + cv::String getErrorString(int code, const ErrorEntry* errors, size_t n) { size_t idx = std::find_if(errors, errors + n, ErrorEntryComparer(code)) - errors; - const std::string& msg = (idx != n) ? errors[idx].str : std::string("Unknown error code"); + const cv::String& msg = (idx != n) ? errors[idx].str : cv::String("Unknown error code"); std::ostringstream ostr; ostr << msg << " [Code = " << code << "]"; @@ -131,7 +131,7 @@ namespace const size_t cu_errors_num = sizeof(cu_errors) / sizeof(cu_errors[0]); } -std::string cv::gpu::detail::cuGetErrString(CUresult res) +cv::String cv::gpu::detail::cuGetErrString(CUresult res) { return getErrorString(res, cu_errors, cu_errors_num); } diff --git a/modules/gpu/src/cu_safe_call.h b/modules/gpu/src/cu_safe_call.h index 6f93adc76..12c15d4fe 100644 --- a/modules/gpu/src/cu_safe_call.h +++ b/modules/gpu/src/cu_safe_call.h @@ -50,7 +50,7 @@ namespace cv { namespace gpu { namespace detail { - std::string cuGetErrString(CUresult res); + cv::String cuGetErrString(CUresult res); inline void cuSafeCall_impl(CUresult res, const char* file, int line) { diff --git a/modules/gpu/src/cuvid_video_source.cpp b/modules/gpu/src/cuvid_video_source.cpp index 7d45b8fee..b637ce4af 100644 --- a/modules/gpu/src/cuvid_video_source.cpp +++ b/modules/gpu/src/cuvid_video_source.cpp @@ -3,7 +3,7 @@ #if defined(HAVE_CUDA) && defined(HAVE_NVCUVID) -cv::gpu::detail::CuvidVideoSource::CuvidVideoSource(const std::string& fname) +cv::gpu::detail::CuvidVideoSource::CuvidVideoSource(const cv::String& fname) { CUVIDSOURCEPARAMS params; std::memset(¶ms, 0, sizeof(CUVIDSOURCEPARAMS)); diff --git a/modules/gpu/src/cuvid_video_source.h b/modules/gpu/src/cuvid_video_source.h index 1c4c0e5e0..9a246d747 100644 --- a/modules/gpu/src/cuvid_video_source.h +++ b/modules/gpu/src/cuvid_video_source.h @@ -54,7 +54,7 @@ namespace cv { namespace gpu class CuvidVideoSource : public VideoReader_GPU::VideoSource { public: - explicit CuvidVideoSource(const std::string& fname); + explicit CuvidVideoSource(const cv::String& fname); ~CuvidVideoSource() { cuvidDestroyVideoSource(videoSource_); } VideoReader_GPU::FormatInfo format() const; diff --git a/modules/gpu/src/error.cpp b/modules/gpu/src/error.cpp index e01be8010..11e28c729 100644 --- a/modules/gpu/src/error.cpp +++ b/modules/gpu/src/error.cpp @@ -54,7 +54,7 @@ namespace struct ErrorEntry { int code; - std::string str; + cv::String str; }; struct ErrorEntryComparer @@ -64,11 +64,11 @@ namespace bool operator()(const ErrorEntry& e) const { return e.code == code; } }; - std::string getErrorString(int code, const ErrorEntry* errors, size_t n) + cv::String getErrorString(int code, const ErrorEntry* errors, size_t n) { size_t idx = std::find_if(errors, errors + n, ErrorEntryComparer(code)) - errors; - const std::string& msg = (idx != n) ? errors[idx].str : std::string("Unknown error code"); + const cv::String& msg = (idx != n) ? errors[idx].str : cv::String("Unknown error code"); std::ostringstream ostr; ostr << msg << " [Code = " << code << "]"; @@ -221,25 +221,25 @@ namespace cv { void nppError(int code, const char *file, const int line, const char *func) { - std::string msg = getErrorString(code, npp_errors, npp_error_num); + cv::String msg = getErrorString(code, npp_errors, npp_error_num); cv::gpu::error(msg.c_str(), file, line, func); } void ncvError(int code, const char *file, const int line, const char *func) { - std::string msg = getErrorString(code, ncv_errors, ncv_error_num); + cv::String msg = getErrorString(code, ncv_errors, ncv_error_num); cv::gpu::error(msg.c_str(), file, line, func); } void cufftError(int code, const char *file, const int line, const char *func) { - std::string msg = getErrorString(code, cufft_errors, cufft_error_num); + cv::String msg = getErrorString(code, cufft_errors, cufft_error_num); cv::gpu::error(msg.c_str(), file, line, func); } void cublasError(int code, const char *file, const int line, const char *func) { - std::string msg = getErrorString(code, cublas_errors, cublas_error_num); + cv::String msg = getErrorString(code, cublas_errors, cublas_error_num); cv::gpu::error(msg.c_str(), file, line, func); } } diff --git a/modules/gpu/src/ffmpeg_video_source.cpp b/modules/gpu/src/ffmpeg_video_source.cpp index bd3d70058..625d8dd79 100644 --- a/modules/gpu/src/ffmpeg_video_source.cpp +++ b/modules/gpu/src/ffmpeg_video_source.cpp @@ -96,7 +96,7 @@ namespace } } -cv::gpu::detail::FFmpegVideoSource::FFmpegVideoSource(const std::string& fname) : +cv::gpu::detail::FFmpegVideoSource::FFmpegVideoSource(const cv::String& fname) : stream_(0) { CV_Assert( init_MediaStream_FFMPEG() ); diff --git a/modules/gpu/src/ffmpeg_video_source.h b/modules/gpu/src/ffmpeg_video_source.h index 41bf0cfd0..b08a6b370 100644 --- a/modules/gpu/src/ffmpeg_video_source.h +++ b/modules/gpu/src/ffmpeg_video_source.h @@ -57,7 +57,7 @@ namespace cv { namespace gpu class FFmpegVideoSource : public VideoReader_GPU::VideoSource { public: - FFmpegVideoSource(const std::string& fname); + FFmpegVideoSource(const cv::String& fname); ~FFmpegVideoSource(); VideoReader_GPU::FormatInfo format() const; diff --git a/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu b/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu index fb057ae79..f2f318152 100644 --- a/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu +++ b/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu @@ -2099,7 +2099,7 @@ NCVStatus ncvGrowDetectionsVector_host(NCVVector &pixelMask, } -NCVStatus loadFromXML(const std::string &filename, +NCVStatus loadFromXML(const cv::String &filename, HaarClassifierCascadeDescriptor &haar, std::vector &haarStages, std::vector &haarClassifierNodes, @@ -2110,7 +2110,7 @@ NCVStatus loadFromXML(const std::string &filename, #define NVBIN_HAAR_VERSION 0x1 -static NCVStatus loadFromNVBIN(const std::string &filename, +static NCVStatus loadFromNVBIN(const cv::String &filename, HaarClassifierCascadeDescriptor &haar, std::vector &haarStages, std::vector &haarClassifierNodes, @@ -2174,13 +2174,13 @@ static NCVStatus loadFromNVBIN(const std::string &filename, } -NCVStatus ncvHaarGetClassifierSize(const std::string &filename, Ncv32u &numStages, +NCVStatus ncvHaarGetClassifierSize(const cv::String &filename, Ncv32u &numStages, Ncv32u &numNodes, Ncv32u &numFeatures) { size_t readCount; NCVStatus ncvStat; - std::string fext = filename.substr(filename.find_last_of(".") + 1); + cv::String fext = filename.substr(filename.find_last_of(".") + 1); std::transform(fext.begin(), fext.end(), fext.begin(), ::tolower); if (fext == "nvbin") @@ -2226,7 +2226,7 @@ NCVStatus ncvHaarGetClassifierSize(const std::string &filename, Ncv32u &numStage } -NCVStatus ncvHaarLoadFromFile_host(const std::string &filename, +NCVStatus ncvHaarLoadFromFile_host(const cv::String &filename, HaarClassifierCascadeDescriptor &haar, NCVVector &h_HaarStages, NCVVector &h_HaarNodes, @@ -2238,7 +2238,7 @@ NCVStatus ncvHaarLoadFromFile_host(const std::string &filename, NCVStatus ncvStat; - std::string fext = filename.substr(filename.find_last_of(".") + 1); + cv::String fext = filename.substr(filename.find_last_of(".") + 1); std::transform(fext.begin(), fext.end(), fext.begin(), ::tolower); std::vector haarStages; @@ -2272,7 +2272,7 @@ NCVStatus ncvHaarLoadFromFile_host(const std::string &filename, } -NCVStatus ncvHaarStoreNVBIN_host(const std::string &filename, +NCVStatus ncvHaarStoreNVBIN_host(const cv::String &filename, HaarClassifierCascadeDescriptor haar, NCVVector &h_HaarStages, NCVVector &h_HaarNodes, diff --git a/modules/gpu/src/nvidia/NCVHaarObjectDetection.hpp b/modules/gpu/src/nvidia/NCVHaarObjectDetection.hpp index 9f29206f0..b11256641 100644 --- a/modules/gpu/src/nvidia/NCVHaarObjectDetection.hpp +++ b/modules/gpu/src/nvidia/NCVHaarObjectDetection.hpp @@ -439,18 +439,18 @@ NCV_EXPORTS NCVStatus ncvGrowDetectionsVector_host(NCVVector &pixelMask, Ncv32f curScale); -NCV_EXPORTS NCVStatus ncvHaarGetClassifierSize(const std::string &filename, Ncv32u &numStages, +NCV_EXPORTS NCVStatus ncvHaarGetClassifierSize(const cv::String &filename, Ncv32u &numStages, Ncv32u &numNodes, Ncv32u &numFeatures); -NCV_EXPORTS NCVStatus ncvHaarLoadFromFile_host(const std::string &filename, +NCV_EXPORTS NCVStatus ncvHaarLoadFromFile_host(const cv::String &filename, HaarClassifierCascadeDescriptor &haar, NCVVector &h_HaarStages, NCVVector &h_HaarNodes, NCVVector &h_HaarFeatures); -NCV_EXPORTS NCVStatus ncvHaarStoreNVBIN_host(const std::string &filename, +NCV_EXPORTS NCVStatus ncvHaarStoreNVBIN_host(const cv::String &filename, HaarClassifierCascadeDescriptor haar, NCVVector &h_HaarStages, NCVVector &h_HaarNodes, diff --git a/modules/gpu/src/nvidia/core/NCV.cu b/modules/gpu/src/nvidia/core/NCV.cu index 77e59cc5c..f1b2194f8 100644 --- a/modules/gpu/src/nvidia/core/NCV.cu +++ b/modules/gpu/src/nvidia/core/NCV.cu @@ -53,7 +53,7 @@ //============================================================================== -static void stdDebugOutput(const std::string &msg) +static void stdDebugOutput(const cv::String &msg) { std::cout << msg; } @@ -62,7 +62,7 @@ static void stdDebugOutput(const std::string &msg) static NCVDebugOutputHandler *debugOutputHandler = stdDebugOutput; -void ncvDebugOutput(const std::string &msg) +void ncvDebugOutput(const cv::String &msg) { debugOutputHandler(msg); } diff --git a/modules/gpu/src/nvidia/core/NCV.hpp b/modules/gpu/src/nvidia/core/NCV.hpp index 703cb827b..12ef4e77d 100644 --- a/modules/gpu/src/nvidia/core/NCV.hpp +++ b/modules/gpu/src/nvidia/core/NCV.hpp @@ -243,10 +243,10 @@ const Ncv32u K_LOG2_WARP_SIZE = 5; //============================================================================== -NCV_EXPORTS void ncvDebugOutput(const std::string &msg); +NCV_EXPORTS void ncvDebugOutput(const cv::String &msg); -typedef void NCVDebugOutputHandler(const std::string &msg); +typedef void NCVDebugOutputHandler(const cv::String &msg); NCV_EXPORTS void ncvSetDebugOutputHandler(NCVDebugOutputHandler* func); diff --git a/modules/gpu/src/optical_flow.cpp b/modules/gpu/src/optical_flow.cpp index 3d8fc05ec..ce90ba7f3 100644 --- a/modules/gpu/src/optical_flow.cpp +++ b/modules/gpu/src/optical_flow.cpp @@ -68,7 +68,7 @@ namespace namespace { - static void outputHandler(const std::string &msg) { CV_Error(CV_GpuApiCallError, msg.c_str()); } + static void outputHandler(const cv::String &msg) { CV_Error(CV_GpuApiCallError, msg.c_str()); } } void cv::gpu::BroxOpticalFlow::operator ()(const GpuMat& frame0, const GpuMat& frame1, GpuMat& u, GpuMat& v, Stream& s) diff --git a/modules/gpu/src/video_reader.cpp b/modules/gpu/src/video_reader.cpp index 3224902c6..e46fc9bc9 100644 --- a/modules/gpu/src/video_reader.cpp +++ b/modules/gpu/src/video_reader.cpp @@ -49,10 +49,10 @@ class cv::gpu::VideoReader_GPU::Impl }; cv::gpu::VideoReader_GPU::VideoReader_GPU() { throw_nogpu(); } -cv::gpu::VideoReader_GPU::VideoReader_GPU(const std::string&) { throw_nogpu(); } +cv::gpu::VideoReader_GPU::VideoReader_GPU(const cv::String&) { throw_nogpu(); } cv::gpu::VideoReader_GPU::VideoReader_GPU(const cv::Ptr&) { throw_nogpu(); } cv::gpu::VideoReader_GPU::~VideoReader_GPU() { } -void cv::gpu::VideoReader_GPU::open(const std::string&) { throw_nogpu(); } +void cv::gpu::VideoReader_GPU::open(const cv::String&) { throw_nogpu(); } void cv::gpu::VideoReader_GPU::open(const cv::Ptr&) { throw_nogpu(); } bool cv::gpu::VideoReader_GPU::isOpened() const { return false; } void cv::gpu::VideoReader_GPU::close() { } @@ -294,7 +294,7 @@ cv::gpu::VideoReader_GPU::VideoReader_GPU() { } -cv::gpu::VideoReader_GPU::VideoReader_GPU(const std::string& filename) +cv::gpu::VideoReader_GPU::VideoReader_GPU(const cv::String& filename) { open(filename); } @@ -309,7 +309,7 @@ cv::gpu::VideoReader_GPU::~VideoReader_GPU() close(); } -void cv::gpu::VideoReader_GPU::open(const std::string& filename) +void cv::gpu::VideoReader_GPU::open(const cv::String& filename) { CV_Assert( !filename.empty() ); diff --git a/modules/gpu/src/video_writer.cpp b/modules/gpu/src/video_writer.cpp index fe44a16f7..797d4ffc9 100644 --- a/modules/gpu/src/video_writer.cpp +++ b/modules/gpu/src/video_writer.cpp @@ -49,13 +49,13 @@ class cv::gpu::VideoWriter_GPU::Impl }; cv::gpu::VideoWriter_GPU::VideoWriter_GPU() { throw_nogpu(); } -cv::gpu::VideoWriter_GPU::VideoWriter_GPU(const std::string&, cv::Size, double, SurfaceFormat) { throw_nogpu(); } -cv::gpu::VideoWriter_GPU::VideoWriter_GPU(const std::string&, cv::Size, double, const EncoderParams&, SurfaceFormat) { throw_nogpu(); } +cv::gpu::VideoWriter_GPU::VideoWriter_GPU(const cv::String&, cv::Size, double, SurfaceFormat) { throw_nogpu(); } +cv::gpu::VideoWriter_GPU::VideoWriter_GPU(const cv::String&, cv::Size, double, const EncoderParams&, SurfaceFormat) { throw_nogpu(); } cv::gpu::VideoWriter_GPU::VideoWriter_GPU(const cv::Ptr&, cv::Size, double, SurfaceFormat) { throw_nogpu(); } cv::gpu::VideoWriter_GPU::VideoWriter_GPU(const cv::Ptr&, cv::Size, double, const EncoderParams&, SurfaceFormat) { throw_nogpu(); } cv::gpu::VideoWriter_GPU::~VideoWriter_GPU() {} -void cv::gpu::VideoWriter_GPU::open(const std::string&, cv::Size, double, SurfaceFormat) { throw_nogpu(); } -void cv::gpu::VideoWriter_GPU::open(const std::string&, cv::Size, double, const EncoderParams&, SurfaceFormat) { throw_nogpu(); } +void cv::gpu::VideoWriter_GPU::open(const cv::String&, cv::Size, double, SurfaceFormat) { throw_nogpu(); } +void cv::gpu::VideoWriter_GPU::open(const cv::String&, cv::Size, double, const EncoderParams&, SurfaceFormat) { throw_nogpu(); } void cv::gpu::VideoWriter_GPU::open(const cv::Ptr&, cv::Size, double, SurfaceFormat) { throw_nogpu(); } void cv::gpu::VideoWriter_GPU::open(const cv::Ptr&, cv::Size, double, const EncoderParams&, SurfaceFormat) { throw_nogpu(); } bool cv::gpu::VideoWriter_GPU::isOpened() const { return false; } @@ -64,9 +64,9 @@ void cv::gpu::VideoWriter_GPU::write(const cv::gpu::GpuMat&, bool) { throw_nogpu cv::gpu::VideoWriter_GPU::EncoderParams cv::gpu::VideoWriter_GPU::getParams() const { EncoderParams params; throw_nogpu(); return params; } cv::gpu::VideoWriter_GPU::EncoderParams::EncoderParams() { throw_nogpu(); } -cv::gpu::VideoWriter_GPU::EncoderParams::EncoderParams(const std::string&) { throw_nogpu(); } -void cv::gpu::VideoWriter_GPU::EncoderParams::load(const std::string&) { throw_nogpu(); } -void cv::gpu::VideoWriter_GPU::EncoderParams::save(const std::string&) const { throw_nogpu(); } +cv::gpu::VideoWriter_GPU::EncoderParams::EncoderParams(const cv::String&) { throw_nogpu(); } +void cv::gpu::VideoWriter_GPU::EncoderParams::load(const cv::String&) { throw_nogpu(); } +void cv::gpu::VideoWriter_GPU::EncoderParams::save(const cv::String&) const { throw_nogpu(); } #else // !defined HAVE_CUDA || !defined WIN32 @@ -736,7 +736,7 @@ void NVENCAPI cv::gpu::VideoWriter_GPU::Impl::HandleOnEndFrame(const NVVE_EndFra class EncoderCallBackFFMPEG : public cv::gpu::VideoWriter_GPU::EncoderCallBack { public: - EncoderCallBackFFMPEG(const std::string& fileName, cv::Size frameSize, double fps); + EncoderCallBackFFMPEG(const cv::String& fileName, cv::Size frameSize, double fps); ~EncoderCallBackFFMPEG(); unsigned char* acquireBitStream(int* bufferSize); @@ -799,7 +799,7 @@ namespace } } -EncoderCallBackFFMPEG::EncoderCallBackFFMPEG(const std::string& fileName, cv::Size frameSize, double fps) : +EncoderCallBackFFMPEG::EncoderCallBackFFMPEG(const cv::String& fileName, cv::Size frameSize, double fps) : stream_(0), isKeyFrame_(false) { int buf_size = std::max(frameSize.area() * 4, 1024 * 1024); @@ -843,12 +843,12 @@ cv::gpu::VideoWriter_GPU::VideoWriter_GPU() { } -cv::gpu::VideoWriter_GPU::VideoWriter_GPU(const std::string& fileName, cv::Size frameSize, double fps, SurfaceFormat format) +cv::gpu::VideoWriter_GPU::VideoWriter_GPU(const cv::String& fileName, cv::Size frameSize, double fps, SurfaceFormat format) { open(fileName, frameSize, fps, format); } -cv::gpu::VideoWriter_GPU::VideoWriter_GPU(const std::string& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format) +cv::gpu::VideoWriter_GPU::VideoWriter_GPU(const cv::String& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format) { open(fileName, frameSize, fps, params, format); } @@ -868,14 +868,14 @@ cv::gpu::VideoWriter_GPU::~VideoWriter_GPU() close(); } -void cv::gpu::VideoWriter_GPU::open(const std::string& fileName, cv::Size frameSize, double fps, SurfaceFormat format) +void cv::gpu::VideoWriter_GPU::open(const cv::String& fileName, cv::Size frameSize, double fps, SurfaceFormat format) { close(); cv::Ptr encoderCallback(new EncoderCallBackFFMPEG(fileName, frameSize, fps)); open(encoderCallback, frameSize, fps, format); } -void cv::gpu::VideoWriter_GPU::open(const std::string& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format) +void cv::gpu::VideoWriter_GPU::open(const cv::String& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format) { close(); cv::Ptr encoderCallback(new EncoderCallBackFFMPEG(fileName, frameSize, fps)); @@ -944,12 +944,12 @@ cv::gpu::VideoWriter_GPU::EncoderParams::EncoderParams() DisableSPSPPS = 0; } -cv::gpu::VideoWriter_GPU::EncoderParams::EncoderParams(const std::string& configFile) +cv::gpu::VideoWriter_GPU::EncoderParams::EncoderParams(const cv::String& configFile) { load(configFile); } -void cv::gpu::VideoWriter_GPU::EncoderParams::load(const std::string& configFile) +void cv::gpu::VideoWriter_GPU::EncoderParams::load(const cv::String& configFile) { cv::FileStorage fs(configFile, cv::FileStorage::READ); CV_Assert( fs.isOpened() ); @@ -975,7 +975,7 @@ void cv::gpu::VideoWriter_GPU::EncoderParams::load(const std::string& configFile cv::read(fs["DisableSPSPPS" ], DisableSPSPPS, 0); } -void cv::gpu::VideoWriter_GPU::EncoderParams::save(const std::string& configFile) const +void cv::gpu::VideoWriter_GPU::EncoderParams::save(const cv::String& configFile) const { cv::FileStorage fs(configFile, cv::FileStorage::WRITE); CV_Assert( fs.isOpened() ); diff --git a/modules/legacy/include/opencv2/legacy.hpp b/modules/legacy/include/opencv2/legacy.hpp index 7b765b0c8..8581a8f54 100644 --- a/modules/legacy/include/opencv2/legacy.hpp +++ b/modules/legacy/include/opencv2/legacy.hpp @@ -1887,7 +1887,7 @@ public: void setVerbose(bool verbose); void read(const FileNode& node); - void write(FileStorage& fs, const std::string& name=std::string()) const; + void write(FileStorage& fs, const cv::String& name=cv::String()) const; int radius; int threshold; @@ -1918,7 +1918,7 @@ public: const PatchGenerator& patchGenerator=PatchGenerator()); virtual ~FernClassifier(); virtual void read(const FileNode& n); - virtual void write(FileStorage& fs, const std::string& name=std::string()) const; + virtual void write(FileStorage& fs, const cv::String& name=cv::String()) const; virtual void trainFromSingleView(const Mat& image, const std::vector& keypoints, int _patchSize=PATCH_SIZE, @@ -2062,8 +2062,8 @@ public: inline void applyQuantization(int num_quant_bits) { makePosteriors2(num_quant_bits); } // debug - void savePosteriors(std::string url, bool append=false); - void savePosteriors2(std::string url, bool append=false); + void savePosteriors(cv::String url, bool append=false); + void savePosteriors2(cv::String url, bool append=false); private: int classes_; @@ -2181,9 +2181,9 @@ public: void write(std::ostream &os) const; // experimental and debug - void saveAllFloatPosteriors(std::string file_url); - void saveAllBytePosteriors(std::string file_url); - void setFloatPosteriorsFromTextfile_176(std::string url); + void saveAllFloatPosteriors(cv::String file_url); + void saveAllBytePosteriors(cv::String file_url); + void setFloatPosteriorsFromTextfile_176(cv::String url); float countZeroElements(); std::vector trees_; @@ -2356,7 +2356,7 @@ protected: CvAffinePose* m_affine_poses; // an array of poses CvMat** m_transforms; // an array of affine transforms corresponding to poses - std::string m_feature_name; // the name of the feature associated with the descriptor + cv::String m_feature_name; // the name of the feature associated with the descriptor CvPoint m_center; // the coordinates of the feature (the center of the input image ROI) int m_pca_dim_high; // the number of descriptor pca components to use for generating affine poses @@ -2382,7 +2382,7 @@ public: const char* pca_hr_config = 0, const char* pca_desc_config = 0, int pyr_levels = 1, int pca_dim_high = 100, int pca_dim_low = 100); - OneWayDescriptorBase(CvSize patch_size, int pose_count, const std::string &pca_filename, const std::string &train_path = std::string(), const std::string &images_list = std::string(), + OneWayDescriptorBase(CvSize patch_size, int pose_count, const cv::String &pca_filename, const cv::String &train_path = cv::String(), const cv::String &images_list = cv::String(), float _scale_min = 0.7f, float _scale_max=1.5f, float _scale_step=1.2f, int pyr_levels = 1, int pca_dim_high = 100, int pca_dim_low = 100); @@ -2516,7 +2516,7 @@ public: void ConvertDescriptorsArrayToTree(); // Converting pca_descriptors array to KD tree // GetPCAFilename: get default PCA filename - static std::string GetPCAFilename () { return "pca.yml"; } + static cv::String GetPCAFilename () { return "pca.yml"; } virtual bool empty() const { return m_train_feature_count <= 0 ? true : false; } @@ -2568,8 +2568,8 @@ public: OneWayDescriptorObject(CvSize patch_size, int pose_count, const char* train_path, const char* pca_config, const char* pca_hr_config = 0, const char* pca_desc_config = 0, int pyr_levels = 1); - OneWayDescriptorObject(CvSize patch_size, int pose_count, const std::string &pca_filename, - const std::string &train_path = std::string (), const std::string &images_list = std::string (), + OneWayDescriptorObject(CvSize patch_size, int pose_count, const cv::String &pca_filename, + const cv::String &train_path = cv::String (), const cv::String &images_list = cv::String (), float _scale_min = 0.7f, float _scale_max=1.5f, float _scale_step=1.2f, int pyr_levels = 1); @@ -2633,16 +2633,16 @@ public: Params( int poseCount = POSE_COUNT, Size patchSize = Size(PATCH_WIDTH, PATCH_HEIGHT), - std::string pcaFilename = std::string(), - std::string trainPath = std::string(), std::string trainImagesList = std::string(), + cv::String pcaFilename = cv::String(), + cv::String trainPath = cv::String(), cv::String trainImagesList = cv::String(), float minScale = GET_MIN_SCALE(), float maxScale = GET_MAX_SCALE(), float stepScale = GET_STEP_SCALE() ); int poseCount; Size patchSize; - std::string pcaFilename; - std::string trainPath; - std::string trainImagesList; + cv::String pcaFilename; + cv::String trainPath; + cv::String trainImagesList; float minScale, maxScale, stepScale; }; @@ -2706,7 +2706,7 @@ public: int compressionMethod=FernClassifier::COMPRESSION_NONE, const PatchGenerator& patchGenerator=PatchGenerator() ); - Params( const std::string& filename ); + Params( const cv::String& filename ); int nclasses; int patchSize; @@ -2717,7 +2717,7 @@ public: int compressionMethod; PatchGenerator patchGenerator; - std::string filename; + cv::String filename; }; FernDescriptorMatcher( const Params& params=Params() ); @@ -2759,7 +2759,7 @@ template class CV_EXPORTS CalonderDescriptorExtractor : public DescriptorExtractor { public: - CalonderDescriptorExtractor( const std::string& classifierFile ); + CalonderDescriptorExtractor( const cv::String& classifierFile ); virtual void read( const FileNode &fn ); virtual void write( FileStorage &fs ) const; @@ -2777,7 +2777,7 @@ protected: }; template -CalonderDescriptorExtractor::CalonderDescriptorExtractor(const std::string& classifier_file) +CalonderDescriptorExtractor::CalonderDescriptorExtractor(const cv::String& classifier_file) { classifier_.read( classifier_file.c_str() ); } @@ -2867,7 +2867,7 @@ public: void setVerbose(bool verbose); void read(const FileNode& node); - void write(FileStorage& fs, const std::string& name=std::string()) const; + void write(FileStorage& fs, const cv::String& name=cv::String()) const; bool operator()(const Mat& image, CV_OUT Mat& H, CV_OUT std::vector& corners) const; bool operator()(const std::vector& pyr, const std::vector& keypoints, CV_OUT Mat& H, CV_OUT std::vector& corners, diff --git a/modules/legacy/src/calonder.cpp b/modules/legacy/src/calonder.cpp index 73f274862..51cb13047 100644 --- a/modules/legacy/src/calonder.cpp +++ b/modules/legacy/src/calonder.cpp @@ -626,7 +626,7 @@ void RandomizedTree::write(std::ostream &os) const } -void RandomizedTree::savePosteriors(std::string url, bool append) +void RandomizedTree::savePosteriors(cv::String url, bool append) { std::ofstream file(url.c_str(), (append?std::ios::app:std::ios::out)); for (int i=0; iwrite(os); } -void RTreeClassifier::saveAllFloatPosteriors(std::string url) +void RTreeClassifier::saveAllFloatPosteriors(cv::String url) { printf("[DEBUG] writing all float posteriors to %s...\n", url.c_str()); for (int i=0; i<(int)trees_.size(); ++i) @@ -923,7 +923,7 @@ void RTreeClassifier::saveAllFloatPosteriors(std::string url) printf("[DEBUG] done\n"); } -void RTreeClassifier::saveAllBytePosteriors(std::string url) +void RTreeClassifier::saveAllBytePosteriors(cv::String url) { printf("[DEBUG] writing all byte posteriors to %s...\n", url.c_str()); for (int i=0; i<(int)trees_.size(); ++i) @@ -932,7 +932,7 @@ void RTreeClassifier::saveAllBytePosteriors(std::string url) } -void RTreeClassifier::setFloatPosteriorsFromTextfile_176(std::string url) +void RTreeClassifier::setFloatPosteriorsFromTextfile_176(cv::String url) { std::ifstream ifs(url.c_str()); diff --git a/modules/legacy/src/oneway.cpp b/modules/legacy/src/oneway.cpp index eae17a5d4..e885dfef2 100644 --- a/modules/legacy/src/oneway.cpp +++ b/modules/legacy/src/oneway.cpp @@ -465,7 +465,7 @@ namespace cv{ void OneWayDescriptor::Initialize(int pose_count, IplImage* frontal, const char* feature_name, int norm) { - m_feature_name = std::string(feature_name); + m_feature_name = cv::String(feature_name); CvRect roi = cvGetImageROI(frontal); m_center = rect_center(roi); @@ -482,7 +482,7 @@ namespace cv{ Initialize(pose_count, frontal, feature_name, 1); return; } - m_feature_name = std::string(feature_name); + m_feature_name = cv::String(feature_name); CvRect roi = cvGetImageROI(frontal); m_center = rect_center(roi); @@ -1287,8 +1287,8 @@ namespace cv{ } - OneWayDescriptorBase::OneWayDescriptorBase(CvSize patch_size, int pose_count, const std::string &pca_filename, - const std::string &train_path, const std::string &images_list, float _scale_min, float _scale_max, + OneWayDescriptorBase::OneWayDescriptorBase(CvSize patch_size, int pose_count, const cv::String &pca_filename, + const cv::String &train_path, const cv::String &images_list, float _scale_min, float _scale_max, float _scale_step, int pyr_levels, int pca_dim_high, int pca_dim_low) : m_pca_dim_high(pca_dim_high), m_pca_dim_low(pca_dim_low), scale_min(_scale_min), scale_max(_scale_max), scale_step(_scale_step) @@ -2080,8 +2080,8 @@ namespace cv{ m_part_id = 0; } - OneWayDescriptorObject::OneWayDescriptorObject(CvSize patch_size, int pose_count, const std::string &pca_filename, - const std::string &train_path, const std::string &images_list, float _scale_min, float _scale_max, float _scale_step, int pyr_levels) : + OneWayDescriptorObject::OneWayDescriptorObject(CvSize patch_size, int pose_count, const cv::String &pca_filename, + const cv::String &train_path, const cv::String &images_list, float _scale_min, float _scale_max, float _scale_step, int pyr_levels) : OneWayDescriptorBase(patch_size, pose_count, pca_filename, train_path, images_list, _scale_min, _scale_max, _scale_step, pyr_levels) { m_part_id = 0; @@ -2145,7 +2145,7 @@ namespace cv{ void readPCAFeatures(const FileNode &fn, CvMat** avg, CvMat** eigenvectors, const char* postfix) { - std::string str = std::string ("avg") + postfix; + cv::String str = cv::String ("avg") + postfix; CvMat* _avg = reinterpret_cast (fn[str].readObj()); if (_avg != 0) { @@ -2153,7 +2153,7 @@ namespace cv{ cvReleaseMat(&_avg); } - str = std::string ("eigenvectors") + postfix; + str = cv::String ("eigenvectors") + postfix; CvMat* _eigenvectors = reinterpret_cast (fn[str].readObj()); if (_eigenvectors != 0) { @@ -2166,8 +2166,8 @@ namespace cv{ * OneWayDescriptorMatcher * \****************************************************************************************/ - OneWayDescriptorMatcher::Params::Params( int _poseCount, Size _patchSize, std::string _pcaFilename, - std::string _trainPath, std::string _trainImagesList, + OneWayDescriptorMatcher::Params::Params( int _poseCount, Size _patchSize, cv::String _pcaFilename, + cv::String _trainPath, cv::String _trainImagesList, float _minScale, float _maxScale, float _stepScale ) : poseCount(_poseCount), patchSize(_patchSize), pcaFilename(_pcaFilename), trainPath(_trainPath), trainImagesList(_trainImagesList), @@ -2271,7 +2271,7 @@ namespace cv{ void OneWayDescriptorMatcher::read( const FileNode &fn ) { - base = new OneWayDescriptorObject( params.patchSize, params.poseCount, std::string (), std::string (), std::string (), + base = new OneWayDescriptorObject( params.patchSize, params.poseCount, cv::String (), cv::String (), cv::String (), params.minScale, params.maxScale, params.stepScale ); base->Read (fn); } diff --git a/modules/legacy/src/planardetect.cpp b/modules/legacy/src/planardetect.cpp index 6c5e96ff8..31aca7670 100644 --- a/modules/legacy/src/planardetect.cpp +++ b/modules/legacy/src/planardetect.cpp @@ -617,7 +617,7 @@ void LDetector::read(const FileNode& objnode) clusteringDistance = (int)objnode["clustering-distance"]; } -void LDetector::write(FileStorage& fs, const std::string& name) const +void LDetector::write(FileStorage& fs, const cv::String& name) const { WriteStructContext ws(fs, name, CV_NODE_MAP); @@ -707,7 +707,7 @@ FernClassifier::FernClassifier(const std::vector >& points, } -void FernClassifier::write(FileStorage& fs, const std::string& objname) const +void FernClassifier::write(FileStorage& fs, const cv::String& objname) const { WriteStructContext ws(fs, objname, CV_NODE_MAP); @@ -1228,7 +1228,7 @@ nstructs(_nstructs), structSize(_structSize), nviews(_nviews), compressionMethod(_compressionMethod), patchGenerator(_patchGenerator) {} -FernDescriptorMatcher::Params::Params( const std::string& _filename ) +FernDescriptorMatcher::Params::Params( const cv::String& _filename ) { filename = _filename; } @@ -1476,7 +1476,7 @@ void PlanarObjectDetector::read(const FileNode& node) } -void PlanarObjectDetector::write(FileStorage& fs, const std::string& objname) const +void PlanarObjectDetector::write(FileStorage& fs, const cv::String& objname) const { WriteStructContext ws(fs, objname, CV_NODE_MAP); diff --git a/modules/legacy/test/test_stereomatching.cpp b/modules/legacy/test/test_stereomatching.cpp index a6524bb71..726224984 100644 --- a/modules/legacy/test/test_stereomatching.cpp +++ b/modules/legacy/test/test_stereomatching.cpp @@ -593,10 +593,10 @@ int CV_StereoMatchingTest::readDatasetsParams( FileStorage& fs ) assert(fn.isSeq()); for( int i = 0; i < (int)fn.size(); i+=3 ) { - string nm = fn[i]; + String nm = fn[i]; DatasetParams params; - string sf = fn[i+1]; params.dispScaleFactor = atoi(sf.c_str()); - string uv = fn[i+2]; params.dispUnknVal = atoi(uv.c_str()); + String sf = fn[i+1]; params.dispScaleFactor = atoi(sf.c_str()); + String uv = fn[i+2]; params.dispUnknVal = atoi(uv.c_str()); datasetsParams[nm] = params; } return cvtest::TS::OK; @@ -684,10 +684,10 @@ protected: assert(fn.isSeq()); for( int i = 0; i < (int)fn.size(); i+=4 ) { - string caseName = fn[i], datasetName = fn[i+1]; + String caseName = fn[i], datasetName = fn[i+1]; RunParams params; - string ndisp = fn[i+2]; params.ndisp = atoi(ndisp.c_str()); - string iterCount = fn[i+3]; params.iterCount = atoi(iterCount.c_str()); + String ndisp = fn[i+2]; params.ndisp = atoi(ndisp.c_str()); + String iterCount = fn[i+3]; params.iterCount = atoi(iterCount.c_str()); caseNames.push_back( caseName ); caseDatasets.push_back( datasetName ); caseRunParams.push_back( params ); diff --git a/modules/ml/doc/mldata.rst b/modules/ml/doc/mldata.rst index bae342e49..997332517 100644 --- a/modules/ml/doc/mldata.rst +++ b/modules/ml/doc/mldata.rst @@ -48,7 +48,7 @@ Class for loading the data from a ``.csv`` file. void set_miss_ch( char ch ); char get_miss_ch() const; - const std::map& get_class_labels_map() const; + const std::map& get_class_labels_map() const; protected: ... @@ -245,7 +245,7 @@ CvMLData::get_class_labels_map ------------------------------- Returns a map that converts strings to labels. -.. ocv:function:: const std::map& CvMLData::get_class_labels_map() const +.. ocv:function:: const std::map& CvMLData::get_class_labels_map() const The method returns a map that converts string class labels to the numerical class labels. It can be used to get an original class label as in a file. diff --git a/modules/ml/include/opencv2/ml.hpp b/modules/ml/include/opencv2/ml.hpp index d1812c2a0..d3a690c96 100644 --- a/modules/ml/include/opencv2/ml.hpp +++ b/modules/ml/include/opencv2/ml.hpp @@ -1043,7 +1043,7 @@ public: CvForestTree* get_tree(int i) const; protected: - virtual std::string getName() const; + virtual cv::String getName() const; virtual bool grow_forest( const CvTermCriteria term_crit ); @@ -1115,7 +1115,7 @@ public: CvRTParams params=CvRTParams()); virtual bool train( CvMLData* data, CvRTParams params=CvRTParams() ); protected: - virtual std::string getName() const; + virtual cv::String getName() const; virtual bool grow_forest( const CvTermCriteria term_crit ); }; @@ -2072,7 +2072,7 @@ public: void set_miss_ch( char ch ); char get_miss_ch() const; - const std::map& get_class_labels_map() const; + const std::map& get_class_labels_map() const; protected: virtual void clear(); @@ -2101,7 +2101,7 @@ protected: bool mix; int total_class_count; - std::map class_map; + std::map class_map; CvMat* train_sample_idx; CvMat* test_sample_idx; diff --git a/modules/ml/src/data.cpp b/modules/ml/src/data.cpp index 7d9cceac4..f4e401cb8 100644 --- a/modules/ml/src/data.cpp +++ b/modules/ml/src/data.cpp @@ -285,7 +285,7 @@ const CvMat* CvMLData::get_missing() const return missing; } -const std::map& CvMLData::get_class_labels_map() const +const std::map& CvMLData::get_class_labels_map() const { return class_map; } diff --git a/modules/ml/src/ertrees.cpp b/modules/ml/src/ertrees.cpp index 31d20398a..8b7091c33 100644 --- a/modules/ml/src/ertrees.cpp +++ b/modules/ml/src/ertrees.cpp @@ -1537,7 +1537,7 @@ CvERTrees::~CvERTrees() { } -std::string CvERTrees::getName() const +cv::String CvERTrees::getName() const { return CV_TYPE_NAME_ML_ERTREES; } diff --git a/modules/ml/src/gbt.cpp b/modules/ml/src/gbt.cpp index a409b7ab3..04e7a0fe3 100644 --- a/modules/ml/src/gbt.cpp +++ b/modules/ml/src/gbt.cpp @@ -1117,7 +1117,7 @@ void CvGBTrees::write( CvFileStorage* fs, const char* name ) const CvSeqReader reader; int i; - std::string s; + cv::String s; cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_GBT ); @@ -1167,7 +1167,7 @@ void CvGBTrees::read( CvFileStorage* fs, CvFileNode* node ) CvFileNode* trees_fnode; CvMemStorage* storage; int i, ntrees; - std::string s; + cv::String s; clear(); read_params( fs, node ); diff --git a/modules/ml/src/precomp.hpp b/modules/ml/src/precomp.hpp index c18024465..281ff11af 100644 --- a/modules/ml/src/precomp.hpp +++ b/modules/ml/src/precomp.hpp @@ -45,6 +45,7 @@ #include "cvconfig.h" #endif +#include "opencv2/core.hpp" #include "opencv2/ml.hpp" #include "opencv2/core/core_c.h" #include "opencv2/core/utility.hpp" diff --git a/modules/ml/src/rtrees.cpp b/modules/ml/src/rtrees.cpp index d88611bef..8e287864a 100644 --- a/modules/ml/src/rtrees.cpp +++ b/modules/ml/src/rtrees.cpp @@ -246,7 +246,7 @@ CvRTrees::~CvRTrees() clear(); } -std::string CvRTrees::getName() const +cv::String CvRTrees::getName() const { return CV_TYPE_NAME_ML_RTREES; } @@ -730,7 +730,7 @@ void CvRTrees::write( CvFileStorage* fs, const char* name ) const if( ntrees < 1 || !trees || nsamples < 1 ) CV_Error( CV_StsBadArg, "Invalid CvRTrees object" ); - std::string modelNodeName = this->getName(); + cv::String modelNodeName = this->getName(); cvStartWriteStruct( fs, name, CV_NODE_MAP, modelNodeName.c_str() ); cvWriteInt( fs, "nclasses", nclasses ); diff --git a/modules/ml/src/svm.cpp b/modules/ml/src/svm.cpp index 76e0c41bc..47fc6c354 100644 --- a/modules/ml/src/svm.cpp +++ b/modules/ml/src/svm.cpp @@ -1924,7 +1924,7 @@ bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses, qsort(ratios, k_fold, sizeof(ratios[0]), icvCmpIndexedratio); double old_dist = 0.0; for (int k=0; k 0.0) @@ -1941,7 +1941,7 @@ bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses, qsort(ratios, k_fold, sizeof(ratios[0]), icvCmpIndexedratio); new_dist = 0.0; for (int k=0; k *resp // 4. em // 5. ann -int str_to_ann_train_method( string& str ) +int str_to_ann_train_method( String& str ) { if( !str.compare("BACKPROP") ) return CvANN_MLP_TrainParams::BACKPROP; @@ -412,7 +412,7 @@ float ann_calc_error( CvANN_MLP* ann, CvMLData* _data, map& cls_map, i // 6. dtree // 7. boost -int str_to_boost_type( string& str ) +int str_to_boost_type( String& str ) { if ( !str.compare("DISCRETE") ) return CvBoost::DISCRETE; @@ -546,7 +546,7 @@ void CV_MLBaseTest::run( int ) int CV_MLBaseTest::prepare_test_case( int test_case_idx ) { int trainSampleCount, respIdx; - string varTypes; + String varTypes; clear(); string dataPath = ts->get_data_path(); @@ -605,7 +605,7 @@ int CV_MLBaseTest::train( int testCaseIdx ) } else if( !modelName.compare(CV_SVM) ) { - string svm_type_str, kernel_type_str; + String svm_type_str, kernel_type_str; modelParamsNode["svm_type"] >> svm_type_str; modelParamsNode["kernel_type"] >> kernel_type_str; CvSVMParams params; @@ -625,7 +625,7 @@ int CV_MLBaseTest::train( int testCaseIdx ) } else if( !modelName.compare(CV_ANN) ) { - string train_method_str; + String train_method_str; double param1, param2; modelParamsNode["train_method"] >> train_method_str; modelParamsNode["param1"] >> param1; @@ -659,7 +659,7 @@ int CV_MLBaseTest::train( int testCaseIdx ) int BOOST_TYPE, WEAK_COUNT, MAX_DEPTH; float WEIGHT_TRIM_RATE; bool USE_SURROGATE; - string typeStr; + String typeStr; modelParamsNode["type"] >> typeStr; BOOST_TYPE = str_to_boost_type( typeStr ); modelParamsNode["weak_count"] >> WEAK_COUNT; diff --git a/modules/nonfree/src/surf.ocl.cpp b/modules/nonfree/src/surf.ocl.cpp index 420a5f6ae..d705f17f8 100644 --- a/modules/nonfree/src/surf.ocl.cpp +++ b/modules/nonfree/src/surf.ocl.cpp @@ -58,7 +58,7 @@ namespace cv const char* noImage2dOption = "-D DISABLE_IMAGE2D"; - static void openCLExecuteKernelSURF(Context *clCxt , const char **source, std::string kernelName, size_t globalThreads[3], + static void openCLExecuteKernelSURF(Context *clCxt , const char **source, cv::String kernelName, size_t globalThreads[3], size_t localThreads[3], std::vector< std::pair > &args, int channels, int depth) { if(support_image2d()) @@ -480,7 +480,7 @@ void SURF_OCL_Invoker::icvCalcLayerDetAndTrace_gpu(oclMat &det, oclMat &trace, i const int max_samples_j = 1 + ((img_cols - min_size) >> octave); Context *clCxt = det.clCxt; - std::string kernelName = "icvCalcLayerDetAndTrace"; + cv::String kernelName = "icvCalcLayerDetAndTrace"; std::vector< std::pair > args; if(sumTex) @@ -518,7 +518,7 @@ void SURF_OCL_Invoker::icvFindMaximaInLayer_gpu(const oclMat &det, const oclMat const int min_margin = ((calcSize(octave, 2) >> 1) >> octave) + 1; Context *clCxt = det.clCxt; - std::string kernelName = use_mask ? "icvFindMaximaInLayer_withmask" : "icvFindMaximaInLayer"; + cv::String kernelName = use_mask ? "icvFindMaximaInLayer_withmask" : "icvFindMaximaInLayer"; std::vector< std::pair > args; args.push_back( std::make_pair( sizeof(cl_mem), (void *)&det.data)); @@ -562,7 +562,7 @@ void SURF_OCL_Invoker::icvInterpolateKeypoint_gpu(const oclMat &det, const oclMa oclMat &keypoints, oclMat &counters_, int octave, int layer_rows, int max_features) { Context *clCxt = det.clCxt; - std::string kernelName = "icvInterpolateKeypoint"; + cv::String kernelName = "icvInterpolateKeypoint"; std::vector< std::pair > args; args.push_back( std::make_pair( sizeof(cl_mem), (void *)&det.data)); @@ -586,7 +586,7 @@ void SURF_OCL_Invoker::icvInterpolateKeypoint_gpu(const oclMat &det, const oclMa void SURF_OCL_Invoker::icvCalcOrientation_gpu(const oclMat &keypoints, int nFeatures) { Context *clCxt = counters.clCxt; - std::string kernelName = "icvCalcOrientation"; + cv::String kernelName = "icvCalcOrientation"; std::vector< std::pair > args; @@ -613,7 +613,7 @@ void SURF_OCL_Invoker::icvCalcOrientation_gpu(const oclMat &keypoints, int nFeat void SURF_OCL_Invoker::icvSetUpright_gpu(const oclMat &keypoints, int nFeatures) { Context *clCxt = counters.clCxt; - std::string kernelName = "icvSetUpright"; + cv::String kernelName = "icvSetUpright"; std::vector< std::pair > args; @@ -632,7 +632,7 @@ void SURF_OCL_Invoker::compute_descriptors_gpu(const oclMat &descriptors, const { // compute unnormalized descriptors, then normalize them - odd indexing since grid must be 2D Context *clCxt = descriptors.clCxt; - std::string kernelName; + cv::String kernelName; std::vector< std::pair > args; size_t localThreads[3] = {1, 1, 1}; size_t globalThreads[3] = {1, 1, 1}; diff --git a/modules/objdetect/include/opencv2/objdetect.hpp b/modules/objdetect/include/opencv2/objdetect.hpp index a8c2955e1..701e744e2 100644 --- a/modules/objdetect/include/opencv2/objdetect.hpp +++ b/modules/objdetect/include/opencv2/objdetect.hpp @@ -307,24 +307,24 @@ public: }; LatentSvmDetector(); - LatentSvmDetector( const std::vector& filenames, const std::vector& classNames=std::vector() ); + LatentSvmDetector( const std::vector& filenames, const std::vector& classNames=std::vector() ); virtual ~LatentSvmDetector(); virtual void clear(); virtual bool empty() const; - bool load( const std::vector& filenames, const std::vector& classNames=std::vector() ); + bool load( const std::vector& filenames, const std::vector& classNames=std::vector() ); virtual void detect( const Mat& image, std::vector& objectDetections, float overlapThreshold=0.5f, int numThreads=-1 ); - const std::vector& getClassNames() const; + const std::vector& getClassNames() const; size_t getClassCount() const; private: std::vector detectors; - std::vector classNames; + std::vector classNames; }; CV_EXPORTS void groupRectangles(CV_OUT CV_IN_OUT std::vector& rectList, int groupThreshold, double eps=0.2); @@ -369,11 +369,11 @@ class CV_EXPORTS_W CascadeClassifier { public: CV_WRAP CascadeClassifier(); - CV_WRAP CascadeClassifier( const std::string& filename ); + CV_WRAP CascadeClassifier( const cv::String& filename ); virtual ~CascadeClassifier(); CV_WRAP virtual bool empty() const; - CV_WRAP bool load( const std::string& filename ); + CV_WRAP bool load( const cv::String& filename ); virtual bool read( const FileNode& node ); CV_WRAP virtual void detectMultiScale( const Mat& image, CV_OUT std::vector& objects, @@ -524,7 +524,7 @@ public: gammaCorrection(_gammaCorrection), nlevels(_nlevels) {} - CV_WRAP HOGDescriptor(const std::string& filename) + CV_WRAP HOGDescriptor(const cv::String& filename) { load(filename); } @@ -543,10 +543,10 @@ public: CV_WRAP virtual void setSVMDetector(InputArray _svmdetector); virtual bool read(FileNode& fn); - virtual void write(FileStorage& fs, const std::string& objname) const; + virtual void write(FileStorage& fs, const cv::String& objname) const; - CV_WRAP virtual bool load(const std::string& filename, const std::string& objname=std::string()); - CV_WRAP virtual void save(const std::string& filename, const std::string& objname=std::string()) const; + CV_WRAP virtual bool load(const cv::String& filename, const cv::String& objname=cv::String()); + CV_WRAP virtual void save(const cv::String& filename, const cv::String& objname=cv::String()) const; virtual void copyTo(HOGDescriptor& c) const; CV_WRAP virtual void compute(const Mat& img, @@ -609,16 +609,16 @@ public: int groupThreshold = 0) const; // read/parse Dalal's alt model file - void readALTModel(std::string modelfile); + void readALTModel(cv::String modelfile); }; CV_EXPORTS_W void findDataMatrix(InputArray image, - CV_OUT std::vector& codes, + CV_OUT std::vector& codes, OutputArray corners=noArray(), OutputArrayOfArrays dmtx=noArray()); CV_EXPORTS_W void drawDataMatrixCodes(InputOutputArray image, - const std::vector& codes, + const std::vector& codes, InputArray corners); } @@ -758,7 +758,7 @@ public: return processImpl(src, mask); } - virtual std::string name() const =0; + virtual cv::String name() const =0; virtual void read(const FileNode& fn) =0; virtual void write(FileStorage& fs) const =0; @@ -770,7 +770,7 @@ public: * - "ColorGradient" * - "DepthNormal" */ - static Ptr create(const std::string& modality_type); + static Ptr create(const cv::String& modality_type); /** * \brief Load a modality from file. @@ -804,7 +804,7 @@ public: */ ColorGradient(float weak_threshold, size_t num_features, float strong_threshold); - virtual std::string name() const; + virtual cv::String name() const; virtual void read(const FileNode& fn); virtual void write(FileStorage& fs) const; @@ -842,7 +842,7 @@ public: DepthNormal(int distance_threshold, int difference_threshold, size_t num_features, int extract_threshold); - virtual std::string name() const; + virtual cv::String name() const; virtual void read(const FileNode& fn); virtual void write(FileStorage& fs) const; @@ -871,7 +871,7 @@ struct CV_EXPORTS Match { } - Match(int x, int y, float similarity, const std::string& class_id, int template_id); + Match(int x, int y, float similarity, const cv::String& class_id, int template_id); /// Sort matches with high similarity to the front bool operator<(const Match& rhs) const @@ -891,11 +891,11 @@ struct CV_EXPORTS Match int x; int y; float similarity; - std::string class_id; + cv::String class_id; int template_id; }; -inline Match::Match(int _x, int _y, float _similarity, const std::string& _class_id, int _template_id) +inline Match::Match(int _x, int _y, float _similarity, const cv::String& _class_id, int _template_id) : x(_x), y(_y), similarity(_similarity), class_id(_class_id), template_id(_template_id) { } @@ -937,7 +937,7 @@ public: * empty or the same size as its corresponding source. */ void match(const std::vector& sources, float threshold, std::vector& matches, - const std::vector& class_ids = std::vector(), + const std::vector& class_ids = std::vector(), OutputArrayOfArrays quantized_images = noArray(), const std::vector& masks = std::vector()) const; @@ -951,13 +951,13 @@ public: * * \return Template ID, or -1 if failed to extract a valid template. */ - int addTemplate(const std::vector& sources, const std::string& class_id, + int addTemplate(const std::vector& sources, const cv::String& class_id, const Mat& object_mask, Rect* bounding_box = NULL); /** * \brief Add a new object template computed by external means. */ - int addSyntheticTemplate(const std::vector