Merge pull request #12467 from alalek:core_use_shared_ptr

modules/core/include/opencv2/core/cvstd_wrapper.hpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_CORE_CVSTD_WRAPPER_HPP
+#define OPENCV_CORE_CVSTD_WRAPPER_HPP
+
+#include "opencv2/core/cvdef.h"
+
+#include <string>
+#include <memory>  // std::shared_ptr
+#include <type_traits>  // std::enable_if
+
+namespace cv {
+
+using std::nullptr_t;
+
+//! @addtogroup core_basic
+//! @{
+
+#ifdef CV_DOXYGEN
+
+template <typename _Tp> using Ptr = std::shared_ptr<_Tp>;  // In ideal world it should look like this, but we need some compatibility workarounds below
+
+template<typename _Tp, typename ... A1> static inline
+Ptr<_Tp> makePtr(const A1&... a1) { return std::make_shared<_Tp>(a1...); }
+
+#else  // cv::Ptr with compatibility workarounds
+
+template<typename Y>
+struct DefaultDeleter
+{
+#ifndef _MSC_VER
+    void operator()(Y* p) const = delete;  // not available by default; enabled for specializations only
+#else
+    void operator()(Y* p) const { delete p; }
+#endif
+};
+
+namespace sfinae {
+template<typename C, typename Ret, typename... Args>
+struct has_parenthesis_operator
+{
+private:
+    template<typename T>
+    static constexpr std::true_type check(typename std::is_same<typename std::decay<decltype(std::declval<T>().operator()(std::declval<Args>()...))>::type, Ret>::type*);
+
+    template<typename> static constexpr std::false_type check(...);
+
+    typedef decltype(check<C>(0)) type;
+
+public:
+    static constexpr bool value = type::value;
+};
+} // namespace sfinae
+
+template <typename Y> using has_custom_delete = sfinae::has_parenthesis_operator<DefaultDeleter<Y>, void, Y*>;
+
+template<typename T>
+struct Ptr : public std::shared_ptr<T>
+{
+#if 0
+    using std::shared_ptr<T>::shared_ptr;  // GCC 5.x can't handle this
+#else
+    inline Ptr() noexcept : std::shared_ptr<T>() {}
+    inline Ptr(nullptr_t) noexcept : std::shared_ptr<T>(nullptr) {}
+    template<typename Y, typename D> inline Ptr(Y* p, D d) : std::shared_ptr<T>(p, d) {}
+    template<typename D> inline Ptr(nullptr_t, D d) : std::shared_ptr<T>(nullptr, d) {}
+
+    template<typename Y> inline Ptr(const Ptr<Y>& r, T* ptr) noexcept : std::shared_ptr<T>(r, ptr) {}
+
+    inline Ptr(const Ptr<T>& o) noexcept : std::shared_ptr<T>(o) {}
+    inline Ptr(Ptr<T>&& o) noexcept : std::shared_ptr<T>(std::move(o)) {}
+
+    template<typename Y> inline Ptr(const Ptr<Y>& o) noexcept : std::shared_ptr<T>(o) {}
+    template<typename Y> inline Ptr(Ptr<Y>&& o) noexcept : std::shared_ptr<T>(std::move(o)) {}
+#endif
+    inline Ptr(const std::shared_ptr<T>& o) noexcept : std::shared_ptr<T>(o) {}
+    inline Ptr(std::shared_ptr<T>&& o) noexcept : std::shared_ptr<T>(std::move(o)) {}
+
+#ifndef _MSC_VER
+    // Overload with custom DefaultDeleter: Ptr<IplImage>(...)
+    template<typename Y = T, class = typename std::enable_if< has_custom_delete<Y>::value >::type>
+    inline Ptr(Y* ptr) : std::shared_ptr<T>(ptr, DefaultDeleter<Y>()) {}
+
+    // Overload without custom deleter: Ptr<std::string>(...);
+    template<typename Y = T, int = sizeof(typename std::enable_if< !has_custom_delete<Y>::value, int >::type) >
+    inline Ptr(Y* ptr) : std::shared_ptr<T>(ptr) {}
+
+    // Overload with custom DefaultDeleter: Ptr<IplImage>(...)
+    template<typename Y, class = typename std::enable_if< has_custom_delete<Y>::value >::type>
+    inline void reset(Y* ptr) { std::shared_ptr<T>::reset(ptr, DefaultDeleter<Y>()); }
+
+    // Overload without custom deleter: Ptr<std::string>(...);
+    template<typename Y, int = sizeof(typename std::enable_if< !has_custom_delete<Y>::value, int >::type) >
+    inline void reset(Y* ptr) { std::shared_ptr<T>::reset(ptr); }
+#else
+    template<typename Y>
+    inline Ptr(Y* ptr) : std::shared_ptr<T>(ptr, DefaultDeleter<Y>()) {}
+
+    template<typename Y>
+    inline void reset(Y* ptr) { std::shared_ptr<T>::reset(ptr, DefaultDeleter<Y>()); }
+#endif
+
+    template<class Y, class Deleter>
+    void reset(Y* ptr, Deleter d) { std::shared_ptr<T>::reset(ptr, d); }
+
+    void reset() noexcept { std::shared_ptr<T>::reset(); }
+
+    Ptr& operator=(const Ptr& o) { std::shared_ptr<T>::operator =(o); return *this; }
+    template<typename Y> inline Ptr& operator=(const Ptr<Y>& o) { std::shared_ptr<T>::operator =(o); return *this; }
+
+    T* operator->() const noexcept { return std::shared_ptr<T>::get();}
+    typename std::add_lvalue_reference<T>::type operator*() const noexcept { return *std::shared_ptr<T>::get(); }
+
+    // OpenCV 3.x methods (not a part of standart C++ library)
+    inline void release() { std::shared_ptr<T>::reset(); }
+    inline operator T* () const { return std::shared_ptr<T>::get(); }
+    inline bool empty() const { return std::shared_ptr<T>::get() == NULL; }
+
+    template<typename Y> inline
+    Ptr<Y> staticCast() const noexcept { return std::static_pointer_cast<Y>(*this); }
+
+    template<typename Y> inline
+    Ptr<Y> constCast() const noexcept { return std::const_pointer_cast<Y>(*this); }
+
+    template<typename Y> inline
+    Ptr<Y> dynamicCast() const noexcept { return std::dynamic_pointer_cast<Y>(*this); }
+};
+
+template<typename _Tp, typename ... A1> static inline
+Ptr<_Tp> makePtr(const A1&... a1)
+{
+#ifndef _MSC_VER
+    static_assert( !has_custom_delete<_Tp>::value, "Can't use this makePtr with custom DefaultDeleter");
+    return (Ptr<_Tp>)std::make_shared<_Tp>(a1...);
+#else
+    return Ptr<_Tp>(new _Tp(a1...), DefaultDeleter<_Tp>());
+#endif
+}
+
+#endif // CV_DOXYGEN
+
+//! @} core_basic
+} // cv
+
+#endif //OPENCV_CORE_CVSTD_WRAPPER_HPP

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

-/*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) 2013, NVIDIA Corporation, 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 copyright holders 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_PTR_INL_HPP
-#define OPENCV_CORE_PTR_INL_HPP
-
-#include <algorithm>
-
-//! @cond IGNORED
-
-namespace cv {
-
-template<typename Y>
-void DefaultDeleter<Y>::operator () (Y* p) const
-{
-    delete p;
-}
-
-namespace detail
-{
-
-struct PtrOwner
-{
-    PtrOwner() : refCount(1)
-    {}
-
-    void incRef()
-    {
-        CV_XADD(&refCount, 1);
-    }
-
-    void decRef()
-    {
-        if (CV_XADD(&refCount, -1) == 1) deleteSelf();
-    }
-
-protected:
-    /* This doesn't really need to be virtual, since PtrOwner is never deleted
-       directly, but it doesn't hurt and it helps avoid warnings. */
-    virtual ~PtrOwner()
-    {}
-
-    virtual void deleteSelf() = 0;
-
-private:
-    unsigned int refCount;
-
-    // noncopyable
-    PtrOwner(const PtrOwner&);
-    PtrOwner& operator = (const PtrOwner&);
-};
-
-template<typename Y, typename D>
-struct PtrOwnerImpl CV_FINAL : PtrOwner
-{
-    PtrOwnerImpl(Y* p, D d) : owned(p), deleter(d)
-    {}
-
-    void deleteSelf() CV_OVERRIDE
-    {
-        deleter(owned);
-        delete this;
-    }
-
-private:
-    Y* owned;
-    D deleter;
-};
-
-
-}
-
-template<typename T>
-Ptr<T>::Ptr() : owner(NULL), stored(NULL)
-{}
-
-template<typename T>
-template<typename Y>
-Ptr<T>::Ptr(Y* p)
-  : owner(p
-      ? new detail::PtrOwnerImpl<Y, DefaultDeleter<Y> >(p, DefaultDeleter<Y>())
-      : NULL),
-    stored(p)
-{}
-
-template<typename T>
-template<typename Y, typename D>
-Ptr<T>::Ptr(Y* p, D d)
-  : owner(p
-      ? new detail::PtrOwnerImpl<Y, D>(p, d)
-      : NULL),
-    stored(p)
-{}
-
-template<typename T>
-Ptr<T>::Ptr(const Ptr& o) : owner(o.owner), stored(o.stored)
-{
-    if (owner) owner->incRef();
-}
-
-template<typename T>
-template<typename Y>
-Ptr<T>::Ptr(const Ptr<Y>& o) : owner(o.owner), stored(o.stored)
-{
-    if (owner) owner->incRef();
-}
-
-template<typename T>
-template<typename Y>
-Ptr<T>::Ptr(const Ptr<Y>& o, T* p) : owner(o.owner), stored(p)
-{
-    if (owner) owner->incRef();
-}
-
-template<typename T>
-Ptr<T>::~Ptr()
-{
-    release();
-}
-
-template<typename T>
-Ptr<T>& Ptr<T>::operator = (const Ptr<T>& o)
-{
-    Ptr(o).swap(*this);
-    return *this;
-}
-
-template<typename T>
-template<typename Y>
-Ptr<T>& Ptr<T>::operator = (const Ptr<Y>& o)
-{
-    Ptr(o).swap(*this);
-    return *this;
-}
-
-template<typename T>
-void Ptr<T>::release()
-{
-    if (owner) owner->decRef();
-    owner = NULL;
-    stored = NULL;
-}
-
-template<typename T>
-template<typename Y>
-void Ptr<T>::reset(Y* p)
-{
-    Ptr(p).swap(*this);
-}
-
-template<typename T>
-template<typename Y, typename D>
-void Ptr<T>::reset(Y* p, D d)
-{
-    Ptr(p, d).swap(*this);
-}
-
-template<typename T>
-void Ptr<T>::swap(Ptr<T>& o)
-{
-    std::swap(owner, o.owner);
-    std::swap(stored, o.stored);
-}
-
-template<typename T>
-T* Ptr<T>::get() const
-{
-    return stored;
-}
-
-template<typename T>
-typename detail::RefOrVoid<T>::type Ptr<T>::operator * () const
-{
-    return *stored;
-}
-
-template<typename T>
-T* Ptr<T>::operator -> () const
-{
-    return stored;
-}
-
-template<typename T>
-Ptr<T>::operator T* () const
-{
-    return stored;
-}
-
-
-template<typename T>
-bool Ptr<T>::empty() const
-{
-    return !stored;
-}
-
-template<typename T>
-template<typename Y>
-Ptr<Y> Ptr<T>::staticCast() const
-{
-    return Ptr<Y>(*this, static_cast<Y*>(stored));
-}
-
-template<typename T>
-template<typename Y>
-Ptr<Y> Ptr<T>::constCast() const
-{
-    return Ptr<Y>(*this, const_cast<Y*>(stored));
-}
-
-template<typename T>
-template<typename Y>
-Ptr<Y> Ptr<T>::dynamicCast() const
-{
-    return Ptr<Y>(*this, dynamic_cast<Y*>(stored));
-}
-
-template<typename T>
-Ptr<T>::Ptr(Ptr&& o) : owner(o.owner), stored(o.stored)
-{
-    o.owner = NULL;
-    o.stored = NULL;
-}
-
-template<typename T>
-Ptr<T>& Ptr<T>::operator = (Ptr<T>&& o)
-{
-    if (this == &o)
-        return *this;
-
-    release();
-    owner = o.owner;
-    stored = o.stored;
-    o.owner = NULL;
-    o.stored = NULL;
-    return *this;
-}
-
-
-template<typename T>
-void swap(Ptr<T>& ptr1, Ptr<T>& ptr2){
-    ptr1.swap(ptr2);
-}
-
-template<typename T>
-bool operator == (const Ptr<T>& ptr1, const Ptr<T>& ptr2)
-{
-    return ptr1.get() == ptr2.get();
-}
-
-template<typename T>
-bool operator != (const Ptr<T>& ptr1, const Ptr<T>& ptr2)
-{
-    return ptr1.get() != ptr2.get();
-}
-
-template<typename T>
-Ptr<T> makePtr()
-{
-    return Ptr<T>(new T());
-}
-
-template<typename T, typename A1>
-Ptr<T> makePtr(const A1& a1)
-{
-    return Ptr<T>(new T(a1));
-}
-
-template<typename T, typename A1, typename A2>
-Ptr<T> makePtr(const A1& a1, const A2& a2)
-{
-    return Ptr<T>(new T(a1, a2));
-}
-
-template<typename T, typename A1, typename A2, typename A3>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3)
-{
-    return Ptr<T>(new T(a1, a2, a3));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10, const A11& a11)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10, const A11& a11, const A12& a12)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12));
-}
-} // namespace cv
-
-//! @endcond
-
-#endif // OPENCV_CORE_PTR_INL_HPP

modules/core/src/lut.cpp

@@ -384,21 +384,14 @@ void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst )
     if (_src.dims() <= 2)
     {
         bool ok = false;
-        Ptr<ParallelLoopBody> body;
-
-        if (body == NULL || ok == false)
-        {
-            ok = false;
-            ParallelLoopBody* p = new LUTParallelBody(src, lut, dst, &ok);
-            body.reset(p);
-        }
-        if (body != NULL && ok)
+        LUTParallelBody body(src, lut, dst, &ok);
+        if (ok)
         {
             Range all(0, dst.rows);
-            if (dst.total()>>18)
-                parallel_for_(all, *body, (double)std::max((size_t)1, dst.total()>>16));
+            if (dst.total() >= (size_t)(1<<18))
+                parallel_for_(all, body, (double)std::max((size_t)1, dst.total()>>16));
             else
-                (*body)(all);
+                body(all);
             if (ok)
                 return;
         }

modules/core/src/persistence_cpp.cpp

@@ -537,7 +537,7 @@ void read( const FileNode& node, SparseMat& mat, const SparseMat& default_mat )
         return;
     }
     Ptr<CvSparseMat> m((CvSparseMat*)cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node));
-    CV_Assert(CV_IS_SPARSE_MAT(m));
+    CV_Assert(CV_IS_SPARSE_MAT(m.get()));
     m->copyToSparseMat(mat);
 }
 

modules/core/test/test_io.cpp

@@ -288,9 +288,9 @@ protected:
             fs["test_sparse_mat"] >> m_s2;
             Ptr<CvSparseMat> _m_s2(cvCreateSparseMat(m_s2));
 
-            if( !m_s || !CV_IS_SPARSE_MAT(m_s) ||
-               !cvTsCheckSparse(m_s, _test_sparse, 0) ||
-               !cvTsCheckSparse(_m_s2, _test_sparse, 0))
+            if( !m_s || !CV_IS_SPARSE_MAT(m_s.get()) ||
+               !cvTsCheckSparse(m_s.get(), _test_sparse.get(), 0) ||
+               !cvTsCheckSparse(_m_s2.get(), _test_sparse.get(), 0))
             {
                 ts->printf( cvtest::TS::LOG, "the read sparse matrix is not correct\n" );
                 ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );

modules/core/test/test_ptr.cpp

@@ -98,22 +98,25 @@ TEST(Core_Ptr, owning_ctor)
         Ptr<void> p(r);
         EXPECT_EQ(r, p.get());
     }
-
     EXPECT_TRUE(deleted);
 
     {
         Ptr<int> p(&dummyObject, ReportingDeleter(&deleted));
         EXPECT_EQ(&dummyObject, p.get());
     }
-
     EXPECT_TRUE(deleted);
 
     {
         Ptr<void> p((void*)0, ReportingDeleter(&deleted));
         EXPECT_NULL(p.get());
     }
+    EXPECT_TRUE(deleted);  // Differ from OpenCV 3.4 (but conformant to std::shared_ptr, see below)
 
-    EXPECT_FALSE(deleted);
+    {
+        std::shared_ptr<void> p((void*)0, ReportingDeleter(&deleted));
+        EXPECT_NULL(p.get());
+    }
+    EXPECT_TRUE(deleted);
 }
 
 TEST(Core_Ptr, sharing_ctor)
@@ -337,7 +340,7 @@ TEST(Core_Ptr, casts)
         Ptr<SubReporter> p2 = p1.dynamicCast<SubReporter>();
         EXPECT_NULL(p2.get());
         p1.release();
-        EXPECT_FALSE(deleted);
+        EXPECT_TRUE(deleted);
     }
 
     EXPECT_TRUE(deleted);
@@ -400,4 +403,16 @@ TEST(Core_Ptr, specialized_deleter)
     ASSERT_TRUE(sd.deleted);
 }
 
+TEST(Core_Ptr, specialized_deleter_via_reset)
+{
+    SpeciallyDeletable sd;
+
+    {
+        Ptr<SpeciallyDeletable> p;
+        p.reset(&sd);
+    }
+
+    ASSERT_TRUE(sd.deleted);
+}
+
 }} // namespace

modules/dnn/src/ocl4dnn/src/ocl4dnn_conv_spatial.cpp

@@ -1820,7 +1820,7 @@ void OCL4DNNConvSpatial<Dtype>::prepareKernel(const UMat &bottom, UMat &top,
     std::string previous_key = key_;
 
     generateKey();
-    if (key_.compare(previous_key) == 0 && bestKernelConfig != NULL)
+    if (key_.compare(previous_key) == 0 && bestKernelConfig)
         return;
 
     if (bestKernelConfig)

modules/ml/test/test_mltests2.cpp

@@ -237,7 +237,7 @@ TEST(ML_ANN, ActivationFunction)
         x->save(dataname + activationName[i] + ".yml");
 #else
         Ptr<ml::ANN_MLP> y = Algorithm::load<ANN_MLP>(dataname + activationName[i] + ".yml");
-        ASSERT_TRUE(y != NULL) << "Could not load   " << dataname + activationName[i] + ".yml";
+        ASSERT_TRUE(y) << "Could not load   " << dataname + activationName[i] + ".yml";
         Mat testSamples = tdata->getTestSamples();
         Mat rx, ry, dst;
         x->predict(testSamples, rx);
@@ -330,7 +330,7 @@ TEST_P(ML_ANN_METHOD, Test)
 #endif
         ASSERT_FALSE(r_gold.empty());
         Ptr<ml::ANN_MLP> y = Algorithm::load<ANN_MLP>(filename);
-        ASSERT_TRUE(y != NULL) << "Could not load   " << filename;
+        ASSERT_TRUE(y) << "Could not load   " << filename;
         Mat rx, ry;
         for (int j = 0; j < 4; j++)
         {

samples/cpp/detect_blob.cpp

@@ -178,7 +178,7 @@ int main(int argc, char *argv[])
             vector<Rect>  zone;
             vector<vector <Point> >  region;
             Mat     desc, result(img.rows, img.cols, CV_8UC3);
-            if (b.dynamicCast<SimpleBlobDetector>() != NULL)
+            if (b.dynamicCast<SimpleBlobDetector>().get())
             {
                 Ptr<SimpleBlobDetector> sbd = b.dynamicCast<SimpleBlobDetector>();
                 sbd->detect(img, keyImg, Mat());

samples/cpp/detect_mser.cpp

@@ -500,7 +500,7 @@ int main(int argc, char *argv[])
             vector<vector <Point> > region;
             Mat desc;
 
-            if (b.dynamicCast<MSER>() != NULL)
+            if (b.dynamicCast<MSER>().get())
             {
                 Ptr<MSER> sbd = b.dynamicCast<MSER>();
                 sbd->detectRegions(img, region, zone);