partially recovered binary compatibility (ticket #2415)

diff --git a/modules/contrib/include/opencv2/contrib/detection_based_tracker.hpp b/modules/contrib/include/opencv2/contrib/detection_based_tracker.hpp
index 332a829..c290318 100644 (file)
--- a/modules/contrib/include/opencv2/contrib/detection_based_tracker.hpp
+++ b/modules/contrib/include/opencv2/contrib/detection_based_tracker.hpp
@@ -7,8 +7,6 @@
 
 #include <vector>
 
-namespace cv
-{
 class DetectionBasedTracker
 {
     public:
@@ -169,5 +167,10 @@ class DetectionBasedTracker
         cv::Rect calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const;
         void detectInRegion(const cv::Mat& img, const cv::Rect& r, std::vector<cv::Rect>& detectedObjectsInRegions);
 };
+
+namespace cv
+{
+    typedef ::DetectionBasedTracker DetectionBasedTracker;
+    
 } //end of cv namespace
 #endif

diff --git a/modules/contrib/src/detection_based_tracker.cpp b/modules/contrib/src/detection_based_tracker.cpp
index 238ac5c..28606d5 100644 (file)
--- a/modules/contrib/src/detection_based_tracker.cpp
+++ b/modules/contrib/src/detection_based_tracker.cpp
@@ -60,15 +60,12 @@ static inline cv::Rect scale_rect(const cv::Rect& r, float scale)
     return cv::Rect(x, y, cvRound(width), cvRound(height));
 }
 
-namespace cv
-{
-    void* workcycleObjectDetectorFunction(void* p);
-}
+void* workcycleObjectDetectorFunction(void* p);
 
-class cv::DetectionBasedTracker::SeparateDetectionWork
+class DetectionBasedTracker::SeparateDetectionWork
 {
     public:
-        SeparateDetectionWork(cv::DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector);
+        SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector);
         virtual ~SeparateDetectionWork();
         bool communicateWithDetectingThread(const Mat& imageGray, vector<Rect>& rectsWhereRegions);
         bool run();
@@ -119,7 +116,7 @@ class cv::DetectionBasedTracker::SeparateDetectionWork
         long long  timeWhenDetectingThreadStartedWork;
 };
 
-cv::DetectionBasedTracker::SeparateDetectionWork::SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector)
+DetectionBasedTracker::SeparateDetectionWork::SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector)
     :detectionBasedTracker(_detectionBasedTracker),
     cascadeInThread(),
     isObjectDetectingReady(false),
@@ -152,7 +149,7 @@ cv::DetectionBasedTracker::SeparateDetectionWork::SeparateDetectionWork(Detectio
     }
 }
 
-cv::DetectionBasedTracker::SeparateDetectionWork::~SeparateDetectionWork()
+DetectionBasedTracker::SeparateDetectionWork::~SeparateDetectionWork()
 {
     if(stateThread!=STATE_THREAD_STOPPED) {
         LOGE("\n\n\nATTENTION!!! dangerous algorithm error: destructor DetectionBasedTracker::DetectionBasedTracker::~SeparateDetectionWork is called before stopping the workthread");
@@ -162,7 +159,7 @@ cv::DetectionBasedTracker::SeparateDetectionWork::~SeparateDetectionWork()
     pthread_cond_destroy(&objectDetectorRun);
     pthread_mutex_destroy(&mutex);
 }
-bool cv::DetectionBasedTracker::SeparateDetectionWork::run()
+bool DetectionBasedTracker::SeparateDetectionWork::run()
 {
     LOGD("DetectionBasedTracker::SeparateDetectionWork::run() --- start");
     pthread_mutex_lock(&mutex);
@@ -211,18 +208,18 @@ do {
 } while(0)
 #endif
 
-void* cv::workcycleObjectDetectorFunction(void* p)
+void* workcycleObjectDetectorFunction(void* p)
 {
-    CATCH_ALL_AND_LOG({ ((cv::DetectionBasedTracker::SeparateDetectionWork*)p)->workcycleObjectDetector(); });
+    CATCH_ALL_AND_LOG({ ((DetectionBasedTracker::SeparateDetectionWork*)p)->workcycleObjectDetector(); });
     try{
-        ((cv::DetectionBasedTracker::SeparateDetectionWork*)p)->stateThread = cv::DetectionBasedTracker::SeparateDetectionWork::STATE_THREAD_STOPPED;
+        ((DetectionBasedTracker::SeparateDetectionWork*)p)->stateThread = DetectionBasedTracker::SeparateDetectionWork::STATE_THREAD_STOPPED;
     } catch(...) {
         LOGE0("DetectionBasedTracker: workcycleObjectDetectorFunction: ERROR concerning pointer, received as the function parameter");
     }
     return NULL;
 }
 
-void cv::DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector()
+void DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector()
 {
     static double freq = getTickFrequency();
     LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- start");
@@ -346,7 +343,7 @@ void cv::DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector()
     LOGI("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector: Returning");
 }
 
-void cv::DetectionBasedTracker::SeparateDetectionWork::stop()
+void DetectionBasedTracker::SeparateDetectionWork::stop()
 {
     //FIXME: TODO: should add quickStop functionality
     pthread_mutex_lock(&mutex);
@@ -363,7 +360,7 @@ void cv::DetectionBasedTracker::SeparateDetectionWork::stop()
     pthread_mutex_unlock(&mutex);
 }
 
-void cv::DetectionBasedTracker::SeparateDetectionWork::resetTracking()
+void DetectionBasedTracker::SeparateDetectionWork::resetTracking()
 {
     LOGD("DetectionBasedTracker::SeparateDetectionWork::resetTracking");
     pthread_mutex_lock(&mutex);
@@ -384,7 +381,7 @@ void cv::DetectionBasedTracker::SeparateDetectionWork::resetTracking()
 
 }
 
-bool cv::DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThread(const Mat& imageGray, vector<Rect>& rectsWhereRegions)
+bool DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThread(const Mat& imageGray, vector<Rect>& rectsWhereRegions)
 {
     static double freq = getTickFrequency();
 
@@ -434,13 +431,13 @@ bool cv::DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingT
     return shouldHandleResult;
 }
 
-cv::DetectionBasedTracker::Parameters::Parameters()
+DetectionBasedTracker::Parameters::Parameters()
 {
     maxTrackLifetime=5;
     minDetectionPeriod=0;
 }
 
-cv::DetectionBasedTracker::InnerParameters::InnerParameters()
+DetectionBasedTracker::InnerParameters::InnerParameters()
 {
     numLastPositionsToTrack=4;
     numStepsToWaitBeforeFirstShow=6;
@@ -453,7 +450,7 @@ cv::DetectionBasedTracker::InnerParameters::InnerParameters()
 
 }
 
-cv::DetectionBasedTracker::DetectionBasedTracker(cv::Ptr<IDetector> mainDetector, cv::Ptr<IDetector> trackingDetector, const Parameters& params)
+DetectionBasedTracker::DetectionBasedTracker(cv::Ptr<IDetector> mainDetector, cv::Ptr<IDetector> trackingDetector, const Parameters& params)
     :separateDetectionWork(),
     parameters(params),
     innerParameters(),
@@ -474,7 +471,7 @@ cv::DetectionBasedTracker::DetectionBasedTracker(cv::Ptr<IDetector> mainDetector
     weightsSizesSmoothing.push_back(0.2);
 }
 
-cv::DetectionBasedTracker::~DetectionBasedTracker()
+DetectionBasedTracker::~DetectionBasedTracker()
 {
 }
 
@@ -547,7 +544,7 @@ void DetectionBasedTracker::process(const Mat& imageGray)
     updateTrackedObjects(detectedObjectsInRegions);
 }
 
-void cv::DetectionBasedTracker::getObjects(std::vector<cv::Rect>& result) const
+void DetectionBasedTracker::getObjects(std::vector<cv::Rect>& result) const
 {
     result.clear();
 
@@ -561,7 +558,7 @@ void cv::DetectionBasedTracker::getObjects(std::vector<cv::Rect>& result) const
     }
 }
 
-void cv::DetectionBasedTracker::getObjects(std::vector<Object>& result) const
+void DetectionBasedTracker::getObjects(std::vector<Object>& result) const
 {
     result.clear();
 
@@ -574,7 +571,7 @@ void cv::DetectionBasedTracker::getObjects(std::vector<Object>& result) const
         LOGD("DetectionBasedTracker::process: found a object with SIZE %d x %d, rect={%d, %d, %d x %d}", r.width, r.height, r.x, r.y, r.width, r.height);
     }
 }
-void cv::DetectionBasedTracker::getObjects(std::vector<ExtObject>& result) const
+void DetectionBasedTracker::getObjects(std::vector<ExtObject>& result) const
 {
     result.clear();
 
@@ -586,7 +583,7 @@ void cv::DetectionBasedTracker::getObjects(std::vector<ExtObject>& result) const
     }
 }
 
-bool cv::DetectionBasedTracker::run()
+bool DetectionBasedTracker::run()
 {
     if (!separateDetectionWork.empty()) {
         return separateDetectionWork->run();
@@ -594,14 +591,14 @@ bool cv::DetectionBasedTracker::run()
     return false;
 }
 
-void cv::DetectionBasedTracker::stop()
+void DetectionBasedTracker::stop()
 {
     if (!separateDetectionWork.empty()) {
         separateDetectionWork->stop();
     }
 }
 
-void cv::DetectionBasedTracker::resetTracking()
+void DetectionBasedTracker::resetTracking()
 {
     if (!separateDetectionWork.empty()) {
         separateDetectionWork->resetTracking();
@@ -609,7 +606,7 @@ void cv::DetectionBasedTracker::resetTracking()
     trackedObjects.clear();
 }
 
-void cv::DetectionBasedTracker::updateTrackedObjects(const vector<Rect>& detectedObjects)
+void DetectionBasedTracker::updateTrackedObjects(const vector<Rect>& detectedObjects)
 {
     enum {
         NEW_RECTANGLE=-1,
@@ -730,7 +727,7 @@ void cv::DetectionBasedTracker::updateTrackedObjects(const vector<Rect>& detecte
     }
 }
 
-int cv::DetectionBasedTracker::addObject(const Rect& location)
+int DetectionBasedTracker::addObject(const Rect& location)
 {
     LOGD("DetectionBasedTracker::addObject: new object {%d, %d %dx%d}",location.x, location.y, location.width, location.height);
     trackedObjects.push_back(TrackedObject(location));
@@ -739,12 +736,12 @@ int cv::DetectionBasedTracker::addObject(const Rect& location)
     return newId;
 }
 
-Rect cv::DetectionBasedTracker::calcTrackedObjectPositionToShow(int i) const
+Rect DetectionBasedTracker::calcTrackedObjectPositionToShow(int i) const
 {
     ObjectStatus status;
     return calcTrackedObjectPositionToShow(i, status);
 }
-Rect cv::DetectionBasedTracker::calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const
+Rect DetectionBasedTracker::calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const
 {
     if ( (i < 0) || (i >= (int)trackedObjects.size()) ) {
         LOGE("DetectionBasedTracker::calcTrackedObjectPositionToShow: ERROR: wrong i=%d", i);
@@ -830,7 +827,7 @@ Rect cv::DetectionBasedTracker::calcTrackedObjectPositionToShow(int i, ObjectSta
     return res;
 }
 
-void cv::DetectionBasedTracker::detectInRegion(const Mat& img, const Rect& r, vector<Rect>& detectedObjectsInRegions)
+void DetectionBasedTracker::detectInRegion(const Mat& img, const Rect& r, vector<Rect>& detectedObjectsInRegions)
 {
     Rect r0(Point(), img.size());
     Rect r1 = scale_rect(r, innerParameters.coeffTrackingWindowSize);
@@ -867,7 +864,7 @@ void cv::DetectionBasedTracker::detectInRegion(const Mat& img, const Rect& r, ve
     }
 }
 
-bool cv::DetectionBasedTracker::setParameters(const Parameters& params)
+bool DetectionBasedTracker::setParameters(const Parameters& params)
 {
     if ( params.maxTrackLifetime < 0 )
     {
@@ -885,7 +882,7 @@ bool cv::DetectionBasedTracker::setParameters(const Parameters& params)
     return true;
 }
 
-const cv::DetectionBasedTracker::Parameters& DetectionBasedTracker::getParameters() const
+const DetectionBasedTracker::Parameters& DetectionBasedTracker::getParameters() const
 {
     return parameters;
 }

diff --git a/modules/core/include/opencv2/core/core.hpp b/modules/core/include/opencv2/core/core.hpp
index c3a808f..5cc5262 100644 (file)
--- a/modules/core/include/opencv2/core/core.hpp
+++ b/modules/core/include/opencv2/core/core.hpp
@@ -2124,11 +2124,15 @@ CV_EXPORTS_W void reduce(InputArray src, OutputArray dst, int dim, int rtype, in
 
 //! makes multi-channel array out of several single-channel arrays
 CV_EXPORTS void merge(const Mat* mv, size_t count, OutputArray dst);
+CV_EXPORTS void merge(const vector<Mat>& mv, OutputArray dst );
+
 //! makes multi-channel array out of several single-channel arrays
 CV_EXPORTS_W void merge(InputArrayOfArrays mv, OutputArray dst);
 
 //! copies each plane of a multi-channel array to a dedicated array
 CV_EXPORTS void split(const Mat& src, Mat* mvbegin);
+CV_EXPORTS void split(const Mat& src, vector<Mat>& mv );
+    
 //! copies each plane of a multi-channel array to a dedicated array
 CV_EXPORTS_W void split(InputArray m, OutputArrayOfArrays mv);
 
@@ -2547,7 +2551,7 @@ CV_EXPORTS_W void fillPoly(InputOutputArray img, InputArrayOfArrays pts,
                            Point offset=Point() );
 
 //! draws one or more polygonal curves
-CV_EXPORTS void polylines(Mat& img, const Point* const* pts, const int* npts,
+CV_EXPORTS void polylines(Mat& img, const Point** pts, const int* npts,
                           int ncontours, bool isClosed, const Scalar& color,
                           int thickness=1, int lineType=8, int shift=0 );
 
@@ -3995,7 +3999,7 @@ public:
     //! 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 string releaseAndGetString();
+    CV_WRAP string releaseAndGetString();
 
     //! returns the first element of the top-level mapping
     CV_WRAP FileNode getFirstTopLevelNode() const;
@@ -4538,6 +4542,7 @@ template<> struct ParamType<uint64>
 class CV_EXPORTS CommandLineParser
 {
 public:
+    CommandLineParser(int argc, const char* const argv[], const char* keys);
     CommandLineParser(int argc, const char* const argv[], const string& keys);
     CommandLineParser(const CommandLineParser& parser);
     CommandLineParser& operator = (const CommandLineParser& parser);
@@ -4559,17 +4564,18 @@ public:
         getByIndex(index, space_delete, ParamType<T>::type, (void*)&val);
         return val;
     }
-
-    bool has(const string& name) const;
-
+    
+    bool has(const string& name);
     bool check() const;
 
     void about(const string& message);
 
     void printMessage() const;
     void printErrors() const;
+    void printParams();
 
 protected:
+    string getString(const string& name);
     void getByName(const string& name, bool space_delete, int type, void* dst) const;
     void getByIndex(int index, bool space_delete, int type, void* dst) const;
 

diff --git a/modules/core/include/opencv2/core/opengl_interop.hpp b/modules/core/include/opencv2/core/opengl_interop.hpp
index c039a1f..d680d82 100644 (file)
--- a/modules/core/include/opencv2/core/opengl_interop.hpp
+++ b/modules/core/include/opencv2/core/opengl_interop.hpp
@@ -221,7 +221,7 @@ public:
 \r
     static Ptr<GlFont> get(const std::string& family, int height = 12, Weight weight = WEIGHT_NORMAL, Style style = STYLE_NORMAL);\r
 \r
-    void draw(const char* str, size_t len) const;\r
+    void draw(const char* str, int len) const;\r
 \r
     inline const std::string& family() const { return family_; }\r
     inline int height() const { return height_; }\r

diff --git a/modules/core/src/command_line_parser.cpp b/modules/core/src/command_line_parser.cpp
index 840bf81..b83a899 100644 (file)
--- a/modules/core/src/command_line_parser.cpp
+++ b/modules/core/src/command_line_parser.cpp
@@ -27,9 +27,12 @@ struct CommandLineParser::Impl
     \r
     vector<CommandLineParserParams> data;\r
     \r
+    Impl() { refcount = 1; }\r
+    Impl(int argc, const char* const argv[], const char* keys);\r
+    \r
     vector<string> split_range_string(const string& str, char fs, char ss) const;\r
     vector<string> split_string(const string& str, char symbol = ' ', bool create_empty_item = false) const;\r
-    string cat_string(const string& str) const;\r
+    string trim_spaces(const string& str) const;\r
     \r
     void apply_params(const string& key, const string& value);\r
     void apply_params(int i, string value);\r
@@ -83,26 +86,39 @@ static void from_str(const string& str, int type, void* dst)
     }\r
 }\r
 \r
-void CommandLineParser::getByName(const string& name, bool space_delete, int type, void* dst) const\r
+string CommandLineParser::getString(const string& name)\r
 {\r
-    try\r
+    for (size_t i = 0; i < impl->data.size(); i++)\r
     {\r
-        for (size_t i = 0; i < impl->data.size(); i++)\r
+        for (size_t j = 0; j < impl->data[i].keys.size(); j++)\r
         {\r
-            for (size_t j = 0; j < impl->data[i].keys.size(); j++)\r
+            if (name.compare(impl->data[i].keys[j]) == 0)\r
             {\r
-                if (name.compare(impl->data[i].keys[j]) == 0)\r
-                {\r
-                    string v = impl->data[i].def_value;\r
-                    if (space_delete)\r
-                        v = impl->cat_string(v);\r
-                    from_str(v, type, dst);\r
-                    return;\r
-                }\r
+                string v = impl->data[i].def_value;\r
+                return v;\r
             }\r
         }\r
-        impl->error = true;\r
-        impl->error_message += "Unknown parametes " + name + "\n";\r
+    }\r
+    return string();\r
+}\r
+    \r
+void CommandLineParser::getByName(const string& name, bool space_delete, int type, void* dst) const\r
+{\r
+    try\r
+    {\r
+        string v = ((CommandLineParser*)this)->getString(name);\r
+        if( v.empty() )\r
+        {\r
+            impl->error = true;\r
+            impl->error_message += "Unknown parametes " + name + "\n";\r
+        }\r
+        else\r
+        {\r
+            if (space_delete)\r
+                v = impl->trim_spaces(v);\r
+            from_str(v, type, dst);\r
+            return;\r
+        }\r
     }\r
     catch (std::exception& e)\r
     {\r
@@ -121,7 +137,7 @@ void CommandLineParser::getByIndex(int index, bool space_delete, int type, void*
             if (impl->data[i].number == index)\r
             {\r
                 string v = impl->data[i].def_value;\r
-                if (space_delete == true) v = impl->cat_string(v);\r
+                if (space_delete == true) v = impl->trim_spaces(v);\r
                 from_str(v, type, dst);\r
                 return;\r
             }\r
@@ -154,36 +170,45 @@ static bool cmp_params(const CommandLineParserParams & p1, const CommandLinePars
 \r
 CommandLineParser::CommandLineParser(int argc, const char* const argv[], const string& keys)\r
 {\r
-    impl = new Impl;\r
-    impl->refcount = 1;\r
+    impl = new Impl(argc, argv, keys.c_str());\r
+}\r
+\r
+CommandLineParser::CommandLineParser(int argc, const char* const argv[], const char* keys)\r
+{\r
+    impl = new Impl(argc, argv, keys);\r
+}\r
+    \r
+CommandLineParser::Impl::Impl(int argc, const char* const argv[], const char* keys)\r
+{\r
+    refcount = 1;\r
     \r
     // path to application\r
     size_t pos_s = string(argv[0]).find_last_of("/\\");\r
     if (pos_s == string::npos)\r
     {\r
-        impl->path_to_app = "";\r
-        impl->app_name = string(argv[0]);\r
+        path_to_app = "";\r
+        app_name = string(argv[0]);\r
     }\r
     else\r
     {\r
-        impl->path_to_app = string(argv[0]).substr(0, pos_s);\r
-        impl->app_name = string(argv[0]).substr(pos_s + 1, string(argv[0]).length() - pos_s);\r
+        path_to_app = string(argv[0]).substr(0, pos_s);\r
+        app_name = string(argv[0]).substr(pos_s + 1, string(argv[0]).length() - pos_s);\r
     }\r
 \r
-    impl->error = false;\r
-    impl->error_message = "";\r
+    error = false;\r
+    error_message = "";\r
 \r
     // parse keys\r
-    vector<string> k = impl->split_range_string(keys, '{', '}');\r
+    vector<string> k = split_range_string(keys, '{', '}');\r
 \r
     int jj = 0;\r
     for (size_t i = 0; i < k.size(); i++)\r
     {\r
-        vector<string> l = impl->split_string(k[i], '|', true);\r
+        vector<string> l = split_string(k[i], '|', true);\r
         CommandLineParserParams p;\r
-        p.keys = impl->split_string(l[0]);\r
+        p.keys = split_string(l[0]);\r
         p.def_value = l[1];\r
-        p.help_message = impl->cat_string(l[2]);\r
+        p.help_message = trim_spaces(l[2]);\r
         p.number = -1;\r
         if (p.keys[0][0] == '@')\r
         {\r
@@ -191,7 +216,7 @@ CommandLineParser::CommandLineParser(int argc, const char* const argv[], const s
             jj++;\r
         }\r
 \r
-        impl->data.push_back(p);\r
+        data.push_back(p);\r
     }\r
 \r
     // parse argv\r
@@ -202,13 +227,13 @@ CommandLineParser::CommandLineParser(int argc, const char* const argv[], const s
 \r
         if (s.find('=') != string::npos && s.find('=') < s.length())\r
         {\r
-            vector<string> k_v = impl->split_string(s, '=', true);\r
+            vector<string> k_v = split_string(s, '=', true);\r
             for (int h = 0; h < 2; h++)\r
             {\r
                 if (k_v[0][0] == '-')\r
                     k_v[0] = k_v[0].substr(1, k_v[0].length() -1);\r
             }\r
-            impl->apply_params(k_v[0], k_v[1]);\r
+            apply_params(k_v[0], k_v[1]);\r
         }\r
         else if (s.length() > 1 && s[0] == '-')\r
         {\r
@@ -217,16 +242,16 @@ CommandLineParser::CommandLineParser(int argc, const char* const argv[], const s
                 if (s[0] == '-')\r
                     s = s.substr(1, s.length() - 1);\r
             }\r
-            impl->apply_params(s, "true");\r
+            apply_params(s, "true");\r
         }\r
         else if (s[0] != '-')\r
         {\r
-            impl->apply_params(jj, s);\r
+            apply_params(jj, s);\r
             jj++;\r
         }\r
     }\r
 \r
-    impl->sort_params();\r
+    sort_params();\r
 }\r
     \r
     \r
@@ -290,7 +315,7 @@ void CommandLineParser::Impl::sort_params()
     sort (data.begin(), data.end(), cmp_params);\r
 }\r
 \r
-string CommandLineParser::Impl::cat_string(const string& str) const\r
+string CommandLineParser::Impl::trim_spaces(const string& str) const\r
 {\r
     int left = 0, right = (int)str.length();\r
     while( left <= right && str[left] == ' ' )\r
@@ -305,7 +330,7 @@ string CommandLineParser::getPathToApplication() const
     return impl->path_to_app;\r
 }\r
 \r
-bool CommandLineParser::has(const string& name) const\r
+bool CommandLineParser::has(const string& name)\r
 {\r
     for (size_t i = 0; i < impl->data.size(); i++)\r
     {\r
@@ -333,6 +358,11 @@ void CommandLineParser::printErrors() const
     }\r
 }\r
 \r
+void CommandLineParser::printParams()\r
+{\r
+    printMessage();\r
+}\r
+    \r
 void CommandLineParser::printMessage() const\r
 {\r
     if (impl->about_message != "")\r
@@ -374,7 +404,7 @@ void CommandLineParser::printMessage() const
                     std::cout << ", ";\r
                 }\r
             }\r
-            string dv = impl->cat_string(impl->data[i].def_value);\r
+            string dv = impl->trim_spaces(impl->data[i].def_value);\r
             if (dv.compare("") != 0)\r
             {\r
                 std::cout << " (value:" << dv << ")";\r
@@ -394,7 +424,7 @@ void CommandLineParser::printMessage() const
 \r
             std::cout << k;\r
 \r
-            string dv = impl->cat_string(impl->data[i].def_value);\r
+            string dv = impl->trim_spaces(impl->data[i].def_value);\r
             if (dv.compare("") != 0)\r
             {\r
                 std::cout << " (value:" << dv << ")";\r

diff --git a/modules/core/src/convert.cpp b/modules/core/src/convert.cpp
index 1f6a85d..4cbbf9d 100644 (file)
--- a/modules/core/src/convert.cpp
+++ b/modules/core/src/convert.cpp
@@ -267,6 +267,11 @@ void cv::split(InputArray _m, OutputArrayOfArrays _mv)
     split(m, dst);
 }
 
+void cv::split(const Mat& src, vector<Mat>& mv)
+{
+    split(_InputArray(src), _OutputArray(mv));
+}
+
 void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
 {
     CV_Assert( mv && n > 0 );
@@ -349,6 +354,11 @@ void cv::merge(InputArrayOfArrays _mv, OutputArray _dst)
     merge(!mv.empty() ? &mv[0] : 0, mv.size(), _dst);
 }
 
+void cv::merge(const vector<Mat>& _mv, OutputArray _dst)
+{
+    merge(_InputArray(_mv), _dst);
+}
+
 /****************************************************************************************\
 *                       Generalized split/merge: mixing channels                         *
 \****************************************************************************************/

diff --git a/modules/core/src/drawing.cpp b/modules/core/src/drawing.cpp
index 50e51fb..c48b048 100644 (file)
--- a/modules/core/src/drawing.cpp
+++ b/modules/core/src/drawing.cpp
@@ -1730,7 +1730,7 @@ void fillPoly( Mat& img, const Point** pts, const int* npts, int ncontours,
 }
 
 
-void polylines( Mat& img, const Point* const* pts, const int* npts, int ncontours, bool isClosed,
+void polylines( Mat& img, const Point** pts, const int* npts, int ncontours, bool isClosed,
                 const Scalar& color, int thickness, int line_type, int shift )
 {
     if( line_type == CV_AA && img.depth() != CV_8U )

diff --git a/modules/core/src/opengl_interop.cpp b/modules/core/src/opengl_interop.cpp
index a549366..d01cfc8 100644 (file)
--- a/modules/core/src/opengl_interop.cpp
+++ b/modules/core/src/opengl_interop.cpp
@@ -1257,7 +1257,7 @@ cv::GlFont::GlFont(const string& _family, int _height, Weight _weight, Style _st
 #endif\r
 }\r
 \r
-void cv::GlFont::draw(const char* str, size_t len) const\r
+void cv::GlFont::draw(const char* str, int len) const\r
 {\r
 #ifndef HAVE_OPENGL\r
     (void)str;\r
@@ -1409,7 +1409,7 @@ void cv::render(const string& str, const Ptr<GlFont>& font, Scalar color, Point2
 \r
     glRasterPos2d(2.0 * (viewport[0] + pos.x) / viewport[2] - 1.0, 1.0 - 2.0 * (viewport[1] + pos.y + font->height()) / viewport[3]);\r
 \r
-    font->draw(str.c_str(), str.length());\r
+    font->draw(str.c_str(), (int)str.length());\r
 \r
     glPopAttrib();\r
 #endif\r

diff --git a/modules/imgproc/include/opencv2/imgproc/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc/imgproc.hpp
index 63f5218..34d59e1 100644 (file)
--- a/modules/imgproc/include/opencv2/imgproc/imgproc.hpp
+++ b/modules/imgproc/include/opencv2/imgproc/imgproc.hpp
@@ -636,8 +636,10 @@ CV_EXPORTS_W void accumulateWeighted( InputArray src, InputOutputArray dst,
 //! computes PSNR image/video quality metric
 CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2);
 
+CV_EXPORTS Point2d phaseCorrelate(InputArray src1, InputArray src2,
+                                  InputArray window = noArray());
 CV_EXPORTS_W Point2d phaseCorrelate(InputArray src1, InputArray src2,
-                                    InputArray window = noArray(), CV_OUT double* response=0);
+                                    InputArray window, CV_OUT double* response CV_WRAP_DEFAULT(0));
 CV_EXPORTS_W void createHanningWindow(OutputArray dst, Size winSize, int type);
 
 //! type of the threshold operation

diff --git a/modules/imgproc/src/phasecorr.cpp b/modules/imgproc/src/phasecorr.cpp
index 3b6c2eb..dd5497f 100644 (file)
--- a/modules/imgproc/src/phasecorr.cpp
+++ b/modules/imgproc/src/phasecorr.cpp
@@ -568,6 +568,10 @@ cv::Point2d cv::phaseCorrelate(InputArray _src1, InputArray _src2, InputArray _w
     return (center - t);
 }
 
+cv::Point2d cv::phaseCorrelate(InputArray _src1, InputArray _src2, InputArray _window)
+{
+    return phaseCorrelate(_src1, _src2, _window, 0);
+}
 
 void cv::createHanningWindow(OutputArray _dst, cv::Size winSize, int type)
 {

diff --git a/modules/videostab/include/opencv2/videostab/deblurring.hpp b/modules/videostab/include/opencv2/videostab/deblurring.hpp
index d2ab438..2e32350 100644 (file)
--- a/modules/videostab/include/opencv2/videostab/deblurring.hpp
+++ b/modules/videostab/include/opencv2/videostab/deblurring.hpp
@@ -63,9 +63,6 @@ public:
     virtual void setRadius(int val) { radius_ = val; }
     virtual int radius() const { return radius_; }
 
-    virtual void deblur(int idx, Mat &frame) = 0;
-
-
     // data from stabilizer
 
     virtual void setFrames(const std::vector<Mat> &val) { frames_ = &val; }
@@ -77,6 +74,9 @@ public:
     virtual void setBlurrinessRates(const std::vector<float> &val) { blurrinessRates_ = &val; }
     virtual const std::vector<float>& blurrinessRates() const { return *blurrinessRates_; }
 
+    virtual void update() {}
+    virtual void deblur(int idx, Mat &frame) = 0;
+
 protected:
     int radius_;
     const std::vector<Mat> *frames_;