Add shared ptr

diff --git a/main.cpp b/main.cpp
index c38b655..13d3d3f 100644 (file)
--- a/main.cpp
+++ b/main.cpp
@@ -26,7 +26,7 @@ int main(int argc, char* argv[])
     initLogger("log4cpp.properties");
     LOG_DEBUG(TAG, "==================================");
 
-    Engine* e = Engine::create();
+    EnginePtr e = Engine::create();
     e->addObserver(new Callback());
     e->setVideoSrc(VideoSrcType::URL, "rtsp://192.168.1.75:554/stream1");
     e->start();

diff --git a/src/Detector.h b/src/Detector.h
index a2c43cf..5cf08c1 100644 (file)
--- a/src/Detector.h
+++ b/src/Detector.h
@@ -1,16 +1,19 @@
 #ifndef _DETECTOR_H_
 #define _DETECTOR_H_
+
 #include "VideoReader.h"
+#include "SharedPtr.h"
 
 namespace suanzi {
 
-class Detector
-{
-public:
-    Detector();
-    virtual ~Detector();
-    void detect(cv::Mat& frame){};
-};
+    TK_DECLARE_PTR(Detector);
+    class Detector
+    {
+    public:
+        Detector();
+        virtual ~Detector();
+        void detect(cv::Mat& frame){};
+    };
 
 }
 

diff --git a/src/Engine.cpp b/src/Engine.cpp
index 82fed4a..be5ceda 100644 (file)
--- a/src/Engine.cpp
+++ b/src/Engine.cpp
@@ -8,36 +8,38 @@ using namespace suanzi;
 const static std::string TAG = "Engine";
 
 static std::mutex g_mutex;
-static Engine* g_instance = nullptr;
+static EngineWPtr g_instance;
 
-Engine::Engine()
-{
-    detector = new Detector();
-}
 
-Engine* Engine::create()
+EnginePtr Engine::create()
 {
     LOG_DEBUG(TAG, "create");
     std::lock_guard<std::mutex> lock(g_mutex);
-    if (g_instance)
-        return g_instance;
-    
-    Engine* instance (new Engine());
+    if (g_instance.lock()){
+        LOG_ERROR(TAG, "already exists");
+        return EnginePtr(); // nullptr
+    }
+    EnginePtr instance (new Engine());
     g_instance = instance;
-    return g_instance;
+    return instance;
 }
 
-void Engine::destroy()
+Engine::Engine()
 {
-    delete g_instance;
+    detector = std::make_shared<Detector>();
+    MetricsPtr m (new Metrics("model.pkl"));
+    multiTracker = std::make_shared<MultiTracker>(m);
 }
 
 Engine::~Engine()
 {    
-    delete detector;
-//    delete tracker;
 }
 
+void Engine::destroy()
+{
+}
+
+
 void Engine::setVideoSrc(VideoSrcType type, const std::string& url)
 {
     videoSrc = url;

diff --git a/src/Engine.h b/src/Engine.h
index ebf65c5..bcfc786 100644 (file)
--- a/src/Engine.h
+++ b/src/Engine.h
@@ -6,30 +6,35 @@
 #include<set>
 #include "Tracker.h"
 #include "Detector.h"
+#include "MultiTracker.h"
 #include "VideoReader.h"
+#include "SharedPtr.h"
 
 namespace suanzi{
 
 class EngineObserver;
 
+TK_DECLARE_PTR(Engine);
+
 class Engine
 {
 public:
-    static Engine* create();
+    static EnginePtr create();
     void destroy();
+    virtual ~Engine();
+
     virtual void start();
     void addObserver(EngineObserver* o);
     void setVideoSrc(VideoSrcType type, const std::string& url);
 
 private:
     Engine();
-    virtual ~Engine();
     void run();
-//    Tracker* tracker;
-    Detector* detector;
+    DetectorPtr detector;
+    MultiTrackerPtr multiTracker;
     std::set<EngineObserver *> observer_list;
     std::string videoSrc;
-    VideoReader* reader;
+    VideoReaderPtr reader;
 };
 
 struct Person

diff --git a/src/Metrics.h b/src/Metrics.h
index dbfca55..a436321 100644 (file)
--- a/src/Metrics.h
+++ b/src/Metrics.h
@@ -3,27 +3,30 @@
 
 #include <string>
 #include <opencv2/opencv.hpp>
+#include "SharedPtr.h"
 
 namespace suanzi {
 
-class Metrics
-{
-public:
-    Metrics(const std::string& cl_path = "");
-    ~Metrics(){}
-    long int MaxCost = 100000;
-    const static int MaxPatch = 5;
+    TK_DECLARE_PTR(Metrics);
+    TK_DECLARE_PTR(Patch);
+    class Metrics
+    {
+    public:
+        Metrics(const std::string& cl_path = "");
+        ~Metrics(){}
+        long int MaxCost = 100000;
+        const static int MaxPatch = 5;
 
-private:
-    cv::HOGDescriptor descriptor;
-};
+    private:
+        cv::HOGDescriptor descriptor;
+    };
 
-class Patch
-{
-public:
-    Patch(){};
-    ~Patch(){};
-};
+    class Patch
+    {
+    public:
+        Patch(){};
+        ~Patch(){};
+    };
 
 }
 

diff --git a/src/MultiTracker.cpp b/src/MultiTracker.cpp
index 2206af3..e52b8e2 100644 (file)
--- a/src/MultiTracker.cpp
+++ b/src/MultiTracker.cpp
@@ -3,30 +3,29 @@
 
 using namespace suanzi;
 
-MultiTracker::MultiTracker(Metrics* m) : metrics(m)
+MultiTracker::MultiTracker(MetricsPtr m) : metrics(m)
 {
 }
 
 
 MultiTracker::~MultiTracker()
 {
-    delete metrics;
     trackers.clear();
 }
 
-Tracker* MultiTracker::createTracker(int id)
+TrackerPtr MultiTracker::createTracker(int id)
 {
-    Tracker* t = new Tracker(id);
+    TrackerPtr t (new Tracker(id));
     addTracker(t);
     return t;
 }
 
-void MultiTracker::addTracker(Tracker* t)
+void MultiTracker::addTracker(TrackerPtr t)
 {
     trackers.insert(t);
 }
 
-void MultiTracker::removeTracker(Tracker *t)
+void MultiTracker::removeTracker(TrackerPtr t)
 {
     trackers.erase(t);
 }

diff --git a/src/MultiTracker.h b/src/MultiTracker.h
index 5fc13f9..28ab685 100644 (file)
--- a/src/MultiTracker.h
+++ b/src/MultiTracker.h
@@ -3,25 +3,27 @@
 
 #include "Tracker.h"
 #include "Metrics.h"
+#include "SharedPtr.h"
 
 namespace suanzi {
 
-class MultiTracker 
-{
-public:
-    MultiTracker(Metrics* m);
-    virtual ~MultiTracker();
-    void addTracker(Tracker *t);
-    void removeTracker(Tracker *t);
-    Tracker* createTracker(int id = 0);
-    void update();
-    
+    TK_DECLARE_PTR(MultiTracker);
 
-private:
-    Metrics* metrics;
-    std::set<Tracker*> trackers;
-    int max_id = 0;
-};
+    class MultiTracker 
+    {
+    public:
+        MultiTracker(MetricsPtr m);
+        virtual ~MultiTracker();
+        void addTracker(TrackerPtr t);
+        void removeTracker(TrackerPtr t);
+        TrackerPtr createTracker(int id = 0);
+        void update();
+        
+    private:
+        MetricsPtr metrics;
+        std::set<TrackerPtr> trackers;
+        int max_id = 0;
+    };
 
 
 }

diff --git a/src/SharedPtr.h b/src/SharedPtr.h
new file mode 100644 (file)
index 0000000..9b13584
--- /dev/null
+++ b/src/SharedPtr.h
@@ -0,0 +1,12 @@
+#ifndef _SHARED_PTR_H_
+#define _SHARED_PTR_H_
+
+#include <memory>
+#ifndef TK_DECLARE_PTR
+#define  TK_DECLARE_PTR(className) \
+    class className; \
+    typedef std::shared_ptr<className> className##Ptr; \
+    typedef std::weak_ptr<className> className##WPtr;
+#endif
+
+#endif /* _SHARED_PTR_H_ */

diff --git a/src/Tracker.h b/src/Tracker.h
index c87f465..262ae5f 100644 (file)
--- a/src/Tracker.h
+++ b/src/Tracker.h
@@ -5,33 +5,35 @@
 #include <string>
 #include <vector>
 #include "Metrics.h"
+#include "SharedPtr.h"
 
 namespace suanzi {
 
-typedef enum 
-{
-    Fire = -1,
-    Active = 2,
-    Lost,
-    Delete
-} TrackerStatus;
-
-class Tracker
-{
-public:
-    Tracker(int id);
-    virtual ~Tracker();
-    void updateState(const cv::Mat& image);
-    void addPatch(Patch* p);
-
-private:
-    TrackerStatus status;
-    TrackerStatus preStatus;
-    int id;
-    int age;
-    int last_active;
-    std::vector<Patch *> patches;
-};
+    typedef enum 
+    {
+        Fire = -1,
+        Active = 2,
+        Lost,
+        Delete
+    } TrackerStatus;
+
+    TK_DECLARE_PTR(Tracker);
+    class Tracker
+    {
+    public:
+        Tracker(int id);
+        virtual ~Tracker();
+        void updateState(const cv::Mat& image);
+        void addPatch(Patch* p);
+
+    private:
+        TrackerStatus status;
+        TrackerStatus preStatus;
+        int id;
+        int age;
+        int last_active;
+        std::vector<Patch *> patches;
+    };
 
 
 }

diff --git a/src/VideoReader.cpp b/src/VideoReader.cpp
index 0945527..17d5518 100644 (file)
--- a/src/VideoReader.cpp
+++ b/src/VideoReader.cpp
@@ -6,23 +6,28 @@ using namespace cv;
 
 const static std::string TAG = "VideoReader";
 
-VideoReader* VideoReaderFactory::createVideoReader(VideoSrcType type, const std::string& url)
+VideoReaderPtr VideoReaderFactory::createVideoReader(VideoSrcType type, const std::string& url)
 {
-    VideoReader* v = nullptr;
     switch(type){
         case VideoSrcType::URL:
-            v = new UrlReader(type, url);
-            break;
+            {
+                VideoReaderPtr v (new UrlReader(type, url));
+                return v;
+            }
         case VideoSrcType::File:
-            v = new FileReader(type, url);
-            break;
+            {
+                VideoReaderPtr v (new FileReader(type, url));
+                return v;
+            }
         case VideoSrcType::USB:
-            v = new UsbReader(type, url);
-            break;
+            {
+                VideoReaderPtr v (new UsbReader(type, url));
+                return v;
+            }
         default:
             break;
     }
-    return v;
+    return nullptr;
 }
 
 VideoReader::~VideoReader()

diff --git a/src/VideoReader.h b/src/VideoReader.h
index 340b548..79d39d0 100644 (file)
--- a/src/VideoReader.h
+++ b/src/VideoReader.h
@@ -1,65 +1,66 @@
 #ifndef _IVIDEO_READER_H_
 #define _IVIDEO_READER_H_
 
+#include "SharedPtr.h"
 #include <string>
 #include <opencv2/opencv.hpp>
 
 namespace suanzi {
 
-typedef enum {
-    URL,
-    File,
-    USB
-} VideoSrcType;
-
-class VideoReader;
-
-class VideoReaderFactory
-{
-public:
-    static VideoReader* createVideoReader(VideoSrcType type, const std::string& url);
-};
-
-class VideoReader
-{
-public:
-    VideoReader(VideoSrcType type, const std::string& url) : type(type), url(url){}
-
-    virtual ~VideoReader();
-    virtual bool read(cv::Mat& mat){return true;}
-
-private:
-    VideoSrcType type;
-
-protected:
-    std::string url;
-};
-
-
-class UrlReader  : public VideoReader
-{
-public:
-    UrlReader(VideoSrcType type, const std::string& url);
-    virtual ~UrlReader();
-    bool read(cv::Mat& mat);
-private:
-    cv::VideoCapture vcap;
-};
-
-class FileReader : public VideoReader
-{
-public:
-    FileReader(VideoSrcType type, const std::string& url):VideoReader(type, url){}
-//    void read(){};
-};
-
-class UsbReader : public VideoReader
-{
-public:
-    UsbReader(VideoSrcType type, const std::string& url):VideoReader(type, url){}
-//    void read(){};
-};
-
+    typedef enum {
+        URL,
+        File,
+        USB
+    } VideoSrcType;
+
+    TK_DECLARE_PTR(VideoReaderFactory);
+    TK_DECLARE_PTR(VideoReader);
+    TK_DECLARE_PTR(URLReader);
+
+    class VideoReaderFactory
+    {
+        public:
+            static VideoReaderPtr createVideoReader(VideoSrcType type, const std::string& url);
+    };
+
+    class VideoReader
+    {
+        public:
+            VideoReader(VideoSrcType type, const std::string& url) : type(type), url(url){}
+
+            virtual ~VideoReader();
+            virtual bool read(cv::Mat& mat){return true;}
+
+        private:
+            VideoSrcType type;
+
+        protected:
+            std::string url;
+    };
+
+    class UrlReader  : public VideoReader
+    {
+        public:
+            UrlReader(VideoSrcType type, const std::string& url);
+            virtual ~UrlReader();
+            bool read(cv::Mat& mat);
+        private:
+            cv::VideoCapture vcap;
+    };
+
+    class FileReader : public VideoReader
+    {
+        public:
+            FileReader(VideoSrcType type, const std::string& url):VideoReader(type, url){}
+        //    void read(){};
+    };
+
+    class UsbReader : public VideoReader
+    {
+        public:
+            UsbReader(VideoSrcType type, const std::string& url):VideoReader(type, url){}
+        //    void read(){};
+    };
 
 }