SkeletonTracker class cleanup
authorAlyssa Rosenzweig <bobbybee@users.noreply.github.com>
Sun, 28 Jun 2015 15:43:56 +0000 (11:43 -0400)
committerAlyssa Rosenzweig <bobbybee@users.noreply.github.com>
Sun, 28 Jun 2015 15:43:56 +0000 (11:43 -0400)
examples/demo.cpp
src/CommodityTracking.cpp
src/CommodityTracking.h

index 69c0221..ab5e172 100644 (file)
@@ -7,23 +7,13 @@ using namespace cv;
 using namespace ct;
 
 int main(int argc, char** argv) {
-    // initialize camera stream from the built-in webcam
-    // and initialize FrameHistory with that stream
-
-    VideoCapture stream(0);
-    FrameHistory history(stream);
-
-    int minimumArclength = 100;
-    int userSensitivity = (argc == 1) ? 260 : atoi(argv[1]); 
-
-    vector<Skeleton*> oldSkeletons;
+    SkeletonTracker tracker;
 
     for(;;) {
-        vector<Skeleton*> skeletons = getSkeleton(oldSkeletons, stream, history, userSensitivity, minimumArclength, 0.5, true);
-        oldSkeletons = skeletons;
+        vector<Skeleton*> skeletons = tracker.getSkeletons();
 
         // visualize skeletons
-        Mat visualization = history.getLastFrame().clone();
+        Mat visualization = tracker.cloneFrame(); 
         //Mat visualization = Mat::zeros(history.getLastFrame().size(), CV_8UC3);
 
         int visWidth = visualization.cols, visHeight = visualization.rows;
index 045e2a7..deaea73 100644 (file)
@@ -4,6 +4,26 @@
 using namespace cv;
 
 namespace ct {
+    SkeletonTracker::SkeletonTracker() :
+                                        m_stream(new VideoCapture(0)),
+                                        m_history(new FrameHistory(*m_stream)),
+                                        m_minimumArclength(100),
+                                        m_userSensitivity(260)
+    {
+    
+    }
+
+    vector<Skeleton*> SkeletonTracker::getSkeletons() {
+         vector<Skeleton*> skeletons = getSkeleton(m_oldSkeletons, *m_stream, *m_history, m_userSensitivity, m_minimumArclength, 0.5, true);
+         m_oldSkeletons = skeletons;
+
+         return skeletons;
+    }
+
+    Mat SkeletonTracker::cloneFrame() {
+        return m_history->getLastFrame().clone();
+    }
+
     void Skeleton::smoothLimb(cv::Point2d* oldLimb, cv::Point2d* newLimb, int thresh) {
         if( (newLimb->x == 0 && oldLimb->x != 0) || (newLimb->y == 0 && oldLimb->y != 0)) {
             newLimb->x = oldLimb->x;
index ffd15b4..6db57da 100644 (file)
@@ -156,7 +156,7 @@ namespace ct {
         int m_magWidth, m_magHeight;
 
     };
-
+    
     /**
     * extractUserMask computes a mask of the user given a generic motion mask.
     * Delta is a motion mask, as returned by FrameHistory::motion .
@@ -248,6 +248,51 @@ namespace ct {
         double scaleFactor, // (fractional) value for scaling the image (optimization)
         bool shouldFlip // flip webcam image?
     );
+
+    /**
+     * SkeletonTracker provides a very high-level interface to the underlying skeleton tracking algorithm
+     * It abstracts away all of the API calls needed to get a Skeleton object from CommodityTracking.
+     * For applications that are only concerned with high-level details of the skeleton as opposed to the underlying computer vision,
+     * the SkeletonTracking class is ideal and useful
+     */
+
+    class SkeletonTracker {
+        public:
+            /**
+             * This constructor should be used if there is no particular need for a more complex configuration.
+             * This uses the first video camera found, and the default values of the internal constants.
+             * It should be sufficient for many uses; if not, feel free to file an issue on Github.
+             */
+
+            SkeletonTracker();
+    
+            /**
+             * getSkeletons contains the main code for intefacing with CommodityTracking.
+             * getSkeletons provides a high-level function call that does exactly what it seems like:
+             * returns the skeletons, and nothing else.
+             * Internally, this function corresponds to a getSkeleton call with some extra maintenance performed,
+             * as getSkeleton is stateless and SkeletonTracker is not.
+             */
+
+            std::vector<ct::Skeleton*> getSkeletons();
+        
+            /**
+             * cloneFrame gets the last frame from the webcam, and clones it to allow the caller to safely write to the frame
+             * This is mainly useful for visualizations of the skeleton tracking process,
+             * as it allows a demo to draw over a user, for instance.
+             */
+
+            cv::Mat cloneFrame();
+        private:
+            std::vector<ct::Skeleton*> m_oldSkeletons;
+            
+            cv::VideoCapture* m_stream;
+            ct::FrameHistory* m_history;
+
+            int m_userSensitivity;
+            int m_minimumArclength;
+    };
 }
 
+
 #endif
This page took 0.030222 seconds and 4 git commands to generate.