Moved to Visual Studio 2015, OpenCV 3.2.0, x64

include/opencv2/videostab/motion_stabilizing.hpp

@@ -40,66 +40,134 @@
 //
 //M*/
 
-#ifndef __OPENCV_VIDEOSTAB_MOTION_STABILIZING_HPP__
-#define __OPENCV_VIDEOSTAB_MOTION_STABILIZING_HPP__
+#ifndef OPENCV_VIDEOSTAB_MOTION_STABILIZING_HPP
+#define OPENCV_VIDEOSTAB_MOTION_STABILIZING_HPP
 
 #include <vector>
-#include "opencv2/core/core.hpp"
+#include <utility>
+#include "opencv2/core.hpp"
+#include "opencv2/videostab/global_motion.hpp"
 
 namespace cv
 {
 namespace videostab
 {
 
+//! @addtogroup videostab_motion
+//! @{
+
 class CV_EXPORTS IMotionStabilizer
 {
 public:
-    virtual void stabilize(const Mat *motions, int size, Mat *stabilizationMotions) const = 0;
-
-#ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY
     virtual ~IMotionStabilizer() {}
-#endif
+
+    //! assumes that [0, size-1) is in or equals to [range.first, range.second)
+    virtual void stabilize(
+            int size, const std::vector<Mat> &motions, std::pair<int,int> range,
+            Mat *stabilizationMotions) = 0;
+};
+
+class CV_EXPORTS MotionStabilizationPipeline : public IMotionStabilizer
+{
+public:
+    void pushBack(Ptr<IMotionStabilizer> stabilizer) { stabilizers_.push_back(stabilizer); }
+    bool empty() const { return stabilizers_.empty(); }
+
+    virtual void stabilize(
+            int size, const std::vector<Mat> &motions, std::pair<int,int> range,
+            Mat *stabilizationMotions);
+
+private:
+    std::vector<Ptr<IMotionStabilizer> > stabilizers_;
 };
 
 class CV_EXPORTS MotionFilterBase : public IMotionStabilizer
 {
 public:
-    MotionFilterBase() : radius_(0) {}
     virtual ~MotionFilterBase() {}
 
-    virtual void setRadius(int val) { radius_ = val; }
-    virtual int radius() const { return radius_; }
+    virtual Mat stabilize(
+            int idx, const std::vector<Mat> &motions, std::pair<int,int> range) = 0;
 
-    virtual void update() {}
-
-    virtual Mat stabilize(int index, const Mat *motions, int size) const = 0;
-    virtual void stabilize(const Mat *motions, int size, Mat *stabilizationMotions) const;
-
-protected:
-    int radius_;
+    virtual void stabilize(
+            int size, const std::vector<Mat> &motions, std::pair<int,int> range,
+            Mat *stabilizationMotions);
 };
 
 class CV_EXPORTS GaussianMotionFilter : public MotionFilterBase
 {
 public:
-    GaussianMotionFilter() : stdev_(-1.f) {}
+    GaussianMotionFilter(int radius = 15, float stdev = -1.f);
 
-    void setStdev(float val) { stdev_ = val; }
+    void setParams(int radius, float stdev = -1.f);
+    int radius() const { return radius_; }
     float stdev() const { return stdev_; }
 
-    virtual void update();
-
-    virtual Mat stabilize(int index, const Mat *motions, int size) const;
+    virtual Mat stabilize(
+            int idx, const std::vector<Mat> &motions, std::pair<int,int> range);
 
 private:
+    int radius_;
     float stdev_;
     std::vector<float> weight_;
 };
 
+inline GaussianMotionFilter::GaussianMotionFilter(int _radius, float _stdev) { setParams(_radius, _stdev); }
+
+class CV_EXPORTS LpMotionStabilizer : public IMotionStabilizer
+{
+public:
+    LpMotionStabilizer(MotionModel model = MM_SIMILARITY);
+
+    void setMotionModel(MotionModel val) { model_ = val; }
+    MotionModel motionModel() const { return model_; }
+
+    void setFrameSize(Size val) { frameSize_ = val; }
+    Size frameSize() const { return frameSize_; }
+
+    void setTrimRatio(float val) { trimRatio_ = val; }
+    float trimRatio() const { return trimRatio_; }
+
+    void setWeight1(float val) { w1_ = val; }
+    float weight1() const { return w1_; }
+
+    void setWeight2(float val) { w2_ = val; }
+    float weight2() const { return w2_; }
+
+    void setWeight3(float val) { w3_ = val; }
+    float weight3() const { return w3_; }
+
+    void setWeight4(float val) { w4_ = val; }
+    float weight4() const { return w4_; }
+
+    virtual void stabilize(
+            int size, const std::vector<Mat> &motions, std::pair<int,int> range,
+            Mat *stabilizationMotions);
+
+private:
+    MotionModel model_;
+    Size frameSize_;
+    float trimRatio_;
+    float w1_, w2_, w3_, w4_;
+
+    std::vector<double> obj_, collb_, colub_;
+    std::vector<int> rows_, cols_;
+    std::vector<double> elems_, rowlb_, rowub_;
+
+    void set(int row, int col, double coef)
+    {
+        rows_.push_back(row);
+        cols_.push_back(col);
+        elems_.push_back(coef);
+    }
+};
+
 CV_EXPORTS Mat ensureInclusionConstraint(const Mat &M, Size size, float trimRatio);
 
 CV_EXPORTS float estimateOptimalTrimRatio(const Mat &M, Size size);
 
+//! @}
+
 } // namespace videostab
 } // namespace