mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
369 lines
14 KiB
369 lines
14 KiB
#include <string> |
|
#include <iostream> |
|
#include <fstream> |
|
#include <sstream> |
|
#include <stdexcept> |
|
#include "opencv2/core/core.hpp" |
|
#include "opencv2/video/video.hpp" |
|
#include "opencv2/imgproc/imgproc.hpp" |
|
#include "opencv2/highgui/highgui.hpp" |
|
#include "opencv2/videostab/videostab.hpp" |
|
|
|
using namespace std; |
|
using namespace cv; |
|
using namespace cv::videostab; |
|
|
|
|
|
Ptr<IFrameSource> stabilizedFrames; |
|
string saveMotionsPath; |
|
double outputFps; |
|
string outputPath; |
|
bool quietMode; |
|
|
|
void run(); |
|
void saveMotionsIfNecessary(); |
|
void printHelp(); |
|
|
|
class GlobalMotionReader : public IGlobalMotionEstimator |
|
{ |
|
public: |
|
GlobalMotionReader(string path) |
|
{ |
|
ifstream f(path.c_str()); |
|
if (!f.is_open()) |
|
throw runtime_error("can't open motions file: " + path); |
|
int size; f >> size; |
|
motions_.resize(size); |
|
for (int i = 0; i < size; ++i) |
|
{ |
|
Mat_<float> M(3, 3); |
|
for (int l = 0; l < 3; ++l) |
|
for (int s = 0; s < 3; ++s) |
|
f >> M(l,s); |
|
motions_[i] = M; |
|
} |
|
pos_ = 0; |
|
} |
|
|
|
virtual Mat estimate(const Mat &/*frame0*/, const Mat &/*frame1*/) |
|
{ |
|
if (pos_ >= motions_.size()) |
|
{ |
|
stringstream text; |
|
text << "can't load motion between frames " << pos_ << " and " << pos_+1; |
|
throw runtime_error(text.str()); |
|
} |
|
return motions_[pos_++]; |
|
} |
|
|
|
private: |
|
vector<Mat> motions_; |
|
size_t pos_; |
|
}; |
|
|
|
void run() |
|
{ |
|
VideoWriter writer; |
|
Mat stabilizedFrame; |
|
|
|
while (!(stabilizedFrame = stabilizedFrames->nextFrame()).empty()) |
|
{ |
|
if (!saveMotionsPath.empty()) |
|
saveMotionsIfNecessary(); |
|
if (!outputPath.empty()) |
|
{ |
|
if (!writer.isOpened()) |
|
writer.open(outputPath, CV_FOURCC('X','V','I','D'), outputFps, stabilizedFrame.size()); |
|
writer << stabilizedFrame; |
|
} |
|
if (!quietMode) |
|
{ |
|
imshow("stabilizedFrame", stabilizedFrame); |
|
char key = static_cast<char>(waitKey(3)); |
|
if (key == 27) |
|
break; |
|
} |
|
} |
|
|
|
cout << "\nfinished\n"; |
|
} |
|
|
|
|
|
void saveMotionsIfNecessary() |
|
{ |
|
static bool areMotionsSaved = false; |
|
if (!areMotionsSaved) |
|
{ |
|
IFrameSource *frameSource = static_cast<IFrameSource*>(stabilizedFrames); |
|
TwoPassStabilizer *twoPassStabilizer = dynamic_cast<TwoPassStabilizer*>(frameSource); |
|
if (twoPassStabilizer) |
|
{ |
|
ofstream f(saveMotionsPath.c_str()); |
|
const vector<Mat> &motions = twoPassStabilizer->motions(); |
|
f << motions.size() << endl; |
|
for (size_t i = 0; i < motions.size(); ++i) |
|
{ |
|
Mat_<float> M = motions[i]; |
|
for (int l = 0, k = 0; l < 3; ++l) |
|
for (int s = 0; s < 3; ++s, ++k) |
|
f << M(l,s) << " "; |
|
f << endl; |
|
} |
|
} |
|
areMotionsSaved = true; |
|
cout << "motions are saved"; |
|
} |
|
} |
|
|
|
|
|
void printHelp() |
|
{ |
|
cout << "OpenCV video stabilizer.\n" |
|
"Usage: videostab <file_path> [arguments]\n\n" |
|
"Arguments:\n" |
|
" -m, --model=(transl|transl_and_scale|linear_sim|affine)\n" |
|
" Set motion model. The default is affine.\n" |
|
" --outlier-ratio=<float_number>\n" |
|
" Outliers ratio in motion estimation. The default is 0.5.\n" |
|
" --min-inlier-ratio=<float_number>\n" |
|
" Minimum inlier ratio to decide if estimated motion is OK. The default is 0.1,\n" |
|
" but you may want to increase it.\n\n" |
|
" --save-motions=<file_path>\n" |
|
" Save estimated motions into file.\n" |
|
" --load-motions=<file_path>\n" |
|
" Load motions from file.\n\n" |
|
" -r, --radius=<int_number>\n" |
|
" Set smoothing radius. The default is 15.\n" |
|
" --stdev=<float_number>\n" |
|
" Set smoothing weights standard deviation. The default is sqrt(radius).\n\n" |
|
" --deblur=(yes|no)\n" |
|
" Do deblurring.\n" |
|
" --deblur-sens=<float_number>\n" |
|
" Set deblurring sensitivity (from 0 to +inf). The default is 0.1.\n\n" |
|
" -t, --trim-ratio=<float_number>\n" |
|
" Set trimming ratio (from 0 to 0.5). The default is 0.0.\n" |
|
" --est-trim=(yes|no)\n" |
|
" Estimate trim ratio automatically. The default is yes (that leads to two passes,\n" |
|
" you can turn it off if you want to use one pass only).\n" |
|
" --incl-constr=(yes|no)\n" |
|
" Ensure the inclusion constraint is always satisfied. The default is no.\n\n" |
|
" --border-mode=(replicate|reflect|const)\n" |
|
" Set border extrapolation mode. The default is replicate.\n\n" |
|
" --mosaic=(yes|no)\n" |
|
" Do consistent mosaicing. The default is no.\n" |
|
" --mosaic-stdev=<float_number>\n" |
|
" Consistent mosaicing stdev threshold. The default is 10.0.\n\n" |
|
" --motion-inpaint=(yes|no)\n" |
|
" Do motion inpainting (requires GPU support). The default is no.\n" |
|
" --dist-thresh=<float_number>\n" |
|
" Estimated flow distance threshold for motion inpainting. The default is 5.0.\n\n" |
|
" --color-inpaint=(no|average|ns|telea)\n" |
|
" Do color inpainting. The defailt is no.\n" |
|
" --color-inpaint-radius=<float_number>\n" |
|
" Set color inpainting radius (for ns and telea options only).\n\n" |
|
" -o, --output=(no|<file_path>)\n" |
|
" Set output file path explicitely. The default is stabilized.avi.\n" |
|
" --fps=<int_number>\n" |
|
" Set output video FPS explicitely. By default the source FPS is used.\n" |
|
" -q, --quiet\n" |
|
" Don't show output video frames.\n\n" |
|
" -h, --help\n" |
|
" Print help.\n" |
|
"\n"; |
|
} |
|
|
|
|
|
int main(int argc, const char **argv) |
|
{ |
|
try |
|
{ |
|
const char *keys = |
|
"{ 1 | | | | }" |
|
"{ m | model | | }" |
|
"{ | min-inlier-ratio | | }" |
|
"{ | outlier-ratio | | }" |
|
"{ | save-motions | | }" |
|
"{ | load-motions | | }" |
|
"{ r | radius | | }" |
|
"{ | stdev | | }" |
|
"{ | deblur | | }" |
|
"{ | deblur-sens | | }" |
|
"{ | est-trim | yes | }" |
|
"{ t | trim-ratio | | }" |
|
"{ | incl-constr | | }" |
|
"{ | border-mode | | }" |
|
"{ | mosaic | | }" |
|
"{ | mosaic-stdev | | }" |
|
"{ | motion-inpaint | | }" |
|
"{ | dist-thresh | | }" |
|
"{ | color-inpaint | no | }" |
|
"{ | color-inpaint-radius | | }" |
|
"{ o | output | stabilized.avi | }" |
|
"{ | fps | | }" |
|
"{ q | quiet | false | }" |
|
"{ h | help | false | }"; |
|
CommandLineParser cmd(argc, argv, keys); |
|
|
|
// parse command arguments |
|
|
|
if (cmd.get<bool>("help")) |
|
{ |
|
printHelp(); |
|
return 0; |
|
} |
|
|
|
StabilizerBase *stabilizer; |
|
GaussianMotionFilter *motionFilter = 0; |
|
|
|
if (!cmd.get<string>("stdev").empty()) |
|
{ |
|
motionFilter = new GaussianMotionFilter(); |
|
motionFilter->setStdev(cmd.get<float>("stdev")); |
|
} |
|
|
|
if (!cmd.get<string>("save-motions").empty()) |
|
saveMotionsPath = cmd.get<string>("save-motions"); |
|
|
|
bool isTwoPass = |
|
cmd.get<string>("est-trim") == "yes" || |
|
!cmd.get<string>("save-motions").empty(); |
|
|
|
if (isTwoPass) |
|
{ |
|
TwoPassStabilizer *twoPassStabilizer = new TwoPassStabilizer(); |
|
if (!cmd.get<string>("est-trim").empty()) |
|
twoPassStabilizer->setEstimateTrimRatio(cmd.get<string>("est-trim") == "yes"); |
|
if (motionFilter) |
|
twoPassStabilizer->setMotionStabilizer(motionFilter); |
|
stabilizer = twoPassStabilizer; |
|
} |
|
else |
|
{ |
|
OnePassStabilizer *onePassStabilizer= new OnePassStabilizer(); |
|
if (motionFilter) |
|
onePassStabilizer->setMotionFilter(motionFilter); |
|
stabilizer = onePassStabilizer; |
|
} |
|
|
|
string inputPath = cmd.get<string>("1"); |
|
if (inputPath.empty()) |
|
throw runtime_error("specify video file path"); |
|
|
|
VideoFileSource *frameSource = new VideoFileSource(inputPath); |
|
outputFps = frameSource->fps(); |
|
stabilizer->setFrameSource(frameSource); |
|
cout << "frame count: " << frameSource->frameCount() << endl; |
|
|
|
PyrLkRobustMotionEstimator *motionEstimator = new PyrLkRobustMotionEstimator(); |
|
if (cmd.get<string>("model") == "transl") |
|
motionEstimator->setMotionModel(TRANSLATION); |
|
else if (cmd.get<string>("model") == "transl_and_scale") |
|
motionEstimator->setMotionModel(TRANSLATION_AND_SCALE); |
|
else if (cmd.get<string>("model") == "linear_sim") |
|
motionEstimator->setMotionModel(LINEAR_SIMILARITY); |
|
else if (cmd.get<string>("model") == "affine") |
|
motionEstimator->setMotionModel(AFFINE); |
|
else if (!cmd.get<string>("model").empty()) |
|
throw runtime_error("unknow motion mode: " + cmd.get<string>("model")); |
|
if (!cmd.get<string>("outlier-ratio").empty()) |
|
{ |
|
RansacParams ransacParams = motionEstimator->ransacParams(); |
|
ransacParams.eps = cmd.get<float>("outlier-ratio"); |
|
motionEstimator->setRansacParams(ransacParams); |
|
} |
|
if (!cmd.get<string>("min-inlier-ratio").empty()) |
|
motionEstimator->setMinInlierRatio(cmd.get<float>("min-inlier-ratio")); |
|
stabilizer->setMotionEstimator(motionEstimator); |
|
if (!cmd.get<string>("load-motions").empty()) |
|
stabilizer->setMotionEstimator(new GlobalMotionReader(cmd.get<string>("load-motions"))); |
|
|
|
if (!cmd.get<string>("radius").empty()) |
|
stabilizer->setRadius(cmd.get<int>("radius")); |
|
|
|
if (cmd.get<string>("deblur") == "yes") |
|
{ |
|
WeightingDeblurer *deblurer = new WeightingDeblurer(); |
|
if (!cmd.get<string>("deblur-sens").empty()) |
|
deblurer->setSensitivity(cmd.get<float>("deblur-sens")); |
|
stabilizer->setDeblurer(deblurer); |
|
} |
|
|
|
if (!cmd.get<string>("trim-ratio").empty()) |
|
stabilizer->setTrimRatio(cmd.get<float>("trim-ratio")); |
|
|
|
if (!cmd.get<string>("incl-constr").empty()) |
|
stabilizer->setCorrectionForInclusion(cmd.get<string>("incl-constr") == "yes"); |
|
|
|
if (cmd.get<string>("border-mode") == "reflect") |
|
stabilizer->setBorderMode(BORDER_REFLECT); |
|
else if (cmd.get<string>("border-mode") == "replicate") |
|
stabilizer->setBorderMode(BORDER_REPLICATE); |
|
else if (cmd.get<string>("border-mode") == "const") |
|
stabilizer->setBorderMode(BORDER_CONSTANT); |
|
else if (!cmd.get<string>("border-mode").empty()) |
|
throw runtime_error("unknown border extrapolation mode: " + cmd.get<string>("border-mode")); |
|
|
|
InpaintingPipeline *inpainters = new InpaintingPipeline(); |
|
if (cmd.get<string>("mosaic") == "yes") |
|
{ |
|
ConsistentMosaicInpainter *inpainter = new ConsistentMosaicInpainter(); |
|
if (!cmd.get<string>("mosaic-stdev").empty()) |
|
inpainter->setStdevThresh(cmd.get<float>("mosaic-stdev")); |
|
inpainters->pushBack(inpainter); |
|
} |
|
if (cmd.get<string>("motion-inpaint") == "yes") |
|
{ |
|
MotionInpainter *inpainter = new MotionInpainter(); |
|
if (!cmd.get<string>("dist-thresh").empty()) |
|
inpainter->setDistThreshold(cmd.get<float>("dist-thresh")); |
|
inpainters->pushBack(inpainter); |
|
} |
|
if (!cmd.get<string>("color-inpaint").empty()) |
|
{ |
|
if (cmd.get<string>("color-inpaint") == "average") |
|
inpainters->pushBack(new ColorAverageInpainter()); |
|
else if (!cmd.get<string>("color-inpaint-radius").empty()) |
|
{ |
|
float radius = cmd.get<float>("color-inpaint-radius"); |
|
if (cmd.get<string>("color-inpaint") == "ns") |
|
inpainters->pushBack(new ColorInpainter(INPAINT_NS, radius)); |
|
else if (cmd.get<string>("color-inpaint") == "telea") |
|
inpainters->pushBack(new ColorInpainter(INPAINT_TELEA, radius)); |
|
else if (cmd.get<string>("color-inpaint") != "no") |
|
throw runtime_error("unknown color inpainting method: " + cmd.get<string>("color-inpaint")); |
|
} |
|
else |
|
{ |
|
if (cmd.get<string>("color-inpaint") == "ns") |
|
inpainters->pushBack(new ColorInpainter(INPAINT_NS)); |
|
else if (cmd.get<string>("color-inpaint") == "telea") |
|
inpainters->pushBack(new ColorInpainter(INPAINT_TELEA)); |
|
else if (cmd.get<string>("color-inpaint") != "no") |
|
throw runtime_error("unknown color inpainting method: " + cmd.get<string>("color-inpaint")); |
|
} |
|
} |
|
if (!inpainters->empty()) |
|
stabilizer->setInpainter(inpainters); |
|
|
|
stabilizer->setLog(new LogToStdout()); |
|
|
|
outputPath = cmd.get<string>("output") != "no" ? cmd.get<string>("output") : ""; |
|
|
|
if (!cmd.get<string>("fps").empty()) |
|
outputFps = cmd.get<double>("fps"); |
|
|
|
quietMode = cmd.get<bool>("quiet"); |
|
|
|
stabilizedFrames = dynamic_cast<IFrameSource*>(stabilizer); |
|
|
|
run(); |
|
} |
|
catch (const exception &e) |
|
{ |
|
cout << "error: " << e.what() << endl; |
|
stabilizedFrames.release(); |
|
return -1; |
|
} |
|
stabilizedFrames.release(); |
|
return 0; |
|
}
|
|
|