Merge pull request #68 from tpietruszka/deepflow
Deepflow implementation (and optical flow testing again)pull/72/head
Vadim Pisarevsky
11 years ago
commit
12e1e11d69
8 changed files with 1679 additions and 3 deletions
@ -0,0 +1,36 @@ |
||||
Optical flow input / output |
||||
============================ |
||||
|
||||
Functions reading and writing .flo files in "Middlebury" format, see: [MiddleburyFlo]_ |
||||
|
||||
readOpticalFlow |
||||
----------------- |
||||
Read a .flo file |
||||
|
||||
.. ocv:function:: Mat readOpticalFlow( const String& path ) |
||||
|
||||
:param path: Path to the file to be loaded |
||||
|
||||
The function readOpticalFlow loads a flow field from a file and returns it as a single matrix. |
||||
Resulting ``Mat`` has a type ``CV_32FC2`` - floating-point, 2-channel. |
||||
First channel corresponds to the flow in the horizontal direction (u), second - vertical (v). |
||||
|
||||
writeOpticalFlow |
||||
----------------- |
||||
Write a .flo to disk |
||||
|
||||
.. ocv:function:: bool writeOpticalFlow( const String& path, InputArray flow ) |
||||
|
||||
:param path: Path to the file to be written |
||||
|
||||
:param flow: Flow field to be stored |
||||
|
||||
The function stores a flow field in a file, returns ``true`` on success, ``false`` otherwise. |
||||
|
||||
The flow field must be a 2-channel, floating-point matrix (``CV_32FC2``). |
||||
First channel corresponds to the flow in the horizontal direction (u), second - vertical (v). |
||||
|
||||
|
||||
.. [MiddleburyFlo] http://vision.middlebury.edu/flow/code/flow-code/README.txt |
||||
|
||||
|
||||
@ -0,0 +1,367 @@ |
||||
#include "opencv2/highgui.hpp" |
||||
#include "opencv2/video.hpp" |
||||
#include "opencv2/optflow.hpp" |
||||
#include <fstream> |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
using namespace optflow; |
||||
|
||||
const String keys = "{help h usage ? | | print this message }" |
||||
"{@image1 | | image1 }" |
||||
"{@image2 | | image2 }" |
||||
"{@algorithm | | [farneback, simpleflow, tvl1 or deepflow] }" |
||||
"{@groundtruth | | path to the .flo file (optional), Middlebury format }" |
||||
"{m measure |endpoint| error measure - [endpoint or angular] }" |
||||
"{r region |all | region to compute stats about [all, discontinuities, untextured] }" |
||||
"{d display | | display additional info images (pauses program execution) }"; |
||||
|
||||
inline bool isFlowCorrect( const Point2f u ) |
||||
{ |
||||
return !cvIsNaN(u.x) && !cvIsNaN(u.y) && (fabs(u.x) < 1e9) && (fabs(u.y) < 1e9); |
||||
} |
||||
inline bool isFlowCorrect( const Point3f u ) |
||||
{ |
||||
return !cvIsNaN(u.x) && !cvIsNaN(u.y) && !cvIsNaN(u.z) && (fabs(u.x) < 1e9) && (fabs(u.y) < 1e9) |
||||
&& (fabs(u.z) < 1e9); |
||||
} |
||||
static Mat endpointError( const Mat_<Point2f>& flow1, const Mat_<Point2f>& flow2 ) |
||||
{ |
||||
Mat result(flow1.size(), CV_32FC1); |
||||
for ( int i = 0; i < flow1.rows; ++i ) |
||||
{ |
||||
for ( int j = 0; j < flow1.cols; ++j ) |
||||
{ |
||||
const Point2f u1 = flow1(i, j); |
||||
const Point2f u2 = flow2(i, j); |
||||
|
||||
if ( isFlowCorrect(u1) && isFlowCorrect(u2) ) |
||||
{ |
||||
const Point2f diff = u1 - u2; |
||||
result.at<float>(i, j) = sqrt((float)diff.ddot(diff)); //distance
|
||||
} else |
||||
result.at<float>(i, j) = NAN; |
||||
} |
||||
} |
||||
return result; |
||||
} |
||||
static Mat angularError( const Mat_<Point2f>& flow1, const Mat_<Point2f>& flow2 ) |
||||
{ |
||||
Mat result(flow1.size(), CV_32FC1); |
||||
|
||||
for ( int i = 0; i < flow1.rows; ++i ) |
||||
{ |
||||
for ( int j = 0; j < flow1.cols; ++j ) |
||||
{ |
||||
const Point2f u1_2d = flow1(i, j); |
||||
const Point2f u2_2d = flow2(i, j); |
||||
const Point3f u1(u1_2d.x, u1_2d.y, 1); |
||||
const Point3f u2(u2_2d.x, u2_2d.y, 1); |
||||
|
||||
if ( isFlowCorrect(u1) && isFlowCorrect(u2) ) |
||||
result.at<float>(i, j) = acos((float)(u1.ddot(u2) / norm(u1) * norm(u2))); |
||||
else |
||||
result.at<float>(i, j) = NAN; |
||||
} |
||||
} |
||||
return result; |
||||
} |
||||
// what fraction of pixels have errors higher than given threshold?
|
||||
static float stat_RX( Mat errors, float threshold, Mat mask ) |
||||
{ |
||||
CV_Assert(errors.size() == mask.size()); |
||||
CV_Assert(mask.depth() == CV_8U); |
||||
|
||||
int count = 0, all = 0; |
||||
for ( int i = 0; i < errors.rows; ++i ) |
||||
{ |
||||
for ( int j = 0; j < errors.cols; ++j ) |
||||
{ |
||||
if ( mask.at<char>(i, j) != 0 ) |
||||
{ |
||||
++all; |
||||
if ( errors.at<float>(i, j) > threshold ) |
||||
++count; |
||||
} |
||||
} |
||||
} |
||||
return (float)count / all; |
||||
} |
||||
static float stat_AX( Mat hist, int cutoff_count, float max_value ) |
||||
{ |
||||
int counter = 0; |
||||
int bin = 0; |
||||
int bin_count = hist.rows; |
||||
while ( bin < bin_count && counter < cutoff_count ) |
||||
{ |
||||
counter += (int) hist.at<float>(bin, 0); |
||||
++bin; |
||||
} |
||||
return (float) bin / bin_count * max_value; |
||||
} |
||||
static void calculateStats( Mat errors, Mat mask = Mat(), bool display_images = false ) |
||||
{ |
||||
float R_thresholds[] = { 0.5f, 1.f, 2.f, 5.f, 10.f }; |
||||
float A_thresholds[] = { 0.5f, 0.75f, 0.95f }; |
||||
if ( mask.empty() ) |
||||
mask = Mat::ones(errors.size(), CV_8U); |
||||
CV_Assert(errors.size() == mask.size()); |
||||
CV_Assert(mask.depth() == CV_8U); |
||||
|
||||
//displaying the mask
|
||||
if(display_images) |
||||
{ |
||||
namedWindow( "Region mask", WINDOW_AUTOSIZE ); |
||||
imshow( "Region mask", mask ); |
||||
} |
||||
|
||||
//mean and std computation
|
||||
Scalar s_mean, s_std; |
||||
float mean, std; |
||||
meanStdDev(errors, s_mean, s_std, mask); |
||||
mean = (float)s_mean[0]; |
||||
std = (float)s_std[0]; |
||||
printf("Average: %.2f\nStandard deviation: %.2f\n", mean, std); |
||||
|
||||
//RX stats - displayed in percent
|
||||
float R; |
||||
int R_thresholds_count = sizeof(R_thresholds) / sizeof(float); |
||||
for ( int i = 0; i < R_thresholds_count; ++i ) |
||||
{ |
||||
R = stat_RX(errors, R_thresholds[i], mask); |
||||
printf("R%.1f: %.2f%%\n", R_thresholds[i], R * 100); |
||||
} |
||||
|
||||
//AX stats
|
||||
double max_value; |
||||
minMaxLoc(errors, NULL, &max_value, NULL, NULL, mask); |
||||
|
||||
Mat hist; |
||||
const int n_images = 1; |
||||
const int channels[] = { 0 }; |
||||
const int n_dimensions = 1; |
||||
const int hist_bins[] = { 1024 }; |
||||
const float iranges[] = { 0, (float) max_value }; |
||||
const float* ranges[] = { iranges }; |
||||
const bool uniform = true; |
||||
const bool accumulate = false; |
||||
calcHist(&errors, n_images, channels, mask, hist, n_dimensions, hist_bins, ranges, uniform, |
||||
accumulate); |
||||
int all_pixels = countNonZero(mask); |
||||
int cutoff_count; |
||||
float A; |
||||
int A_thresholds_count = sizeof(A_thresholds) / sizeof(float); |
||||
for ( int i = 0; i < A_thresholds_count; ++i ) |
||||
{ |
||||
cutoff_count = (int) (floor(A_thresholds[i] * all_pixels + 0.5f)); |
||||
A = stat_AX(hist, cutoff_count, (float) max_value); |
||||
printf("A%.2f: %.2f\n", A_thresholds[i], A); |
||||
} |
||||
} |
||||
|
||||
static Mat flowToDisplay(const Mat flow) |
||||
{ |
||||
Mat flow_split[2]; |
||||
Mat magnitude, angle; |
||||
Mat hsv_split[3], hsv, rgb; |
||||
split(flow, flow_split); |
||||
cartToPolar(flow_split[0], flow_split[1], magnitude, angle, true); |
||||
normalize(magnitude, magnitude, 0, 1, NORM_MINMAX); |
||||
hsv_split[0] = angle; // already in degrees - no normalization needed
|
||||
hsv_split[1] = Mat::ones(angle.size(), angle.type()); |
||||
hsv_split[2] = magnitude; |
||||
merge(hsv_split, 3, hsv); |
||||
cvtColor(hsv, rgb, COLOR_HSV2BGR); |
||||
return rgb; |
||||
} |
||||
|
||||
int main( int argc, char** argv ) |
||||
{ |
||||
CommandLineParser parser(argc, argv, keys); |
||||
parser.about("OpenCV optical flow evaluation app"); |
||||
if ( parser.has("help") || argc < 4 ) |
||||
{ |
||||
parser.printMessage(); |
||||
printf("EXAMPLES:\n"); |
||||
printf("./example_optflow_optical_flow_evaluation im1.png im2.png farneback -d \n"); |
||||
printf("\t - compute flow field between im1 and im2 with farneback's method and display it"); |
||||
printf("./example_optflow_optical_flow_evaluation im1.png im2.png simpleflow groundtruth.flo \n"); |
||||
printf("\t - compute error statistics given the groundtruth; all pixels, endpoint error measure"); |
||||
printf("./example_optflow_optical_flow_evaluation im1.png im2.png farneback groundtruth.flo -m=angular -r=untextured \n"); |
||||
printf("\t - as before, but with changed error measure and stats computed only about \"untextured\" areas"); |
||||
printf("\n\n Flow file format description: http://vision.middlebury.edu/flow/code/flow-code/README.txt\n\n"); |
||||
return 0; |
||||
} |
||||
String i1_path = parser.get<String>(0); |
||||
String i2_path = parser.get<String>(1); |
||||
String method = parser.get<String>(2); |
||||
String groundtruth_path = parser.get<String>(3); |
||||
String error_measure = parser.get<String>("measure"); |
||||
String region = parser.get<String>("region"); |
||||
bool display_images = parser.has("display"); |
||||
|
||||
if ( !parser.check() ) |
||||
{ |
||||
parser.printErrors(); |
||||
return 0; |
||||
} |
||||
|
||||
Mat i1, i2; |
||||
Mat_<Point2f> flow, ground_truth; |
||||
Mat computed_errors; |
||||
i1 = imread(i1_path, 1); |
||||
i2 = imread(i2_path, 1); |
||||
|
||||
if ( !i1.data || !i2.data ) |
||||
{ |
||||
printf("No image data \n"); |
||||
return -1; |
||||
} |
||||
if ( i1.size() != i2.size() || i1.channels() != i2.channels() ) |
||||
{ |
||||
printf("Dimension mismatch between input images\n"); |
||||
return -1; |
||||
} |
||||
// 8-bit images expected by all algorithms
|
||||
if ( i1.depth() != CV_8U ) |
||||
i1.convertTo(i1, CV_8U); |
||||
if ( i2.depth() != CV_8U ) |
||||
i2.convertTo(i2, CV_8U); |
||||
|
||||
if ( (method == "farneback" || method == "tvl1" || method == "deepflow") && i1.channels() == 3 ) |
||||
{ // 1-channel images are expected
|
||||
cvtColor(i1, i1, COLOR_BGR2GRAY); |
||||
cvtColor(i2, i2, COLOR_BGR2GRAY); |
||||
} else if ( method == "simpleflow" && i1.channels() == 1 ) |
||||
{ // 3-channel images expected
|
||||
cvtColor(i1, i1, COLOR_GRAY2BGR); |
||||
cvtColor(i2, i2, COLOR_GRAY2BGR); |
||||
} |
||||
|
||||
flow = Mat(i1.size[0], i1.size[1], CV_32FC2); |
||||
Ptr<DenseOpticalFlow> algorithm; |
||||
|
||||
if ( method == "farneback" ) |
||||
algorithm = createOptFlow_Farneback(); |
||||
else if ( method == "simpleflow" ) |
||||
algorithm = createOptFlow_SimpleFlow(); |
||||
else if ( method == "tvl1" ) |
||||
algorithm = createOptFlow_DualTVL1(); |
||||
else if ( method == "deepflow" ) |
||||
algorithm = createOptFlow_DeepFlow(); |
||||
else |
||||
{ |
||||
printf("Wrong method!\n"); |
||||
parser.printMessage(); |
||||
return -1; |
||||
} |
||||
|
||||
double startTick, time; |
||||
startTick = (double) getTickCount(); // measure time
|
||||
algorithm->calc(i1, i2, flow); |
||||
time = ((double) getTickCount() - startTick) / getTickFrequency(); |
||||
printf("\nTime [s]: %.3f\n", time); |
||||
if(display_images) |
||||
{ |
||||
Mat flow_image = flowToDisplay(flow); |
||||
namedWindow( "Computed flow", WINDOW_AUTOSIZE ); |
||||
imshow( "Computed flow", flow_image ); |
||||
} |
||||
|
||||
if ( !groundtruth_path.empty() ) |
||||
{ // compare to ground truth
|
||||
ground_truth = optflow::readOpticalFlow(groundtruth_path); |
||||
if ( flow.size() != ground_truth.size() || flow.channels() != 2 |
||||
|| ground_truth.channels() != 2 ) |
||||
{ |
||||
printf("Dimension mismatch between the computed flow and the provided ground truth\n"); |
||||
return -1; |
||||
} |
||||
if ( error_measure == "endpoint" ) |
||||
computed_errors = endpointError(flow, ground_truth); |
||||
else if ( error_measure == "angular" ) |
||||
computed_errors = angularError(flow, ground_truth); |
||||
else |
||||
{ |
||||
printf("Invalid error measure! Available options: endpoint, angular\n"); |
||||
return -1; |
||||
} |
||||
|
||||
Mat mask; |
||||
if( region == "all" ) |
||||
mask = Mat::ones(ground_truth.size(), CV_8U) * 255; |
||||
else if ( region == "discontinuities" ) |
||||
{ |
||||
Mat truth_merged, grad_x, grad_y, gradient; |
||||
vector<Mat> truth_split; |
||||
split(ground_truth, truth_split); |
||||
truth_merged = truth_split[0] + truth_split[1]; |
||||
|
||||
Sobel( truth_merged, grad_x, CV_16S, 1, 0, -1, 1, 0, BORDER_REPLICATE ); |
||||
grad_x = abs(grad_x); |
||||
Sobel( truth_merged, grad_y, CV_16S, 0, 1, 1, 1, 0, BORDER_REPLICATE ); |
||||
grad_y = abs(grad_y); |
||||
addWeighted(grad_x, 0.5, grad_y, 0.5, 0, gradient); //approximation!
|
||||
|
||||
Scalar s_mean; |
||||
s_mean = mean(gradient); |
||||
double threshold = s_mean[0]; // threshold value arbitrary
|
||||
mask = gradient > threshold; |
||||
dilate(mask, mask, Mat::ones(9, 9, CV_8U)); |
||||
} |
||||
else if ( region == "untextured" ) |
||||
{ |
||||
Mat i1_grayscale, grad_x, grad_y, gradient; |
||||
if( i1.channels() == 3 ) |
||||
cvtColor(i1, i1_grayscale, COLOR_BGR2GRAY); |
||||
else |
||||
i1_grayscale = i1; |
||||
Sobel( i1_grayscale, grad_x, CV_16S, 1, 0, 7 ); |
||||
grad_x = abs(grad_x); |
||||
Sobel( i1_grayscale, grad_y, CV_16S, 0, 1, 7 ); |
||||
grad_y = abs(grad_y); |
||||
addWeighted(grad_x, 0.5, grad_y, 0.5, 0, gradient); //approximation!
|
||||
GaussianBlur(gradient, gradient, Size(5,5), 1, 1); |
||||
|
||||
Scalar s_mean; |
||||
s_mean = mean(gradient); |
||||
// arbitrary threshold value used - could be determined statistically from the image?
|
||||
double threshold = 1000; |
||||
mask = gradient < threshold; |
||||
dilate(mask, mask, Mat::ones(3, 3, CV_8U)); |
||||
} |
||||
|
||||
else |
||||
{ |
||||
printf("Invalid region selected! Available options: all, discontinuities, untextured"); |
||||
return -1; |
||||
} |
||||
|
||||
//masking out NaNs and incorrect GT values
|
||||
Mat truth_split[2]; |
||||
split(ground_truth, truth_split); |
||||
Mat abs_mask = Mat((abs(truth_split[0]) < 1e9) & (abs(truth_split[1]) < 1e9)); |
||||
Mat nan_mask = Mat((truth_split[0]==truth_split[0]) & (truth_split[1] == truth_split[1])); |
||||
bitwise_and(abs_mask, nan_mask, nan_mask); |
||||
|
||||
bitwise_and(nan_mask, mask, mask); //including the selected region
|
||||
|
||||
if(display_images) // display difference between computed and GT flow
|
||||
{ |
||||
Mat difference = ground_truth - flow; |
||||
Mat masked_difference; |
||||
difference.copyTo(masked_difference, mask); |
||||
Mat flow_image = flowToDisplay(masked_difference); |
||||
namedWindow( "Error map", WINDOW_AUTOSIZE ); |
||||
imshow( "Error map", flow_image ); |
||||
} |
||||
|
||||
printf("Using %s error measure\n", error_measure.c_str()); |
||||
calculateStats(computed_errors, mask, display_images); |
||||
|
||||
} |
||||
if(display_images) // wait for the user to see all the images
|
||||
waitKey(0); |
||||
return 0; |
||||
|
||||
} |
||||
@ -0,0 +1,868 @@ |
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp" |
||||
#include <opencv2/highgui.hpp> |
||||
|
||||
namespace cv |
||||
{ |
||||
namespace optflow |
||||
{ |
||||
|
||||
class OpticalFlowDeepFlow: public DenseOpticalFlow |
||||
{ |
||||
public: |
||||
OpticalFlowDeepFlow(); |
||||
|
||||
void calc( InputArray I0, InputArray I1, InputOutputArray flow ); |
||||
void collectGarbage(); |
||||
|
||||
// AlgorithmInfo* info() const;
|
||||
|
||||
protected: |
||||
float sigma; // Gaussian smoothing parameter
|
||||
int minSize; // minimal dimension of an image in the pyramid
|
||||
float downscaleFactor; // scaling factor in the pyramid
|
||||
int fixedPointIterations; // during each level of the pyramid
|
||||
int sorIterations; // iterations of SOR
|
||||
float alpha; // smoothness assumption weight
|
||||
float delta; // color constancy weight
|
||||
float gamma; // gradient constancy weight
|
||||
float omega; // relaxation factor in SOR
|
||||
|
||||
float zeta; // added to the denomimnator of theta_0 (normaliation of the data term)
|
||||
float epsilon; // robust penalizer const
|
||||
int maxLayers; // max amount of layers in the pyramid
|
||||
|
||||
private: |
||||
void calcOneLevel( const Mat I0, const Mat I1, Mat W ); |
||||
Mat warpImage( const Mat input, const Mat flow ); |
||||
void dataTerm( const Mat W, const Mat dW, const Mat Ix, const Mat Iy, const Mat Iz, |
||||
const Mat Ixx, const Mat Ixy, const Mat Iyy, const Mat Ixz, const Mat Iyz, |
||||
Mat a11, Mat a12, Mat a22, Mat b1, Mat b2 ); |
||||
void smoothnessWeights( const Mat W, Mat weightsX, Mat weightsY ); |
||||
void smoothnessTerm( const Mat W, const Mat weightsX, const Mat weightsY, Mat b1, Mat b2 ); |
||||
void sorSolve( const Mat a11, const Mat a12, const Mat a22, const Mat b1, const Mat b2, |
||||
const Mat smoothX, const Mat smoothY, Mat dW ); |
||||
void sorUnfolded( const Mat a11, const Mat a12, const Mat a22, const Mat b1, const Mat b2, |
||||
const Mat smoothX, const Mat smoothY, Mat dW ); |
||||
std::vector<Mat> buildPyramid( const Mat& src ); |
||||
|
||||
int interpolationType; |
||||
|
||||
}; |
||||
|
||||
OpticalFlowDeepFlow::OpticalFlowDeepFlow() |
||||
{ |
||||
// parameters
|
||||
sigma = 0.6f; |
||||
minSize = 25; |
||||
downscaleFactor = 0.95f; |
||||
fixedPointIterations = 5; |
||||
sorIterations = 25; |
||||
alpha = 1.0f; |
||||
delta = 0.5f; |
||||
gamma = 5.0f; |
||||
omega = 1.6f; |
||||
|
||||
//consts
|
||||
interpolationType = INTER_LINEAR; |
||||
zeta = 0.1f; |
||||
epsilon = 0.001f; |
||||
maxLayers = 200; |
||||
} |
||||
|
||||
std::vector<Mat> OpticalFlowDeepFlow::buildPyramid( const Mat& src ) |
||||
{ |
||||
std::vector<Mat> pyramid; |
||||
pyramid.push_back(src); |
||||
Mat prev = pyramid[0]; |
||||
int i = 0; |
||||
while ( i < this->maxLayers ) |
||||
{ |
||||
Mat next; //TODO: filtering at each level?
|
||||
Size nextSize((int) (prev.cols * downscaleFactor + 0.5f), |
||||
(int) (prev.rows * downscaleFactor + 0.5f)); |
||||
if( nextSize.height <= minSize || nextSize.width <= minSize) |
||||
break; |
||||
resize(prev, next, |
||||
nextSize, 0, 0, |
||||
interpolationType); |
||||
pyramid.push_back(next); |
||||
prev = next; |
||||
} |
||||
return pyramid; |
||||
} |
||||
Mat OpticalFlowDeepFlow::warpImage( const Mat input, const Mat flow ) |
||||
{ |
||||
// warps the image "backwards"
|
||||
// if flow = computeFlow( I0, I1 ), then
|
||||
// I0 = warpImage( I1, flow ) - approx.
|
||||
|
||||
Mat output; |
||||
Mat mapX = Mat(flow.size(), CV_32FC1); |
||||
Mat mapY = Mat(flow.size(), CV_32FC1); |
||||
const float *pFlow; |
||||
float *pMapX, *pMapY; |
||||
for ( int j = 0; j < flow.rows; ++j ) |
||||
{ |
||||
pFlow = flow.ptr<float>(j); |
||||
pMapX = mapX.ptr<float>(j); |
||||
pMapY = mapY.ptr<float>(j); |
||||
for ( int i = 0; i < flow.cols; ++i ) |
||||
{ |
||||
pMapX[i] = i + pFlow[2 * i]; |
||||
pMapY[i] = j + pFlow[2 * i + 1]; |
||||
} |
||||
} |
||||
remap(input, output, mapX, mapY, interpolationType, BORDER_TRANSPARENT); |
||||
return output; |
||||
} |
||||
void OpticalFlowDeepFlow::calc( InputArray _I0, InputArray _I1, InputOutputArray _flow ) |
||||
{ |
||||
Mat I0temp = _I0.getMat(); |
||||
Mat I1temp = _I1.getMat(); |
||||
|
||||
CV_Assert(I0temp.size() == I1temp.size()); |
||||
CV_Assert(I0temp.type() == I1temp.type()); |
||||
CV_Assert(I0temp.channels() == 1); |
||||
// TODO: currently only grayscale - data term could be computed in color version as well...
|
||||
|
||||
Mat I0, I1; |
||||
|
||||
I0temp.convertTo(I0, CV_32F); |
||||
I1temp.convertTo(I1, CV_32F); |
||||
|
||||
_flow.create(I0.size(), CV_32FC2); |
||||
Mat W = _flow.getMat(); // if any data present - will be discarded
|
||||
|
||||
// pre-smooth images
|
||||
int kernelLen = ((int)floor(3 * sigma) * 2) + 1; |
||||
Size kernelSize(kernelLen, kernelLen); |
||||
GaussianBlur(I0, I0, kernelSize, sigma); |
||||
GaussianBlur(I1, I1, kernelSize, sigma); |
||||
// build down-sized pyramids
|
||||
std::vector<Mat> pyramid_I0 = buildPyramid(I0); |
||||
std::vector<Mat> pyramid_I1 = buildPyramid(I1); |
||||
int levelCount = (int) pyramid_I0.size(); |
||||
|
||||
// initialize the first version of flow estimate to zeros
|
||||
Size smallestSize = pyramid_I0[levelCount - 1].size(); |
||||
W = Mat::zeros(smallestSize, CV_32FC2); |
||||
|
||||
for ( int level = levelCount - 1; level >= 0; --level ) |
||||
{ //iterate through all levels, beginning with the most coarse
|
||||
calcOneLevel(pyramid_I0[level], pyramid_I1[level], W); |
||||
if ( level > 0 ) //not the last level
|
||||
{ |
||||
Mat temp; |
||||
Size newSize = pyramid_I0[level - 1].size(); |
||||
resize(W, temp, newSize, 0, 0, interpolationType); //resize calculated flow
|
||||
W = temp * (1.0f / downscaleFactor); //scale values
|
||||
} |
||||
} |
||||
W.copyTo(_flow); |
||||
} |
||||
|
||||
void OpticalFlowDeepFlow::calcOneLevel( const Mat I0, const Mat I1, Mat W ) |
||||
{ |
||||
CV_DbgAssert( I0.size() == I1.size() );CV_DbgAssert( I0.type() == I1.type() );CV_DbgAssert( W.size() == I0.size() ); |
||||
|
||||
// linear equation systems
|
||||
Size s = I0.size(); |
||||
int t = CV_32F; // data type
|
||||
Mat a11, a12, a22, b1, b2; |
||||
a11.create(s, t); |
||||
a12.create(s, t); |
||||
a22.create(s, t); |
||||
b1.create(s, t); |
||||
b2.create(s, t); |
||||
// diffusivity coeffs
|
||||
Mat weightsX, weightsY; |
||||
weightsX.create(s, t); |
||||
weightsY.create(s, t); |
||||
|
||||
Mat warpedI1 = warpImage(I1, W); // warped second image
|
||||
Mat averageFrame = 0.5 * (I0 + warpedI1); // mean value of 2 frames - to compute derivatives on
|
||||
|
||||
//computing derivatives, notation as in Brox's paper
|
||||
Mat Ix, Iy, Iz, Ixx, Ixy, Iyy, Ixz, Iyz; |
||||
int ddepth = -1; //as source image
|
||||
int kernel_size = 1; |
||||
|
||||
Sobel(averageFrame, Ix, ddepth, 1, 0, kernel_size, 1, 0.00, BORDER_REPLICATE); |
||||
Sobel(averageFrame, Iy, ddepth, 0, 1, kernel_size, 1, 0.00, BORDER_REPLICATE); |
||||
Iz.create(I1.size(), I1.type()); |
||||
Iz = warpedI1 - I0; |
||||
Sobel(Ix, Ixx, ddepth, 1, 0, kernel_size, 1, 0.00, BORDER_REPLICATE); |
||||
Sobel(Ix, Ixy, ddepth, 0, 1, kernel_size, 1, 0.00, BORDER_REPLICATE); |
||||
Sobel(Iy, Iyy, ddepth, 0, 1, kernel_size, 1, 0.00, BORDER_REPLICATE); |
||||
Sobel(Iz, Ixz, ddepth, 1, 0, kernel_size, 1, 0.00, BORDER_REPLICATE); |
||||
Sobel(Iz, Iyz, ddepth, 0, 1, kernel_size, 1, 0.00, BORDER_REPLICATE); |
||||
|
||||
Mat tempW = W.clone(); // flow version to be modified in each iteration
|
||||
Mat dW = Mat::zeros(W.size(), W.type()); // flow increment
|
||||
|
||||
//fixed-point iterations
|
||||
for ( int i = 0; i < fixedPointIterations; ++i ) |
||||
{ |
||||
dataTerm(W, dW, Ix, Iy, Iz, Ixx, Ixy, Iyy, Ixz, Iyz, a11, a12, a22, b1, b2); |
||||
smoothnessWeights(tempW, weightsX, weightsY); |
||||
smoothnessTerm(W, weightsX, weightsY, b1, b2); |
||||
sorSolve(a11, a12, a22, b1, b2, weightsX, weightsY, dW); |
||||
tempW = W + dW; |
||||
} |
||||
tempW.copyTo(W); |
||||
} |
||||
void OpticalFlowDeepFlow::dataTerm( const Mat W, const Mat dW, const Mat Ix, const Mat Iy, |
||||
const Mat Iz, const Mat Ixx, const Mat Ixy, const Mat Iyy, const Mat Ixz, |
||||
const Mat Iyz, Mat a11, Mat a12, Mat a22, Mat b1, Mat b2 ) |
||||
{ |
||||
const float zeta_squared = zeta * zeta; // added in normalization factor to be non-zero
|
||||
const float epsilon_squared = epsilon * epsilon; |
||||
|
||||
const float *pIx, *pIy, *pIz; |
||||
const float *pIxx, *pIxy, *pIyy, *pIxz, *pIyz; |
||||
const float *pdU, *pdV; // accessing 2 layers of dW. Succesive columns interleave u and v
|
||||
float *pa11, *pa12, *pa22, *pb1, *pb2; // linear equation sys. coeffs for each pixel
|
||||
|
||||
float derivNorm; //denominator of the spatial-derivative normalizing factor (theta_0)
|
||||
float derivNorm2; |
||||
float Ik1z, Ik1zx, Ik1zy; // approximations of I^(k+1) values by Taylor expansions
|
||||
float temp; |
||||
for ( int j = 0; j < W.rows; j++ ) //for each row
|
||||
{ |
||||
pIx = Ix.ptr<float>(j); |
||||
pIy = Iy.ptr<float>(j); |
||||
pIz = Iz.ptr<float>(j); |
||||
pIxx = Ixx.ptr<float>(j); |
||||
pIxy = Ixy.ptr<float>(j); |
||||
pIyy = Iyy.ptr<float>(j); |
||||
pIxz = Ixz.ptr<float>(j); |
||||
pIyz = Iyz.ptr<float>(j); |
||||
|
||||
pa11 = a11.ptr<float>(j); |
||||
pa12 = a12.ptr<float>(j); |
||||
pa22 = a22.ptr<float>(j); |
||||
pb1 = b1.ptr<float>(j); |
||||
pb2 = b2.ptr<float>(j); |
||||
|
||||
pdU = dW.ptr<float>(j); |
||||
pdV = pdU + 1; |
||||
for ( int i = 0; i < W.cols; i++ ) //for each pixel in the row
|
||||
{ // TODO: implement masking of points warped out of the image
|
||||
//color constancy component
|
||||
derivNorm = (*pIx) * (*pIx) + (*pIy) * (*pIy) + zeta_squared; |
||||
Ik1z = *pIz + (*pIx * *pdU) + (*pIy * *pdV); |
||||
temp = (0.5f*delta/3) / sqrt(Ik1z * Ik1z / derivNorm + epsilon_squared); |
||||
*pa11 = *pIx * *pIx * temp / derivNorm; |
||||
*pa12 = *pIx * *pIy * temp / derivNorm; |
||||
*pa22 = *pIy * *pIy * temp / derivNorm; |
||||
*pb1 = -*pIz * *pIx * temp / derivNorm; |
||||
*pb2 = -*pIz * *pIy * temp / derivNorm; |
||||
|
||||
// gradient constancy component
|
||||
|
||||
derivNorm = *pIxx * *pIxx + *pIxy * *pIxy + zeta_squared; |
||||
derivNorm2 = *pIyy * *pIyy + *pIxy * *pIxy + zeta_squared; |
||||
Ik1zx = *pIxz + *pIxx * *pdU + *pIxy * *pdV; |
||||
Ik1zy = *pIyz + *pIxy * *pdU + *pIyy * *pdV; |
||||
|
||||
temp = (0.5f*gamma/3) |
||||
/ sqrt( |
||||
Ik1zx * Ik1zx / derivNorm + Ik1zy * Ik1zy / derivNorm2 |
||||
+ epsilon_squared); |
||||
*pa11 += temp * (*pIxx * *pIxx / derivNorm + *pIxy * *pIxy / derivNorm2); |
||||
*pa12 += temp * (*pIxx * *pIxy / derivNorm + *pIxy * *pIyy / derivNorm2); |
||||
*pa22 += temp * (*pIxy * *pIxy / derivNorm + *pIyy * *pIyy / derivNorm2); |
||||
*pb1 += -temp * (*pIxx * *pIxz / derivNorm + *pIxy * *pIyz / derivNorm2); |
||||
*pb2 += -temp * (*pIxy * *pIxz / derivNorm + *pIyy * *pIyz / derivNorm2); |
||||
|
||||
++pIx; |
||||
++pIy; |
||||
++pIz; |
||||
++pIxx; |
||||
++pIxy; |
||||
++pIyy; |
||||
++pIxz; |
||||
++pIyz; |
||||
pdU += 2; |
||||
pdV += 2; |
||||
++pa11; |
||||
++pa12; |
||||
++pa22; |
||||
++pb1; |
||||
++pb2; |
||||
|
||||
} |
||||
} |
||||
|
||||
|
||||
|
||||
} |
||||
void OpticalFlowDeepFlow::smoothnessWeights( const Mat W, Mat weightsX, Mat weightsY ) |
||||
{ |
||||
float k[] = { -0.5, 0, 0.5 }; |
||||
const float epsilon_squared = epsilon * epsilon; |
||||
Mat kernel_h = Mat(1, 3, CV_32FC1, k); |
||||
Mat kernel_v = Mat(3, 1, CV_32FC1, k); |
||||
Mat Wx, Wy; // partial derivatives of the flow
|
||||
Mat S = Mat(W.size(), CV_32FC1); // sum of squared derivatives
|
||||
weightsX = Mat::zeros(W.size(), CV_32FC1); //output - weights of smoothness terms in x and y directions
|
||||
weightsY = Mat::zeros(W.size(), CV_32FC1); |
||||
|
||||
filter2D(W, Wx, CV_32FC2, kernel_h); |
||||
filter2D(W, Wy, CV_32FC2, kernel_v); |
||||
|
||||
const float * ux, *uy, *vx, *vy; |
||||
float * pS, *pWeight, *temp; |
||||
|
||||
for ( int j = 0; j < S.rows; ++j ) |
||||
{ |
||||
ux = Wx.ptr<float>(j); |
||||
vx = ux + 1; |
||||
uy = Wy.ptr<float>(j); |
||||
vy = uy + 1; |
||||
pS = S.ptr<float>(j); |
||||
for ( int i = 0; i < S.cols; ++i ) |
||||
{ |
||||
*pS = alpha / sqrt(*ux * *ux + *vx * *vx + *uy * *uy + *vy * *vy + epsilon_squared); |
||||
ux += 2; |
||||
vx += 2; |
||||
uy += 2; |
||||
vy += 2; |
||||
++pS; |
||||
} |
||||
} |
||||
// horizontal weights
|
||||
for ( int j = 0; j < S.rows; ++j ) |
||||
{ |
||||
pWeight = weightsX.ptr<float>(j); |
||||
pS = S.ptr<float>(j); |
||||
for ( int i = 0; i < S.cols - 1; ++i ) |
||||
{ |
||||
*pWeight = *pS + *(pS + 1); |
||||
++pS; |
||||
++pWeight; |
||||
} |
||||
} |
||||
//vertical weights
|
||||
for ( int j = 0; j < S.rows - 1; ++j ) |
||||
{ |
||||
pWeight = weightsY.ptr<float>(j); |
||||
pS = S.ptr<float>(j); |
||||
temp = S.ptr<float>(j + 1); // next row pointer for easy access
|
||||
for ( int i = 0; i < S.cols; ++i ) |
||||
{ |
||||
*pWeight = *(pS++) + *(temp++); |
||||
++pWeight; |
||||
} |
||||
} |
||||
} |
||||
void OpticalFlowDeepFlow::smoothnessTerm( const Mat W, const Mat weightsX, const Mat weightsY, |
||||
Mat b1, Mat b2 ) |
||||
{ |
||||
float *pB1, *pB2; |
||||
const float *pU, *pV, *pWeight; |
||||
float iB1, iB2; // increments of b1 and b2
|
||||
//horizontal direction - both U and V (b1 and b2)
|
||||
for ( int j = 0; j < W.rows; j++ ) |
||||
{ |
||||
pB1 = b1.ptr<float>(j); |
||||
pB2 = b2.ptr<float>(j); |
||||
pU = W.ptr<float>(j); |
||||
pV = pU + 1; |
||||
pWeight = weightsX.ptr<float>(j); |
||||
for ( int i = 0; i < W.cols - 1; i++ ) |
||||
{ |
||||
iB1 = (*(pU + 2) - *pU) * *pWeight; |
||||
iB2 = (*(pV + 2) - *pV) * *pWeight; |
||||
*pB1 += iB1; |
||||
*(pB1 + 1) -= iB1; |
||||
*pB2 += iB2; |
||||
*(pB2 + 1) -= iB2; |
||||
|
||||
pB1++; |
||||
pB2++; |
||||
pU += 2; |
||||
pV += 2; |
||||
pWeight++; |
||||
} |
||||
} |
||||
const float *pUnext, *pVnext; // temp pointers for next row
|
||||
float *pB1next, *pB2next; |
||||
//vertical direction - both U and V
|
||||
for ( int j = 0; j < W.rows - 1; j++ ) |
||||
{ |
||||
pB1 = b1.ptr<float>(j); |
||||
pB2 = b2.ptr<float>(j); |
||||
pU = W.ptr<float>(j); |
||||
pV = pU + 1; |
||||
pUnext = W.ptr<float>(j + 1); |
||||
pVnext = pUnext + 1; |
||||
pB1next = b1.ptr<float>(j + 1); |
||||
pB2next = b2.ptr<float>(j + 1); |
||||
pWeight = weightsY.ptr<float>(j); |
||||
for ( int i = 0; i < W.cols; i++ ) |
||||
{ |
||||
iB1 = (*pUnext - *pU) * *pWeight; |
||||
iB2 = (*pVnext - *pV) * *pWeight; |
||||
*pB1 += iB1; |
||||
*pB1next -= iB1; |
||||
*pB2 += iB2; |
||||
*pB2next -= iB2; |
||||
|
||||
pB1++; |
||||
pB2++; |
||||
pU += 2; |
||||
pV += 2; |
||||
pWeight++; |
||||
pUnext += 2; |
||||
pVnext += 2; |
||||
pB1next++; |
||||
pB2next++; |
||||
} |
||||
} |
||||
} |
||||
|
||||
void OpticalFlowDeepFlow::sorSolve( const Mat a11, const Mat a12, const Mat a22, const Mat b1, |
||||
const Mat b2, const Mat smoothX, const Mat smoothY, Mat dW ) |
||||
{ |
||||
CV_Assert(a11.isContinuous()); |
||||
CV_Assert(a12.isContinuous()); |
||||
CV_Assert(a22.isContinuous()); |
||||
CV_Assert(b1.isContinuous()); |
||||
CV_Assert(b2.isContinuous()); |
||||
CV_Assert(smoothX.isContinuous()); |
||||
CV_Assert(smoothY.isContinuous()); |
||||
|
||||
if(dW.cols > 2 && dW.rows > 2) |
||||
{ |
||||
sorUnfolded(a11, a12, a22, b1, b2, smoothX, smoothY, dW ); |
||||
//more efficient version - this one is mostly for future reference and readability
|
||||
return; |
||||
} |
||||
std::vector<Mat> dWChannels(2); |
||||
split(dW, dWChannels); |
||||
|
||||
Mat *du = &(dWChannels[0]); |
||||
Mat *dv = &(dWChannels[1]); |
||||
|
||||
CV_Assert(du->isContinuous()); |
||||
CV_Assert(dv->isContinuous()); |
||||
|
||||
const float *pa11, *pa12, *pa22, *pb1, *pb2, *psmoothX, *psmoothY; |
||||
float *pdu, *pdv; |
||||
psmoothX = smoothX.ptr<float>(0); |
||||
psmoothY = smoothY.ptr<float>(0); |
||||
pdu = du->ptr<float>(0); |
||||
pdv = dv->ptr<float>(0); |
||||
|
||||
float sigmaU, sigmaV, dPsi, A11, A22, A12, B1, B2, det; |
||||
|
||||
int cols = dW.cols; |
||||
int rows = dW.rows; |
||||
|
||||
int s = dW.cols; // step between rows
|
||||
|
||||
for ( int iter = 0; iter < sorIterations; ++iter ) |
||||
{ |
||||
pa11 = a11.ptr<float>(0); |
||||
pa12 = a12.ptr<float>(0); |
||||
pa22 = a22.ptr<float>(0); |
||||
pb1 = b1.ptr<float>(0); |
||||
pb2 = b2.ptr<float>(0); |
||||
for ( int j = 0; j < rows; ++j ) |
||||
{ |
||||
for ( int i = 0; i < cols; ++i ) |
||||
{ |
||||
int o = j * s + i; |
||||
if ( i == 0 && j == 0 ) |
||||
{ |
||||
dPsi = psmoothX[o] + psmoothY[o]; |
||||
sigmaU = psmoothX[o] * pdu[o + 1] + psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o] * pdv[o + 1] + psmoothY[o] * pdv[o + s]; |
||||
} else if ( i == cols - 1 && j == 0 ) |
||||
{ |
||||
dPsi = psmoothX[o - 1] + psmoothY[o]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothY[o] * pdv[o + s]; |
||||
} else if ( j == 0 ) |
||||
{ |
||||
dPsi = psmoothX[o - 1] + psmoothX[o] + psmoothY[o]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothX[o] * pdu[o + 1] + psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothX[o] * pdv[o + 1] + psmoothY[o] * pdv[o + s]; |
||||
} else if ( i == 0 && j == rows - 1 ) |
||||
{ |
||||
dPsi = psmoothX[o] + psmoothY[o - s]; |
||||
sigmaU = psmoothX[o] * pdu[o + 1] |
||||
+ psmoothY[o - s] * pdu[o - s]; |
||||
sigmaV = psmoothX[o] * pdv[o + 1] |
||||
+ psmoothY[o - s] * pdv[o - s]; |
||||
} else if ( i == cols - 1 && j == rows - 1 ) |
||||
{ |
||||
dPsi = psmoothX[o - 1] + psmoothY[o - s]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothY[o - s] * pdu[o - s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothY[o - s] * pdv[o - s]; |
||||
} else if ( j == rows - 1 ) |
||||
{ |
||||
dPsi = psmoothX[o - 1] + psmoothX[o] + psmoothY[o - s]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothX[o] * pdu[o + 1] |
||||
+ psmoothY[o - s] * pdu[o - s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothX[o] * pdv[o + 1] |
||||
+ psmoothY[o - s] * pdv[o - s]; |
||||
} else if ( i == 0 ) |
||||
{ |
||||
dPsi = psmoothX[o] + psmoothY[o - s] + psmoothY[o]; |
||||
sigmaU = psmoothX[o] * pdu[o + 1] |
||||
+ psmoothY[o - s] * pdu[o - s] |
||||
+ psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o] * pdv[o + 1] |
||||
+ psmoothY[o - s] * pdv[o - s] |
||||
+ psmoothY[o] * pdv[o + s]; |
||||
} else if ( i == cols - 1 ) |
||||
{ |
||||
dPsi = psmoothX[o - 1] + psmoothY[o - s] + psmoothY[o]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothY[o - s] * pdu[o - s] |
||||
+ psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothY[o - s] * pdv[o - s] |
||||
+ psmoothY[o] * pdv[o + s]; |
||||
} else |
||||
{ |
||||
dPsi = psmoothX[o - 1] + psmoothX[o] + psmoothY[o - s] |
||||
+ psmoothY[o]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothX[o] * pdu[o + 1] |
||||
+ psmoothY[o - s] * pdu[o - s] |
||||
+ psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothX[o] * pdv[o + 1] |
||||
+ psmoothY[o - s] * pdv[o - s] |
||||
+ psmoothY[o] * pdv[o + s]; |
||||
} |
||||
A11 = *pa22 + dPsi; |
||||
A12 = -*pa12; |
||||
A22 = *pa11 + dPsi; |
||||
det = A11 * A22 - A12 * A12; |
||||
A11 /= det; |
||||
A12 /= det; |
||||
A22 /= det; |
||||
B1 = *pb1 + sigmaU; |
||||
B2 = *pb2 + sigmaV; |
||||
pdu[o] += omega * (A11 * B1 + A12 * B2 - pdu[o]); |
||||
pdv[o] += omega * (A12 * B1 + A22 * B2 - pdv[o]); |
||||
++pa11; ++pa12; ++pa22; ++pb1; ++pb2; |
||||
} |
||||
} |
||||
} |
||||
merge(dWChannels, dW); |
||||
} |
||||
|
||||
|
||||
void OpticalFlowDeepFlow::sorUnfolded( const Mat a11, const Mat a12, const Mat a22, const Mat b1, const Mat b2, |
||||
const Mat smoothX, const Mat smoothY, Mat dW ) |
||||
{ |
||||
// the same effect as sorSolve(), but written more efficiently
|
||||
std::vector<Mat> dWChannels(2); |
||||
split(dW, dWChannels); |
||||
|
||||
Mat *du = &(dWChannels[0]); |
||||
Mat *dv = &(dWChannels[1]); |
||||
|
||||
CV_Assert(du->isContinuous()); |
||||
CV_Assert(dv->isContinuous()); |
||||
|
||||
const float *pa11, *pa12, *pa22, *pb1, *pb2, *psmoothX, *psmoothY; |
||||
float *pdu, *pdv; |
||||
|
||||
|
||||
float sigmaU, sigmaV, dPsi, A11, A22, A12, B1, B2, det; |
||||
|
||||
int cols = dW.cols; |
||||
int rows = dW.rows; |
||||
|
||||
int s = dW.cols; // step between rows
|
||||
int j, i, o; //row, column, offset
|
||||
|
||||
for ( int iter = 0; iter < sorIterations; ++iter ) |
||||
{ |
||||
pa11 = a11.ptr<float>(0); |
||||
pa12 = a12.ptr<float>(0); |
||||
pa22 = a22.ptr<float>(0); |
||||
pb1 = b1.ptr<float>(0); |
||||
pb2 = b2.ptr<float>(0); |
||||
psmoothX = smoothX.ptr<float>(0); |
||||
psmoothY = smoothY.ptr<float>(0); |
||||
pdu = du->ptr<float>(0); |
||||
pdv = dv->ptr<float>(0); |
||||
|
||||
// first row
|
||||
// first column
|
||||
o=0; |
||||
dPsi = psmoothX[o] + psmoothY[o]; |
||||
sigmaU = psmoothX[o] * pdu[o + 1] + psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o] * pdv[o + 1] + psmoothY[o] * pdv[o + s]; |
||||
A11 = *pa22 + dPsi; |
||||
A12 = -*pa12; |
||||
A22 = *pa11 + dPsi; |
||||
det = A11 * A22 - A12 * A12; |
||||
A11 /= det; |
||||
A12 /= det; |
||||
A22 /= det; |
||||
B1 = *pb1 + sigmaU; |
||||
B2 = *pb2 + sigmaV; |
||||
pdu[o] += omega * (A11 * B1 + A12 * B2 - pdu[o]); |
||||
pdv[o] += omega * (A12 * B1 + A22 * B2 - pdv[o]); |
||||
++pa11; ++pa12; ++pa22; ++pb1; ++pb2; |
||||
// middle rows
|
||||
for ( o = 1; o < cols-1; ++o ) |
||||
{ |
||||
dPsi = psmoothX[o - 1] + psmoothX[o] + psmoothY[o]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothX[o] * pdu[o + 1] + psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothX[o] * pdv[o + 1] + psmoothY[o] * pdv[o + s]; |
||||
A11 = *pa22 + dPsi; |
||||
A12 = -*pa12; |
||||
A22 = *pa11 + dPsi; |
||||
det = A11 * A22 - A12 * A12; |
||||
A11 /= det; |
||||
A12 /= det; |
||||
A22 /= det; |
||||
B1 = *pb1 + sigmaU; |
||||
B2 = *pb2 + sigmaV; |
||||
pdu[o] += omega * (A11 * B1 + A12 * B2 - pdu[o]); |
||||
pdv[o] += omega * (A12 * B1 + A22 * B2 - pdv[o]); |
||||
++pa11; ++pa12; ++pa22; ++pb1; ++pb2; |
||||
} |
||||
// last column
|
||||
dPsi = psmoothX[o - 1] + psmoothY[o]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothY[o] * pdv[o + s]; |
||||
A11 = *pa22 + dPsi; |
||||
A12 = -*pa12; |
||||
A22 = *pa11 + dPsi; |
||||
det = A11 * A22 - A12 * A12; |
||||
A11 /= det; |
||||
A12 /= det; |
||||
A22 /= det; |
||||
B1 = *pb1 + sigmaU; |
||||
B2 = *pb2 + sigmaV; |
||||
pdu[o] += omega * (A11 * B1 + A12 * B2 - pdu[o]); |
||||
pdv[o] += omega * (A12 * B1 + A22 * B2 - pdv[o]); |
||||
++pa11; ++pa12; ++pa22; ++pb1; ++pb2; |
||||
++o; |
||||
//middle rows
|
||||
for ( j = 1; j < rows - 1; ++j) |
||||
{ |
||||
// first column
|
||||
dPsi = psmoothX[o] + psmoothY[o - s] + psmoothY[o]; |
||||
sigmaU = psmoothX[o] * pdu[o + 1] |
||||
+ psmoothY[o - s] * pdu[o - s] |
||||
+ psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o] * pdv[o + 1] |
||||
+ psmoothY[o - s] * pdv[o - s] |
||||
+ psmoothY[o] * pdv[o + s]; |
||||
A11 = *pa22 + dPsi; |
||||
A12 = -*pa12; |
||||
A22 = *pa11 + dPsi; |
||||
det = A11 * A22 - A12 * A12; |
||||
A11 /= det; |
||||
A12 /= det; |
||||
A22 /= det; |
||||
B1 = *pb1 + sigmaU; |
||||
B2 = *pb2 + sigmaV; |
||||
pdu[o] += omega * (A11 * B1 + A12 * B2 - pdu[o]); |
||||
pdv[o] += omega * (A12 * B1 + A22 * B2 - pdv[o]); |
||||
++pa11; ++pa12; ++pa22; ++pb1; ++pb2; |
||||
++o; |
||||
// middle columns
|
||||
for ( i = 1; i < cols - 1; ++i) |
||||
{ |
||||
dPsi = psmoothX[o - 1] + psmoothX[o] + psmoothY[o - s] |
||||
+ psmoothY[o]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothX[o] * pdu[o + 1] |
||||
+ psmoothY[o - s] * pdu[o - s] |
||||
+ psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothX[o] * pdv[o + 1] |
||||
+ psmoothY[o - s] * pdv[o - s] |
||||
+ psmoothY[o] * pdv[o + s]; |
||||
A11 = *pa22 + dPsi; |
||||
A12 = -*pa12; |
||||
A22 = *pa11 + dPsi; |
||||
det = A11 * A22 - A12 * A12; |
||||
A11 /= det; |
||||
A12 /= det; |
||||
A22 /= det; |
||||
B1 = *pb1 + sigmaU; |
||||
B2 = *pb2 + sigmaV; |
||||
pdu[o] += omega * (A11 * B1 + A12 * B2 - pdu[o]); |
||||
pdv[o] += omega * (A12 * B1 + A22 * B2 - pdv[o]); |
||||
++pa11; ++pa12; ++pa22; ++pb1; ++pb2; |
||||
++o; |
||||
} |
||||
//last column
|
||||
dPsi = psmoothX[o - 1] + psmoothY[o - s] + psmoothY[o]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothY[o - s] * pdu[o - s] |
||||
+ psmoothY[o] * pdu[o + s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothY[o - s] * pdv[o - s] |
||||
+ psmoothY[o] * pdv[o + s]; |
||||
A11 = *pa22 + dPsi; |
||||
A12 = -*pa12; |
||||
A22 = *pa11 + dPsi; |
||||
det = A11 * A22 - A12 * A12; |
||||
A11 /= det; |
||||
A12 /= det; |
||||
A22 /= det; |
||||
B1 = *pb1 + sigmaU; |
||||
B2 = *pb2 + sigmaV; |
||||
pdu[o] += omega * (A11 * B1 + A12 * B2 - pdu[o]); |
||||
pdv[o] += omega * (A12 * B1 + A22 * B2 - pdv[o]); |
||||
++pa11; ++pa12; ++pa22; ++pb1; ++pb2; |
||||
++o; |
||||
} |
||||
//last row
|
||||
//first column
|
||||
dPsi = psmoothX[o] + psmoothY[o - s]; |
||||
sigmaU = psmoothX[o] * pdu[o + 1] |
||||
+ psmoothY[o - s] * pdu[o - s]; |
||||
sigmaV = psmoothX[o] * pdv[o + 1] |
||||
+ psmoothY[o - s] * pdv[o - s]; |
||||
A11 = *pa22 + dPsi; |
||||
A12 = -*pa12; |
||||
A22 = *pa11 + dPsi; |
||||
det = A11 * A22 - A12 * A12; |
||||
A11 /= det; |
||||
A12 /= det; |
||||
A22 /= det; |
||||
B1 = *pb1 + sigmaU; |
||||
B2 = *pb2 + sigmaV; |
||||
pdu[o] += omega * (A11 * B1 + A12 * B2 - pdu[o]); |
||||
pdv[o] += omega * (A12 * B1 + A22 * B2 - pdv[o]); |
||||
++pa11; ++pa12; ++pa22; ++pb1; ++pb2; |
||||
++o; |
||||
//middle columns
|
||||
for ( i = 1; i < cols - 1; ++i) |
||||
{ |
||||
dPsi = psmoothX[o - 1] + psmoothX[o] + psmoothY[o - s]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothX[o] * pdu[o + 1] |
||||
+ psmoothY[o - s] * pdu[o - s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothX[o] * pdv[o + 1] |
||||
+ psmoothY[o - s] * pdv[o - s]; |
||||
A11 = *pa22 + dPsi; |
||||
A12 = -*pa12; |
||||
A22 = *pa11 + dPsi; |
||||
det = A11 * A22 - A12 * A12; |
||||
A11 /= det; |
||||
A12 /= det; |
||||
A22 /= det; |
||||
B1 = *pb1 + sigmaU; |
||||
B2 = *pb2 + sigmaV; |
||||
pdu[o] += omega * (A11 * B1 + A12 * B2 - pdu[o]); |
||||
pdv[o] += omega * (A12 * B1 + A22 * B2 - pdv[o]); |
||||
++pa11; ++pa12; ++pa22; ++pb1; ++pb2; |
||||
++o; |
||||
} |
||||
//last column
|
||||
dPsi = psmoothX[o - 1] + psmoothY[o - s]; |
||||
sigmaU = psmoothX[o - 1] * pdu[o - 1] |
||||
+ psmoothY[o - s] * pdu[o - s]; |
||||
sigmaV = psmoothX[o - 1] * pdv[o - 1] |
||||
+ psmoothY[o - s] * pdv[o - s]; |
||||
A11 = *pa22 + dPsi; |
||||
A12 = -*pa12; |
||||
A22 = *pa11 + dPsi; |
||||
det = A11 * A22 - A12 * A12; |
||||
A11 /= det; |
||||
A12 /= det; |
||||
A22 /= det; |
||||
B1 = *pb1 + sigmaU; |
||||
B2 = *pb2 + sigmaV; |
||||
pdu[o] += omega * (A11 * B1 + A12 * B2 - pdu[o]); |
||||
pdv[o] += omega * (A12 * B1 + A22 * B2 - pdv[o]); |
||||
++pa11; ++pa12; ++pa22; ++pb1; ++pb2; |
||||
} |
||||
merge(dWChannels, dW); |
||||
|
||||
} |
||||
void OpticalFlowDeepFlow::collectGarbage() |
||||
{ |
||||
|
||||
} |
||||
//
|
||||
//CV_INIT_ALGORITHM(OpticalFlowDeepFlow, "DenseOpticalFlow.DeepFlow",
|
||||
// obj.info()->addParam(obj, "sigma", obj.sigma, false, 0, 0, "Gaussian blur parameter");
|
||||
// obj.info()->addParam(obj, "alpha", obj.alpha, false, 0, 0, "Smoothness assumption weight");
|
||||
// obj.info()->addParam(obj, "delta", obj.delta, false, 0, 0, "Color constancy weight");
|
||||
// obj.info()->addParam(obj, "gamma", obj.gamma, false, 0, 0, "Gradient constancy weight");
|
||||
// obj.info()->addParam(obj, "omega", obj.omega, false, 0, 0, "Relaxation factor in SOR");
|
||||
// obj.info()->addParam(obj, "minSize", obj.minSize, false, 0, 0, "Min. image size in the pyramid");
|
||||
// obj.info()->addParam(obj, "fixedPointIterations", obj.fixedPointIterations, false, 0, 0, "Fixed point iterations");
|
||||
// obj.info()->addParam(obj, "sorIterations", obj.sorIterations, false, 0, 0, "SOR iterations");
|
||||
// obj.info()->addParam(obj, "downscaleFactor", obj.downscaleFactor, false, 0, 0,"Downscale factor"))
|
||||
|
||||
|
||||
Ptr<DenseOpticalFlow> createOptFlow_DeepFlow() |
||||
{ |
||||
return makePtr<OpticalFlowDeepFlow>(); |
||||
} |
||||
|
||||
}//optflow
|
||||
}//cv
|
||||
@ -0,0 +1,183 @@ |
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
#include "precomp.hpp" |
||||
|
||||
#include "opencv2/core.hpp" |
||||
#include "opencv2/highgui.hpp" |
||||
#include "opencv2/video.hpp" |
||||
#include "opencv2/optflow.hpp" |
||||
|
||||
namespace cv |
||||
{ |
||||
namespace optflow |
||||
{ |
||||
class OpticalFlowSimpleFlow : public DenseOpticalFlow |
||||
{ |
||||
public: |
||||
OpticalFlowSimpleFlow(); |
||||
void calc(InputArray I0, InputArray I1, InputOutputArray flow); |
||||
void collectGarbage(); |
||||
// AlgorithmInfo* info() const;
|
||||
|
||||
protected: |
||||
int layers; |
||||
int averaging_radius; |
||||
int max_flow; |
||||
double sigma_dist; |
||||
double sigma_color; |
||||
int postprocess_window; |
||||
double sigma_dist_fix; |
||||
double sigma_color_fix; |
||||
double occ_thr; |
||||
int upscale_averaging_radius; |
||||
double upscale_sigma_dist; |
||||
double upscale_sigma_color; |
||||
double speed_up_thr; |
||||
}; |
||||
|
||||
OpticalFlowSimpleFlow::OpticalFlowSimpleFlow() |
||||
{ |
||||
// values from the example app
|
||||
layers = 3; |
||||
averaging_radius = 2; |
||||
max_flow = 4; |
||||
// values from the default function parameters
|
||||
sigma_dist = 4.1; |
||||
sigma_color = 25.5; |
||||
postprocess_window = 18; |
||||
sigma_dist_fix = 55.0; |
||||
sigma_color_fix = 25.5; |
||||
occ_thr = 0.35; |
||||
upscale_averaging_radius = 18; |
||||
upscale_sigma_dist = 55.0; |
||||
upscale_sigma_color = 25.5; |
||||
speed_up_thr = 10; |
||||
} |
||||
|
||||
void OpticalFlowSimpleFlow::calc(InputArray I0, InputArray I1, InputOutputArray flow) |
||||
{ |
||||
optflow::calcOpticalFlowSF(I0, I1, flow, layers, averaging_radius, max_flow, sigma_dist, sigma_color, |
||||
postprocess_window, sigma_dist_fix, sigma_color_fix, occ_thr, |
||||
upscale_averaging_radius, upscale_sigma_dist, upscale_sigma_color, speed_up_thr); |
||||
} |
||||
void OpticalFlowSimpleFlow::collectGarbage() |
||||
{ |
||||
|
||||
} |
||||
//CV_INIT_ALGORITHM(OpticalFlowSimpleFlow, "DenseOpticalFlow.SimpleFlow"),
|
||||
// obj.info()->addParam(obj, "layers", obj.layers);
|
||||
// obj.info()->addParam(obj, "averaging_radius", obj.averaging_radius);
|
||||
// obj.info()->addParam(obj, "max_flow", obj.max_flow);
|
||||
// obj.info()->addParam(obj, "sigma_dist", obj.sigma_dist);
|
||||
// obj.info()->addParam(obj, "sigma_color", obj.sigma_color);
|
||||
// obj.info()->addParam(obj, "postprocess_window", obj.postprocess_window);
|
||||
// obj.info()->addParam(obj, "sigma_dist_fix", obj.sigma_dist_fix);
|
||||
// obj.info()->addParam(obj, "sigma_color_fix", obj.sigma_color_fix);
|
||||
// obj.info()->addParam(obj, "occ_thr", obj.occ_thr);
|
||||
// obj.info()->addParam(obj, "upscale_averaging_radius", obj.upscale_averaging_radius);
|
||||
// obj.info()->addParam(obj, "upscale_sigma_dist", obj.upscale_sigma_dist);
|
||||
// obj.info()->addParam(obj, "upscale_sigma_color", obj.upscale_sigma_color);
|
||||
// obj.info()->addParam(obj, "speed_up_thr", obj.speed_up_thr))
|
||||
|
||||
Ptr<DenseOpticalFlow> createOptFlow_SimpleFlow() |
||||
{ |
||||
return makePtr<OpticalFlowSimpleFlow>(); |
||||
} |
||||
|
||||
class OpticalFlowFarneback : public DenseOpticalFlow |
||||
{ |
||||
public: |
||||
OpticalFlowFarneback(); |
||||
void calc(InputArray I0, InputArray I1, InputOutputArray flow); |
||||
void collectGarbage(); |
||||
// AlgorithmInfo* info() const;
|
||||
protected: |
||||
int numLevels; |
||||
double pyrScale; |
||||
bool fastPyramids; |
||||
int winSize; |
||||
int numIters; |
||||
int polyN; |
||||
double polySigma; |
||||
int flags; |
||||
}; |
||||
|
||||
OpticalFlowFarneback::OpticalFlowFarneback() |
||||
{ |
||||
// values copied from the FarnebackOpticalFlow class
|
||||
numLevels = 5; |
||||
pyrScale = 0.5; |
||||
fastPyramids = false; |
||||
winSize = 13; |
||||
numIters = 10; |
||||
polyN = 5; |
||||
polySigma = 1.1; |
||||
flags = 0; |
||||
} |
||||
|
||||
void OpticalFlowFarneback::calc(InputArray I0, InputArray I1, InputOutputArray flow) |
||||
{ |
||||
calcOpticalFlowFarneback(I0, I1, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags); |
||||
} |
||||
void OpticalFlowFarneback::collectGarbage() |
||||
{ |
||||
} |
||||
|
||||
//CV_INIT_ALGORITHM(OpticalFlowFarneback, "DenseOpticalFlow.Farneback",
|
||||
// obj.info()->addParam(obj, "numLevels", obj.numLevels);
|
||||
// obj.info()->addParam(obj, "pyrScale", obj.pyrScale);
|
||||
// obj.info()->addParam(obj, "fastPyramids", obj.fastPyramids);
|
||||
// obj.info()->addParam(obj, "winSize", obj.winSize);
|
||||
// obj.info()->addParam(obj, "numIters", obj.numIters);
|
||||
// obj.info()->addParam(obj, "polyN", obj.polyN);
|
||||
// obj.info()->addParam(obj, "polySigma", obj.polySigma);
|
||||
// obj.info()->addParam(obj, "flags", obj.flags))
|
||||
|
||||
|
||||
|
||||
|
||||
Ptr<DenseOpticalFlow> createOptFlow_Farneback() |
||||
{ |
||||
return makePtr<OpticalFlowFarneback>(); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,139 @@ |
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
#include "precomp.hpp" |
||||
#include<iostream> |
||||
#include<fstream> |
||||
|
||||
namespace cv { |
||||
namespace optflow { |
||||
const float FLOW_TAG_FLOAT = 202021.25f; |
||||
const char *FLOW_TAG_STRING = "PIEH"; |
||||
CV_EXPORTS_W Mat readOpticalFlow( const String& path ) |
||||
{ |
||||
// CV_Assert(sizeof(float) == 4);
|
||||
//FIXME: ensure right sizes of int and float - here and in writeOpticalFlow()
|
||||
|
||||
Mat_<Point2f> flow; |
||||
std::ifstream file(path.c_str(), std::ios_base::binary); |
||||
if ( !file.good() ) |
||||
return flow; // no file - return empty matrix
|
||||
|
||||
float tag; |
||||
file.read((char*) &tag, sizeof(float)); |
||||
if ( tag != FLOW_TAG_FLOAT ) |
||||
return flow; |
||||
|
||||
int width, height; |
||||
|
||||
file.read((char*) &width, 4); |
||||
file.read((char*) &height, 4); |
||||
|
||||
flow.create(height, width); |
||||
|
||||
for ( int i = 0; i < flow.rows; ++i ) |
||||
{ |
||||
for ( int j = 0; j < flow.cols; ++j ) |
||||
{ |
||||
Point2f u; |
||||
file.read((char*) &u.x, sizeof(float)); |
||||
file.read((char*) &u.y, sizeof(float)); |
||||
if ( !file.good() ) |
||||
{ |
||||
flow.release(); |
||||
return flow; |
||||
} |
||||
|
||||
flow(i, j) = u; |
||||
} |
||||
} |
||||
file.close(); |
||||
return flow; |
||||
} |
||||
CV_EXPORTS_W bool writeOpticalFlow( const String& path, InputArray flow ) |
||||
{ |
||||
// CV_Assert(sizeof(float) == 4);
|
||||
|
||||
const int nChannels = 2; |
||||
|
||||
Mat input = flow.getMat(); |
||||
if ( input.channels() != nChannels || input.depth() != CV_32F || path.length() == 0 ) |
||||
return false; |
||||
|
||||
std::ofstream file(path.c_str(), std::ofstream::binary); |
||||
if ( !file.good() ) |
||||
return false; |
||||
|
||||
int nRows, nCols; |
||||
|
||||
nRows = (int) input.size().height; |
||||
nCols = (int) input.size().width; |
||||
|
||||
const int headerSize = 12; |
||||
char header[headerSize]; |
||||
memcpy(header, FLOW_TAG_STRING, 4); |
||||
// size of ints is known - has been asserted in the current function
|
||||
memcpy(header + 4, reinterpret_cast<const char*>(&nCols), sizeof(nCols)); |
||||
memcpy(header + 8, reinterpret_cast<const char*>(&nRows), sizeof(nRows)); |
||||
file.write(header, headerSize); |
||||
if ( !file.good() ) |
||||
return false; |
||||
|
||||
// if ( input.isContinuous() ) //matrix is continous - treat it as a single row
|
||||
// {
|
||||
// nCols *= nRows;
|
||||
// nRows = 1;
|
||||
// }
|
||||
|
||||
int row; |
||||
char* p; |
||||
for ( row = 0; row < nRows; row++ ) |
||||
{ |
||||
p = input.ptr<char>(row); |
||||
file.write(p, nCols * nChannels * sizeof(float)); |
||||
if ( !file.good() ) |
||||
return false; |
||||
} |
||||
file.close(); |
||||
return true; |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue