Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Refactored videostab module. Added normalization into motion estimators.

Browse Source
pull/2/head
Alexey Spizhevoy 13 years ago
parent 258afe7cc2
commit 9d871abd32
5 changed files with 126 additions and 57 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 23
      modules/videostab/include/opencv2/videostab/global_motion.hpp
  2. 123
      modules/videostab/src/global_motion.cpp
  3. 17
      modules/videostab/src/stabilizer.cpp
  4. 2
      modules/videostab/src/wobble_suppression.cpp
  5. 18
      samples/cpp/videostab.cpp

23
modules/videostab/include/opencv2/videostab/global_motion.hpp
Unescape View File

@ -66,8 +66,7 @@ enum MotionModel
}; };
CV_EXPORTS Mat estimateGlobalMotionLeastSquares( CV_EXPORTS Mat estimateGlobalMotionLeastSquares(
const std::vector<Point2f> &points0, const std::vector<Point2f> &points1, int npoints, Point2f *points0, Point2f *points1, int model = AFFINE, float *rmse = 0);
int model = AFFINE, float *rmse = 0);
struct CV_EXPORTS RansacParams struct CV_EXPORTS RansacParams
{ {
@ -80,16 +79,24 @@ struct CV_EXPORTS RansacParams
RansacParams(int size, float thresh, float eps, float prob) RansacParams(int size, float thresh, float eps, float prob)
: size(size), thresh(thresh), eps(eps), prob(prob) {} : size(size), thresh(thresh), eps(eps), prob(prob) {}
static RansacParams translation2dMotionStd() { return RansacParams(1, 0.5f, 0.5f, 0.99f); } static RansacParams default2dMotion(MotionModel model)
static RansacParams translationAndScale2dMotionStd() { return RansacParams(2, 0.5f, 0.5f, 0.99f); } {
static RansacParams linearSimilarity2dMotionStd() { return RansacParams(2, 0.5f, 0.5f, 0.99f); } CV_Assert(model < UNKNOWN);
static RansacParams affine2dMotionStd() { return RansacParams(3, 0.5f, 0.5f, 0.99f); } if (model == TRANSLATION)
static RansacParams homography2dMotionStd() { return RansacParams(4, 0.5f, 0.5f, 0.99f); } return RansacParams(1, 0.5f, 0.5f, 0.99f);
if (model == TRANSLATION_AND_SCALE)
return RansacParams(2, 0.5f, 0.5f, 0.99f);
if (model == LINEAR_SIMILARITY)
return RansacParams(2, 0.5f, 0.5f, 0.99f);
if (model == AFFINE)
return RansacParams(3, 0.5f, 0.5f, 0.99f);
return RansacParams(4, 0.5f, 0.5f, 0.99f);
}
}; };
CV_EXPORTS Mat estimateGlobalMotionRobust( CV_EXPORTS Mat estimateGlobalMotionRobust(
const std::vector<Point2f> &points0, const std::vector<Point2f> &points1, const std::vector<Point2f> &points0, const std::vector<Point2f> &points1,
int model = AFFINE, const RansacParams &params = RansacParams::affine2dMotionStd(), int model = AFFINE, const RansacParams &params = RansacParams::default2dMotion(AFFINE),
float *rmse = 0, int *ninliers = 0); float *rmse = 0, int *ninliers = 0);
class CV_EXPORTS GlobalMotionEstimatorBase class CV_EXPORTS GlobalMotionEstimatorBase

123
modules/videostab/src/global_motion.cpp
Unescape View File

@ -51,8 +51,44 @@ namespace cv
namespace videostab namespace videostab
{ {
// does isotropic normalization
static Mat normalizePoints(int npoints, Point2f *points)
{
float cx = 0.f, cy = 0.f;
for (int i = 0; i < npoints; ++i)
{
cx += points[i].x;
cy += points[i].y;
}
cx /= npoints;
cy /= npoints;
float d = 0.f;
for (int i = 0; i < npoints; ++i)
{
points[i].x -= cx;
points[i].y -= cy;
d += sqrt(sqr(points[i].x) + sqr(points[i].y));
}
d /= npoints;
float s = sqrt(2.f) / d;
for (int i = 0; i < npoints; ++i)
{
points[i].x *= s;
points[i].y *= s;
}
Mat_<float> T = Mat::eye(3, 3, CV_32F);
T(0,0) = T(1,1) = s;
T(0,2) = -cx*s;
T(1,2) = -cy*s;
return T;
}
static Mat estimateGlobMotionLeastSquaresTranslation( static Mat estimateGlobMotionLeastSquaresTranslation(
int npoints, const Point2f *points0, const Point2f *points1, float *rmse) int npoints, Point2f *points0, Point2f *points1, float *rmse)
{ {
Mat_<float> M = Mat::eye(3, 3, CV_32F); Mat_<float> M = Mat::eye(3, 3, CV_32F);
for (int i = 0; i < npoints; ++i) for (int i = 0; i < npoints; ++i)
@ -62,6 +98,7 @@ static Mat estimateGlobMotionLeastSquaresTranslation(
} }
M(0,2) /= npoints; M(0,2) /= npoints;
M(1,2) /= npoints; M(1,2) /= npoints;
if (rmse) if (rmse)
{ {
*rmse = 0; *rmse = 0;
@ -70,13 +107,17 @@ static Mat estimateGlobMotionLeastSquaresTranslation(
sqr(points1[i].y - points0[i].y - M(1,2)); sqr(points1[i].y - points0[i].y - M(1,2));
*rmse = sqrt(*rmse / npoints); *rmse = sqrt(*rmse / npoints);
} }
return M; return M;
} }
static Mat estimateGlobMotionLeastSquaresTranslationAndScale( static Mat estimateGlobMotionLeastSquaresTranslationAndScale(
int npoints, const Point2f *points0, const Point2f *points1, float *rmse) int npoints, Point2f *points0, Point2f *points1, float *rmse)
{ {
Mat_<float> T0 = normalizePoints(npoints, points0);
Mat_<float> T1 = normalizePoints(npoints, points1);
Mat_<float> A(2*npoints, 3), b(2*npoints, 1); Mat_<float> A(2*npoints, 3), b(2*npoints, 1);
float *a0, *a1; float *a0, *a1;
Point2f p0, p1; Point2f p0, p1;
@ -103,13 +144,17 @@ static Mat estimateGlobMotionLeastSquaresTranslationAndScale(
M(0,0) = M(1,1) = sol(0,0); M(0,0) = M(1,1) = sol(0,0);
M(0,2) = sol(1,0); M(0,2) = sol(1,0);
M(1,2) = sol(2,0); M(1,2) = sol(2,0);
return M;
return T1.inv() * M * T0;
} }
static Mat estimateGlobMotionLeastSquaresLinearSimilarity( static Mat estimateGlobMotionLeastSquaresLinearSimilarity(
int npoints, const Point2f *points0, const Point2f *points1, float *rmse) int npoints, Point2f *points0, Point2f *points1, float *rmse)
{ {
Mat_<float> T0 = normalizePoints(npoints, points0);
Mat_<float> T1 = normalizePoints(npoints, points1);
Mat_<float> A(2*npoints, 4), b(2*npoints, 1); Mat_<float> A(2*npoints, 4), b(2*npoints, 1);
float *a0, *a1; float *a0, *a1;
Point2f p0, p1; Point2f p0, p1;
@ -138,13 +183,17 @@ static Mat estimateGlobMotionLeastSquaresLinearSimilarity(
M(1,0) = -sol(1,0); M(1,0) = -sol(1,0);
M(0,2) = sol(2,0); M(0,2) = sol(2,0);
M(1,2) = sol(3,0); M(1,2) = sol(3,0);
return M;
return T1.inv() * M * T0;
} }
static Mat estimateGlobMotionLeastSquaresAffine( static Mat estimateGlobMotionLeastSquaresAffine(
int npoints, const Point2f *points0, const Point2f *points1, float *rmse) int npoints, Point2f *points0, Point2f *points1, float *rmse)
{ {
Mat_<float> T0 = normalizePoints(npoints, points0);
Mat_<float> T1 = normalizePoints(npoints, points1);
Mat_<float> A(2*npoints, 6), b(2*npoints, 1); Mat_<float> A(2*npoints, 6), b(2*npoints, 1);
float *a0, *a1; float *a0, *a1;
Point2f p0, p1; Point2f p0, p1;
@ -172,24 +221,22 @@ static Mat estimateGlobMotionLeastSquaresAffine(
for (int j = 0; j < 3; ++j, ++k) for (int j = 0; j < 3; ++j, ++k)
M(i,j) = sol(k,0); M(i,j) = sol(k,0);
return M; return T1.inv() * M * T0;
} }
Mat estimateGlobalMotionLeastSquares( Mat estimateGlobalMotionLeastSquares(
const vector<Point2f> &points0, const vector<Point2f> &points1, int model, float *rmse) int npoints, Point2f *points0, Point2f *points1, int model, float *rmse)
{ {
CV_Assert(model <= AFFINE); CV_Assert(model <= AFFINE);
CV_Assert(points0.size() == points1.size());
typedef Mat (*Impl)(int, const Point2f*, const Point2f*, float*); typedef Mat (*Impl)(int, Point2f*, Point2f*, float*);
static Impl impls[] = { estimateGlobMotionLeastSquaresTranslation, static Impl impls[] = { estimateGlobMotionLeastSquaresTranslation,
estimateGlobMotionLeastSquaresTranslationAndScale, estimateGlobMotionLeastSquaresTranslationAndScale,
estimateGlobMotionLeastSquaresLinearSimilarity, estimateGlobMotionLeastSquaresLinearSimilarity,
estimateGlobMotionLeastSquaresAffine }; estimateGlobMotionLeastSquaresAffine };
int npoints = static_cast<int>(points0.size()); return impls[model](npoints, points0, points1, rmse);
return impls[model](npoints, &points0[0], &points1[0], rmse);
} }
@ -200,22 +247,22 @@ Mat estimateGlobalMotionRobust(
CV_Assert(model <= AFFINE); CV_Assert(model <= AFFINE);
CV_Assert(points0.size() == points1.size()); CV_Assert(points0.size() == points1.size());
typedef Mat (*Impl)(int, const Point2f*, const Point2f*, float*);
static Impl impls[] = { estimateGlobMotionLeastSquaresTranslation,
estimateGlobMotionLeastSquaresTranslationAndScale,
estimateGlobMotionLeastSquaresLinearSimilarity,
estimateGlobMotionLeastSquaresAffine };
const int npoints = static_cast<int>(points0.size()); const int npoints = static_cast<int>(points0.size());
const int niters = static_cast<int>(ceil(log(1 - params.prob) / const int niters = static_cast<int>(ceil(log(1 - params.prob) /
log(1 - pow(1 - params.eps, params.size)))); log(1 - pow(1 - params.eps, params.size))));
RNG rng(0); // current hypothesis
vector<int> indices(params.size); vector<int> indices(params.size);
vector<Point2f> subset0(params.size), subset1(params.size); vector<Point2f> subset0(params.size);
vector<Point2f> subset0best(params.size), subset1best(params.size); vector<Point2f> subset1(params.size);
// best hypothesis
vector<Point2f> subset0best(params.size);
vector<Point2f> subset1best(params.size);
Mat_<float> bestM; Mat_<float> bestM;
int ninliersMax = -1; int ninliersMax = -1;
RNG rng(0);
Point2f p0, p1; Point2f p0, p1;
float x, y; float x, y;
@ -239,7 +286,8 @@ Mat estimateGlobalMotionRobust(
subset1[i] = points1[indices[i]]; subset1[i] = points1[indices[i]];
} }
Mat_<float> M = impls[model](params.size, &subset0[0], &subset1[0], 0); Mat_<float> M = estimateGlobalMotionLeastSquares(
params.size, &subset0[0], &subset1[0], model, 0);
int ninliers = 0; int ninliers = 0;
for (int i = 0; i < npoints; ++i) for (int i = 0; i < npoints; ++i)
@ -260,8 +308,9 @@ Mat estimateGlobalMotionRobust(
} }
if (ninliersMax < params.size) if (ninliersMax < params.size)
// compute rmse // compute RMSE
bestM = impls[model](params.size, &subset0best[0], &subset1best[0], rmse); bestM = estimateGlobalMotionLeastSquares(
params.size, &subset0best[0], &subset1best[0], model, rmse);
else else
{ {
subset0.resize(ninliersMax); subset0.resize(ninliersMax);
@ -278,7 +327,8 @@ Mat estimateGlobalMotionRobust(
j++; j++;
} }
} }
bestM = impls[model](ninliersMax, &subset0[0], &subset1[0], rmse); bestM = estimateGlobalMotionLeastSquares(
ninliersMax, &subset0[0], &subset1[0], model, rmse);
} }
if (ninliers) if (ninliers)
@ -332,16 +382,11 @@ PyrLkRobustMotionEstimator::PyrLkRobustMotionEstimator(MotionModel model)
setDetector(new GoodFeaturesToTrackDetector()); setDetector(new GoodFeaturesToTrackDetector());
setOptFlowEstimator(new SparsePyrLkOptFlowEstimator()); setOptFlowEstimator(new SparsePyrLkOptFlowEstimator());
setMotionModel(model); setMotionModel(model);
if (model == TRANSLATION)
setRansacParams(RansacParams::translation2dMotionStd()); RansacParams ransac = RansacParams::default2dMotion(model);
else if (model == TRANSLATION_AND_SCALE) ransac.size *= 2; // we use more points than needed, but result looks better
setRansacParams(RansacParams::translationAndScale2dMotionStd()); setRansacParams(ransac);
else if (model == LINEAR_SIMILARITY)
setRansacParams(RansacParams::linearSimilarity2dMotionStd());
else if (model == AFFINE)
setRansacParams(RansacParams::affine2dMotionStd());
else if (model == HOMOGRAPHY)
setRansacParams(RansacParams::homography2dMotionStd());
setMaxRmse(0.5f); setMaxRmse(0.5f);
setMinInlierRatio(0.1f); setMinInlierRatio(0.1f);
setGridSize(Size(0,0)); setGridSize(Size(0,0));
@ -362,6 +407,7 @@ Mat PyrLkRobustMotionEstimator::estimate(const Mat &frame0, const Mat &frame1, b
keypointsPrev_.push_back(KeyPoint((x+1)*dx, (y+1)*dy, 0.f)); keypointsPrev_.push_back(KeyPoint((x+1)*dx, (y+1)*dy, 0.f));
} }
// draw keypoints
/*Mat img; /*Mat img;
drawKeypoints(frame0, keypointsPrev_, img); drawKeypoints(frame0, keypointsPrev_, img);
imshow("frame0_keypoints", img); imshow("frame0_keypoints", img);
@ -374,10 +420,9 @@ Mat PyrLkRobustMotionEstimator::estimate(const Mat &frame0, const Mat &frame1, b
optFlowEstimator_->run(frame0, frame1, pointsPrev_, points_, status_, noArray()); optFlowEstimator_->run(frame0, frame1, pointsPrev_, points_, status_, noArray());
size_t npoints = points_.size(); size_t npoints = points_.size();
pointsPrevGood_.clear(); pointsPrevGood_.clear(); pointsPrevGood_.reserve(npoints);
pointsPrevGood_.reserve(npoints); pointsGood_.clear(); pointsGood_.reserve(npoints);
pointsGood_.clear();
pointsGood_.reserve(npoints);
for (size_t i = 0; i < npoints; ++i) for (size_t i = 0; i < npoints; ++i)
{ {
if (status_[i]) if (status_[i])

17
modules/videostab/src/stabilizer.cpp
Unescape View File

@ -338,16 +338,18 @@ void TwoPassStabilizer::runPrePassIfNecessary()
WobbleSuppressorBase *wobbleSuppressor = static_cast<WobbleSuppressorBase*>(wobbleSuppressor_); WobbleSuppressorBase *wobbleSuppressor = static_cast<WobbleSuppressorBase*>(wobbleSuppressor_);
doWobbleSuppression_ = dynamic_cast<NullWobbleSuppressor*>(wobbleSuppressor) == 0; doWobbleSuppression_ = dynamic_cast<NullWobbleSuppressor*>(wobbleSuppressor) == 0;
bool okEst; bool ok = true, ok2 = true;
while (!(frame = frameSource_->nextFrame()).empty()) while (!(frame = frameSource_->nextFrame()).empty())
{ {
if (frameCount_ > 0) if (frameCount_ > 0)
{ {
motions_.push_back(motionEstimator_->estimate(prevFrame, frame)); motions_.push_back(motionEstimator_->estimate(prevFrame, frame, &ok));
if (doWobbleSuppression_) if (doWobbleSuppression_)
{ {
Mat M = wobbleSuppressor_->motionEstimator()->estimate(prevFrame, frame, &okEst); Mat M = wobbleSuppressor_->motionEstimator()->estimate(prevFrame, frame, &ok2);
if (okEst) if (ok2)
motions2_.push_back(M); motions2_.push_back(M);
else else
motions2_.push_back(motions_.back()); motions2_.push_back(motions_.back());
@ -363,7 +365,12 @@ void TwoPassStabilizer::runPrePassIfNecessary()
prevFrame = frame; prevFrame = frame;
frameCount_++; frameCount_++;
log_->print("."); if (ok)
{
if (ok2) log_->print(".");
else log_->print("?");
}
else log_->print("x");
} }
for (int i = 0; i < radius_; ++i) for (int i = 0; i < radius_; ++i)

2
modules/videostab/src/wobble_suppression.cpp
Unescape View File

@ -55,7 +55,7 @@ WobbleSuppressorBase::WobbleSuppressorBase() : motions_(0), stabilizationMotions
{ {
PyrLkRobustMotionEstimator *est = new PyrLkRobustMotionEstimator(); PyrLkRobustMotionEstimator *est = new PyrLkRobustMotionEstimator();
est->setMotionModel(HOMOGRAPHY); est->setMotionModel(HOMOGRAPHY);
est->setRansacParams(RansacParams::homography2dMotionStd()); est->setRansacParams(RansacParams::default2dMotion(HOMOGRAPHY));
setMotionEstimator(est); setMotionEstimator(est);
} }

18
samples/cpp/videostab.cpp
Unescape View File

@ -67,6 +67,8 @@ void printHelp()
"Arguments:\n" "Arguments:\n"
" -m, --model=(transl|transl_and_scale|linear_sim|affine|homography)\n" " -m, --model=(transl|transl_and_scale|linear_sim|affine|homography)\n"
" Set motion model. The default is affine.\n" " Set motion model. The default is affine.\n"
" --subset=(<int_number>|auto)\n"
" Number of random samples per one motion hypothesis. The default is auto.\n"
" --outlier-ratio=<float_number>\n" " --outlier-ratio=<float_number>\n"
" Motion estimation outlier ratio hypothesis. The default is 0.5.\n" " Motion estimation outlier ratio hypothesis. The default is 0.5.\n"
" --min-inlier-ratio=<float_number>\n" " --min-inlier-ratio=<float_number>\n"
@ -116,10 +118,12 @@ void printHelp()
" --ws-model=(transl|transl_and_scale|linear_sim|affine|homography)\n" " --ws-model=(transl|transl_and_scale|linear_sim|affine|homography)\n"
" Set wobble suppression motion model (must have more DOF than motion \n" " Set wobble suppression motion model (must have more DOF than motion \n"
" estimation model). The default is homography.\n" " estimation model). The default is homography.\n"
" --ws-min-inlier-ratio=<float_number>\n" " --ws-subset=(<int_number>|auto)\n"
" Minimum inlier ratio to decide if estimated motion is OK. The default is 0.1.\n" " Number of random samples per one motion hypothesis. The default is auto.\n"
" --ws-outlier-ratio=<float_number>\n" " --ws-outlier-ratio=<float_number>\n"
" Motion estimation outlier ratio hypothesis. The default is 0.5.\n" " Motion estimation outlier ratio hypothesis. The default is 0.5.\n"
" --ws-min-inlier-ratio=<float_number>\n"
" Minimum inlier ratio to decide if estimated motion is OK. The default is 0.1.\n"
" --ws-nkps=<int_number>\n" " --ws-nkps=<int_number>\n"
" Number of keypoints to find in each frame. The default is 1000.\n" " Number of keypoints to find in each frame. The default is 1000.\n"
" --ws-extra-kps=<int_number>\n" " --ws-extra-kps=<int_number>\n"
@ -147,8 +151,9 @@ int main(int argc, const char **argv)
const char *keys = const char *keys =
"{ 1 | | | | }" "{ 1 | | | | }"
"{ m | model | affine| }" "{ m | model | affine| }"
"{ | min-inlier-ratio | 0.1 | }" "{ | subset | auto | }"
"{ | outlier-ratio | 0.5 | }" "{ | outlier-ratio | 0.5 | }"
"{ | min-inlier-ratio | 0.1 | }"
"{ | nkps | 1000 | }" "{ | nkps | 1000 | }"
"{ | extra-kps | 0 | }" "{ | extra-kps | 0 | }"
"{ sm | save-motions | no | }" "{ sm | save-motions | no | }"
@ -170,8 +175,9 @@ int main(int argc, const char **argv)
"{ ws | wobble-suppress | no | }" "{ ws | wobble-suppress | no | }"
"{ | ws-period | 30 | }" "{ | ws-period | 30 | }"
"{ | ws-model | homography | }" "{ | ws-model | homography | }"
"{ | ws-min-inlier-ratio | 0.1 | }" "{ | ws-subset | auto | }"
"{ | ws-outlier-ratio | 0.5 | }" "{ | ws-outlier-ratio | 0.5 | }"
"{ | ws-min-inlier-ratio | 0.1 | }"
"{ | ws-nkps | 1000 | }" "{ | ws-nkps | 1000 | }"
"{ | ws-extra-kps | 0 | }" "{ | ws-extra-kps | 0 | }"
"{ sm2 | save-motions2 | no | }" "{ sm2 | save-motions2 | no | }"
@ -230,6 +236,8 @@ int main(int argc, const char **argv)
est->setDetector(new GoodFeaturesToTrackDetector(argi("ws-nkps"))); est->setDetector(new GoodFeaturesToTrackDetector(argi("ws-nkps")));
RansacParams ransac = est->ransacParams(); RansacParams ransac = est->ransacParams();
if (arg("ws-subset") != "auto")
ransac.size = argi("ws-subset");
ransac.eps = argf("ws-outlier-ratio"); ransac.eps = argf("ws-outlier-ratio");
est->setRansacParams(ransac); est->setRansacParams(ransac);
est->setMinInlierRatio(argf("ws-min-inlier-ratio")); est->setMinInlierRatio(argf("ws-min-inlier-ratio"));
@ -288,6 +296,8 @@ int main(int argc, const char **argv)
est->setDetector(new GoodFeaturesToTrackDetector(argi("nkps"))); est->setDetector(new GoodFeaturesToTrackDetector(argi("nkps")));
RansacParams ransac = est->ransacParams(); RansacParams ransac = est->ransacParams();
if (arg("subset") != "auto")
ransac.size = argi("subset");
ransac.eps = argf("outlier-ratio"); ransac.eps = argf("outlier-ratio");
est->setRansacParams(ransac); est->setRansacParams(ransac);
est->setMinInlierRatio(argf("min-inlier-ratio")); est->setMinInlierRatio(argf("min-inlier-ratio"));

Write Preview
Loading…
Cancel
Save