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

removed some tabs

Browse Source
pull/2942/head
Ernest Galbrun 11 years ago
parent eb6c598678
commit ca6fb27ea6
1 changed files with 43 additions and 43 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. 86
      modules/video/src/tvl1flow.cpp

86
modules/video/src/tvl1flow.cpp
Unescape View File

@ -373,20 +373,20 @@ void OpticalFlowDual_TVL1::calc(InputArray _I0, InputArray _I1, InputOutputArray
CV_Assert( I0.type() == I1.type() ); CV_Assert( I0.type() == I1.type() );
CV_Assert( !useInitialFlow || (_flow.size() == I0.size() && _flow.type() == CV_32FC2) ); CV_Assert( !useInitialFlow || (_flow.size() == I0.size() && _flow.type() == CV_32FC2) );
CV_Assert( nscales > 0 ); CV_Assert( nscales > 0 );
bool use_gamma = gamma != 0; bool use_gamma = gamma != 0;
// allocate memory for the pyramid structure // allocate memory for the pyramid structure
dm.I0s.resize(nscales); dm.I0s.resize(nscales);
dm.I1s.resize(nscales); dm.I1s.resize(nscales);
dm.u1s.resize(nscales); dm.u1s.resize(nscales);
dm.u2s.resize(nscales); dm.u2s.resize(nscales);
dm.u3s.resize(nscales); dm.u3s.resize(nscales);
I0.convertTo(dm.I0s[0], dm.I0s[0].depth(), I0.depth() == CV_8U ? 1.0 : 255.0); I0.convertTo(dm.I0s[0], dm.I0s[0].depth(), I0.depth() == CV_8U ? 1.0 : 255.0);
I1.convertTo(dm.I1s[0], dm.I1s[0].depth(), I1.depth() == CV_8U ? 1.0 : 255.0); I1.convertTo(dm.I1s[0], dm.I1s[0].depth(), I1.depth() == CV_8U ? 1.0 : 255.0);
dm.u1s[0].create(I0.size()); dm.u1s[0].create(I0.size());
dm.u2s[0].create(I0.size()); dm.u2s[0].create(I0.size());
if (use_gamma) dm.u3s[0].create(I0.size()); if (use_gamma) dm.u3s[0].create(I0.size());
if (useInitialFlow) if (useInitialFlow)
{ {
@ -409,25 +409,25 @@ void OpticalFlowDual_TVL1::calc(InputArray _I0, InputArray _I1, InputOutputArray
dm.v1_buf.create(I0.size()); dm.v1_buf.create(I0.size());
dm.v2_buf.create(I0.size()); dm.v2_buf.create(I0.size());
dm.v3_buf.create(I0.size()); dm.v3_buf.create(I0.size());
dm.p11_buf.create(I0.size()); dm.p11_buf.create(I0.size());
dm.p12_buf.create(I0.size()); dm.p12_buf.create(I0.size());
dm.p21_buf.create(I0.size()); dm.p21_buf.create(I0.size());
dm.p22_buf.create(I0.size()); dm.p22_buf.create(I0.size());
dm.p31_buf.create(I0.size()); dm.p31_buf.create(I0.size());
dm.p32_buf.create(I0.size()); dm.p32_buf.create(I0.size());
dm.div_p1_buf.create(I0.size()); dm.div_p1_buf.create(I0.size());
dm.div_p2_buf.create(I0.size()); dm.div_p2_buf.create(I0.size());
dm.div_p3_buf.create(I0.size()); dm.div_p3_buf.create(I0.size());
dm.u1x_buf.create(I0.size()); dm.u1x_buf.create(I0.size());
dm.u1y_buf.create(I0.size()); dm.u1y_buf.create(I0.size());
dm.u2x_buf.create(I0.size()); dm.u2x_buf.create(I0.size());
dm.u2y_buf.create(I0.size()); dm.u2y_buf.create(I0.size());
dm.u3x_buf.create(I0.size()); dm.u3x_buf.create(I0.size());
dm.u3y_buf.create(I0.size()); dm.u3y_buf.create(I0.size());
// create the scales // create the scales
for (int s = 1; s < nscales; ++s) for (int s = 1; s < nscales; ++s)
@ -454,14 +454,14 @@ void OpticalFlowDual_TVL1::calc(InputArray _I0, InputArray _I1, InputOutputArray
dm.u1s[s].create(dm.I0s[s].size()); dm.u1s[s].create(dm.I0s[s].size());
dm.u2s[s].create(dm.I0s[s].size()); dm.u2s[s].create(dm.I0s[s].size());
} }
if (use_gamma) dm.u3s[s].create(dm.I0s[s].size()); if (use_gamma) dm.u3s[s].create(dm.I0s[s].size());
} }
if (!useInitialFlow) if (!useInitialFlow)
{ {
dm.u1s[nscales - 1].setTo(Scalar::all(0)); dm.u1s[nscales - 1].setTo(Scalar::all(0));
dm.u2s[nscales - 1].setTo(Scalar::all(0)); dm.u2s[nscales - 1].setTo(Scalar::all(0));
} }
if (use_gamma) dm.u3s[nscales - 1].setTo(Scalar::all(0)); if (use_gamma) dm.u3s[nscales - 1].setTo(Scalar::all(0));
// pyramidal structure for computing the optical flow // pyramidal structure for computing the optical flow
for (int s = nscales - 1; s >= 0; --s) for (int s = nscales - 1; s >= 0; --s)
{ {
@ -477,7 +477,7 @@ void OpticalFlowDual_TVL1::calc(InputArray _I0, InputArray _I1, InputOutputArray
// zoom the optical flow for the next finer scale // zoom the optical flow for the next finer scale
resize(dm.u1s[s], dm.u1s[s - 1], dm.I0s[s - 1].size()); resize(dm.u1s[s], dm.u1s[s - 1], dm.I0s[s - 1].size());
resize(dm.u2s[s], dm.u2s[s - 1], dm.I0s[s - 1].size()); resize(dm.u2s[s], dm.u2s[s - 1], dm.I0s[s - 1].size());
if (use_gamma) resize(dm.u3s[s], dm.u3s[s - 1], dm.I0s[s - 1].size()); if (use_gamma) resize(dm.u3s[s], dm.u3s[s - 1], dm.I0s[s - 1].size());
// scale the optical flow with the appropriate zoom factor (don't scale u3!) // scale the optical flow with the appropriate zoom factor (don't scale u3!)
multiply(dm.u1s[s - 1], Scalar::all(1 / scaleStep), dm.u1s[s - 1]); multiply(dm.u1s[s - 1], Scalar::all(1 / scaleStep), dm.u1s[s - 1]);
@ -944,7 +944,7 @@ struct EstimateVBody : ParallelLoopBody
void EstimateVBody::operator() (const Range& range) const void EstimateVBody::operator() (const Range& range) const
{ {
bool use_gamma = gamma != 0; bool use_gamma = gamma != 0;
for (int y = range.start; y < range.end; ++y) for (int y = range.start; y < range.end; ++y)
{ {
const float* I1wxRow = I1wx[y]; const float* I1wxRow = I1wx[y];
@ -957,12 +957,12 @@ void EstimateVBody::operator() (const Range& range) const
float* v1Row = v1[y]; float* v1Row = v1[y];
float* v2Row = v2[y]; float* v2Row = v2[y];
float* v3Row = use_gamma ? v3[y]:NULL; float* v3Row = use_gamma ? v3[y]:NULL;
for (int x = 0; x < I1wx.cols; ++x) for (int x = 0; x < I1wx.cols; ++x)
{ {
const float rho = use_gamma ? rhoRow[x] + (I1wxRow[x] * u1Row[x] + I1wyRow[x] * u2Row[x]) + gamma * u3Row[x] : const float rho = use_gamma ? rhoRow[x] + (I1wxRow[x] * u1Row[x] + I1wyRow[x] * u2Row[x]) + gamma * u3Row[x] :
rhoRow[x] + (I1wxRow[x] * u1Row[x] + I1wyRow[x] * u2Row[x]); rhoRow[x] + (I1wxRow[x] * u1Row[x] + I1wyRow[x] * u2Row[x]);
float d1 = 0.0f; float d1 = 0.0f;
float d2 = 0.0f; float d2 = 0.0f;
float d3 = 0.0f; float d3 = 0.0f;
@ -970,25 +970,25 @@ void EstimateVBody::operator() (const Range& range) const
{ {
d1 = l_t * I1wxRow[x]; d1 = l_t * I1wxRow[x];
d2 = l_t * I1wyRow[x]; d2 = l_t * I1wyRow[x];
if (use_gamma) d3 = l_t * gamma; if (use_gamma) d3 = l_t * gamma;
} }
else if (rho > l_t * gradRow[x]) else if (rho > l_t * gradRow[x])
{ {
d1 = -l_t * I1wxRow[x]; d1 = -l_t * I1wxRow[x];
d2 = -l_t * I1wyRow[x]; d2 = -l_t * I1wyRow[x];
if (use_gamma) d3 = -l_t * gamma; if (use_gamma) d3 = -l_t * gamma;
} }
else if (gradRow[x] > std::numeric_limits<float>::epsilon()) else if (gradRow[x] > std::numeric_limits<float>::epsilon())
{ {
float fi = -rho / gradRow[x]; float fi = -rho / gradRow[x];
d1 = fi * I1wxRow[x]; d1 = fi * I1wxRow[x];
d2 = fi * I1wyRow[x]; d2 = fi * I1wyRow[x];
if (use_gamma) d3 = fi * gamma; if (use_gamma) d3 = fi * gamma;
} }
v1Row[x] = u1Row[x] + d1; v1Row[x] = u1Row[x] + d1;
v2Row[x] = u2Row[x] + d2; v2Row[x] = u2Row[x] + d2;
if (use_gamma) v3Row[x] = u3Row[x] + d3; if (use_gamma) v3Row[x] = u3Row[x] + d3;
} }
} }
} }
@ -1005,17 +1005,17 @@ void estimateV(const Mat_<float>& I1wx, const Mat_<float>& I1wy, const Mat_<floa
CV_DbgAssert( v2.size() == I1wx.size() ); CV_DbgAssert( v2.size() == I1wx.size() );
EstimateVBody body; EstimateVBody body;
bool use_gamma = gamma != 0; bool use_gamma = gamma != 0;
body.I1wx = I1wx; body.I1wx = I1wx;
body.I1wy = I1wy; body.I1wy = I1wy;
body.u1 = u1; body.u1 = u1;
body.u2 = u2; body.u2 = u2;
if (use_gamma) body.u3 = u3; if (use_gamma) body.u3 = u3;
body.grad = grad; body.grad = grad;
body.rho_c = rho_c; body.rho_c = rho_c;
body.v1 = v1; body.v1 = v1;
body.v2 = v2; body.v2 = v2;
if (use_gamma) body.v3 = v3; if (use_gamma) body.v3 = v3;
body.l_t = l_t; body.l_t = l_t;
body.gamma = gamma; body.gamma = gamma;
parallel_for_(Range(0, I1wx.rows), body); parallel_for_(Range(0, I1wx.rows), body);
@ -1035,8 +1035,8 @@ float estimateU(const Mat_<float>& v1, const Mat_<float>& v2, const Mat_<float>&
CV_DbgAssert( u1.size() == v1.size() ); CV_DbgAssert( u1.size() == v1.size() );
CV_DbgAssert( u2.size() == v1.size() ); CV_DbgAssert( u2.size() == v1.size() );
float error = 0.0f; float error = 0.0f;
bool use_gamma = gamma != 0; bool use_gamma = gamma != 0;
for (int y = 0; y < v1.rows; ++y) for (int y = 0; y < v1.rows; ++y)
{ {
const float* v1Row = v1[y]; const float* v1Row = v1[y];
@ -1059,10 +1059,10 @@ float estimateU(const Mat_<float>& v1, const Mat_<float>& v2, const Mat_<float>&
u1Row[x] = v1Row[x] + theta * divP1Row[x]; u1Row[x] = v1Row[x] + theta * divP1Row[x];
u2Row[x] = v2Row[x] + theta * divP2Row[x]; u2Row[x] = v2Row[x] + theta * divP2Row[x];
if (use_gamma) u3Row[x] = v3Row[x] + theta * divP3Row[x]; if (use_gamma) u3Row[x] = v3Row[x] + theta * divP3Row[x];
error += use_gamma?(u1Row[x] - u1k) * (u1Row[x] - u1k) + (u2Row[x] - u2k) * (u2Row[x] - u2k) + (u3Row[x] - u3k) * (u3Row[x] - u3k): error += use_gamma?(u1Row[x] - u1k) * (u1Row[x] - u1k) + (u2Row[x] - u2k) * (u2Row[x] - u2k) + (u3Row[x] - u3k) * (u3Row[x] - u3k):
(u1Row[x] - u1k) * (u1Row[x] - u1k) + (u2Row[x] - u2k) * (u2Row[x] - u2k); (u1Row[x] - u1k) * (u1Row[x] - u1k) + (u2Row[x] - u2k) * (u2Row[x] - u2k);
} }
} }
@ -1089,7 +1089,7 @@ struct EstimateDualVariablesBody : ParallelLoopBody
mutable Mat_<float> p31; mutable Mat_<float> p31;
mutable Mat_<float> p32; mutable Mat_<float> p32;
float taut; float taut;
bool use_gamma; bool use_gamma;
}; };
void EstimateDualVariablesBody::operator() (const Range& range) const void EstimateDualVariablesBody::operator() (const Range& range) const
@ -1118,14 +1118,14 @@ void EstimateDualVariablesBody::operator() (const Range& range) const
const float ng1 = 1.0f + taut * g1; const float ng1 = 1.0f + taut * g1;
const float ng2 = 1.0f + taut * g2; const float ng2 = 1.0f + taut * g2;
const float ng3 = 1.0f + taut * g3; const float ng3 = 1.0f + taut * g3;
p11Row[x] = (p11Row[x] + taut * u1xRow[x]) / ng1; p11Row[x] = (p11Row[x] + taut * u1xRow[x]) / ng1;
p12Row[x] = (p12Row[x] + taut * u1yRow[x]) / ng1; p12Row[x] = (p12Row[x] + taut * u1yRow[x]) / ng1;
p21Row[x] = (p21Row[x] + taut * u2xRow[x]) / ng2; p21Row[x] = (p21Row[x] + taut * u2xRow[x]) / ng2;
p22Row[x] = (p22Row[x] + taut * u2yRow[x]) / ng2; p22Row[x] = (p22Row[x] + taut * u2yRow[x]) / ng2;
if (use_gamma) p31Row[x] = (p31Row[x] + taut * u3xRow[x]) / ng3; if (use_gamma) p31Row[x] = (p31Row[x] + taut * u3xRow[x]) / ng3;
if (use_gamma) p32Row[x] = (p32Row[x] + taut * u3yRow[x]) / ng3; if (use_gamma) p32Row[x] = (p32Row[x] + taut * u3yRow[x]) / ng3;
} }
} }
} }
@ -1165,7 +1165,7 @@ void estimateDualVariables(const Mat_<float>& u1x, const Mat_<float>& u1y,
body.p31 = p31; body.p31 = p31;
body.p32 = p32; body.p32 = p32;
body.taut = taut; body.taut = taut;
body.use_gamma = use_gamma; body.use_gamma = use_gamma;
parallel_for_(Range(0, u1x.rows), body); parallel_for_(Range(0, u1x.rows), body);
} }
@ -1283,21 +1283,21 @@ void OpticalFlowDual_TVL1::procOneScale(const Mat_<float>& I0, const Mat_<float>
Mat_<float> v1 = dm.v1_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> v1 = dm.v1_buf(Rect(0, 0, I0.cols, I0.rows));
Mat_<float> v2 = dm.v2_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> v2 = dm.v2_buf(Rect(0, 0, I0.cols, I0.rows));
Mat_<float> v3 = dm.v3_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> v3 = dm.v3_buf(Rect(0, 0, I0.cols, I0.rows));
Mat_<float> p11 = dm.p11_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> p11 = dm.p11_buf(Rect(0, 0, I0.cols, I0.rows));
Mat_<float> p12 = dm.p12_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> p12 = dm.p12_buf(Rect(0, 0, I0.cols, I0.rows));
Mat_<float> p21 = dm.p21_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> p21 = dm.p21_buf(Rect(0, 0, I0.cols, I0.rows));
Mat_<float> p22 = dm.p22_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> p22 = dm.p22_buf(Rect(0, 0, I0.cols, I0.rows));
Mat_<float> p31 = dm.p31_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> p31 = dm.p31_buf(Rect(0, 0, I0.cols, I0.rows));
Mat_<float> p32 = dm.p32_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> p32 = dm.p32_buf(Rect(0, 0, I0.cols, I0.rows));
p11.setTo(Scalar::all(0)); p11.setTo(Scalar::all(0));
p12.setTo(Scalar::all(0)); p12.setTo(Scalar::all(0));
p21.setTo(Scalar::all(0)); p21.setTo(Scalar::all(0));
p22.setTo(Scalar::all(0)); p22.setTo(Scalar::all(0));
bool use_gamma = gamma != 0.; bool use_gamma = gamma != 0.;
if (use_gamma) p31.setTo(Scalar::all(0)); if (use_gamma) p31.setTo(Scalar::all(0));
if (use_gamma) p32.setTo(Scalar::all(0)); if (use_gamma) p32.setTo(Scalar::all(0));
Mat_<float> div_p1 = dm.div_p1_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> div_p1 = dm.div_p1_buf(Rect(0, 0, I0.cols, I0.rows));
Mat_<float> div_p2 = dm.div_p2_buf(Rect(0, 0, I0.cols, I0.rows)); Mat_<float> div_p2 = dm.div_p2_buf(Rect(0, 0, I0.cols, I0.rows));
@ -1333,20 +1333,20 @@ void OpticalFlowDual_TVL1::procOneScale(const Mat_<float>& I0, const Mat_<float>
for (int n_inner = 0; error > scaledEpsilon && n_inner < innerIterations; ++n_inner) for (int n_inner = 0; error > scaledEpsilon && n_inner < innerIterations; ++n_inner)
{ {
// estimate the values of the variable (v1, v2) (thresholding operator TH) // estimate the values of the variable (v1, v2) (thresholding operator TH)
estimateV(I1wx, I1wy, u1, u2, u3, grad, rho_c, v1, v2, v3, l_t, static_cast<float>(gamma)); estimateV(I1wx, I1wy, u1, u2, u3, grad, rho_c, v1, v2, v3, l_t, static_cast<float>(gamma));
// compute the divergence of the dual variable (p1, p2, p3) // compute the divergence of the dual variable (p1, p2, p3)
divergence(p11, p12, div_p1); divergence(p11, p12, div_p1);
divergence(p21, p22, div_p2); divergence(p21, p22, div_p2);
if (use_gamma) divergence(p31, p32, div_p3); if (use_gamma) divergence(p31, p32, div_p3);
// estimate the values of the optical flow (u1, u2) // estimate the values of the optical flow (u1, u2)
error = estimateU(v1, v2, v3, div_p1, div_p2, div_p3, u1, u2, u3, static_cast<float>(theta), static_cast<float>(gamma)); error = estimateU(v1, v2, v3, div_p1, div_p2, div_p3, u1, u2, u3, static_cast<float>(theta), static_cast<float>(gamma));
// compute the gradient of the optical flow (Du1, Du2) // compute the gradient of the optical flow (Du1, Du2)
forwardGradient(u1, u1x, u1y); forwardGradient(u1, u1x, u1y);
forwardGradient(u2, u2x, u2y); forwardGradient(u2, u2x, u2y);
if (use_gamma) forwardGradient(u3, u3x, u3y); if (use_gamma) forwardGradient(u3, u3x, u3y);
// estimate the values of the dual variable (p1, p2, p3) // estimate the values of the dual variable (p1, p2, p3)
estimateDualVariables(u1x, u1y, u2x, u2y, u3x, u3y, p11, p12, p21, p22, p31, p32, taut, use_gamma); estimateDualVariables(u1x, u1y, u2x, u2y, u3x, u3y, p11, p12, p21, p22, p31, p32, taut, use_gamma);

Write Preview
Loading…
Cancel
Save