Skip to content

O
opencv_contrib
Commit 0c691ff0 authored by Zhou Chao's avatar Zhou Chao
Browse files
Options

replace tabs with spaces

parent e5f3571b
Hide whitespace changes
Inline Side-by-side
Showing with 248 additions and 248 deletions
modules/ximgproc/src/l0_smooth.cpp
View file @ 0c691ff0
...@@ -44,133 +44,133 @@ using namespace std; ...@@ -44,133 +44,133 @@ using namespace std;
namespace namespace
{ {
void shift(InputArray src, OutputArray dst, int shift_x, int shift_y) { void shift(InputArray src, OutputArray dst, int shift_x, int shift_y) {
Mat S = src.getMat(); Mat S = src.getMat();
Mat D = dst.getMat(); Mat D = dst.getMat();
if(S.data == D.data){ if(S.data == D.data){
S = S.clone(); S = S.clone();
} }
D.create(S.size(), S.type()); D.create(S.size(), S.type());
Mat s0(S, Rect(0, 0, S.cols - shift_x, S.rows - shift_y)); Mat s0(S, Rect(0, 0, S.cols - shift_x, S.rows - shift_y));
Mat s1(S, Rect(S.cols - shift_x, 0, shift_x, S.rows - shift_y)); Mat s1(S, Rect(S.cols - shift_x, 0, shift_x, S.rows - shift_y));
Mat s2(S, Rect(0, S.rows - shift_y, S.cols-shift_x, shift_y)); Mat s2(S, Rect(0, S.rows - shift_y, S.cols-shift_x, shift_y));
Mat s3(S, Rect(S.cols - shift_x, S.rows- shift_y, shift_x, shift_y)); Mat s3(S, Rect(S.cols - shift_x, S.rows- shift_y, shift_x, shift_y));
Mat d0(D, Rect(shift_x, shift_y, S.cols - shift_x, S.rows - shift_y)); Mat d0(D, Rect(shift_x, shift_y, S.cols - shift_x, S.rows - shift_y));
Mat d1(D, Rect(0, shift_y, shift_x, S.rows - shift_y)); Mat d1(D, Rect(0, shift_y, shift_x, S.rows - shift_y));
Mat d2(D, Rect(shift_x, 0, S.cols-shift_x, shift_y)); Mat d2(D, Rect(shift_x, 0, S.cols-shift_x, shift_y));
Mat d3(D, Rect(0,0,shift_x, shift_y)); Mat d3(D, Rect(0,0,shift_x, shift_y));
s0.copyTo(d0); s0.copyTo(d0);
s1.copyTo(d1); s1.copyTo(d1);
s2.copyTo(d2); s2.copyTo(d2);
s3.copyTo(d3); s3.copyTo(d3);
} }
// dft after padding imaginary // dft after padding imaginary
void fft(InputArray src, OutputArray dst) { void fft(InputArray src, OutputArray dst) {
Mat S = src.getMat(); Mat S = src.getMat();
Mat planes[] = {S, Mat::zeros(S.size(), S.type())}; Mat planes[] = {S, Mat::zeros(S.size(), S.type())};
merge(planes, 2, dst); merge(planes, 2, dst);
// compute the result // compute the result
dft(dst, dst); dft(dst, dst);
} }
void psf2otf(InputArray src, OutputArray dst, int height, int width){ void psf2otf(InputArray src, OutputArray dst, int height, int width){
Mat S = src.getMat(); Mat S = src.getMat();
Mat D = dst.getMat(); Mat D = dst.getMat();
Mat padded; Mat padded;
if(S.data == D.data){ if(S.data == D.data){
S = S.clone(); S = S.clone();
} }
// add padding // add padding
copyMakeBorder(S, padded, 0, height - S.rows, 0, width - S.cols, copyMakeBorder(S, padded, 0, height - S.rows, 0, width - S.cols,
BORDER_CONSTANT, Scalar::all(0)); BORDER_CONSTANT, Scalar::all(0));
shift(padded, padded, width - S.cols / 2, height - S.rows / 2); shift(padded, padded, width - S.cols / 2, height - S.rows / 2);
// convert to frequency domain // convert to frequency domain
fft(padded, dst); fft(padded, dst);
} }
void dftMultiChannel(InputArray src, vector<Mat> &dst){ void dftMultiChannel(InputArray src, vector<Mat> &dst){
Mat S = src.getMat(); Mat S = src.getMat();
split(S, dst); split(S, dst);
for(int i = 0; i < S.channels(); i++){ for(int i = 0; i < S.channels(); i++){
fft(dst[i], dst[i]); fft(dst[i], dst[i]);
} }
} }
void idftMultiChannel(const vector<Mat> &src, OutputArray dst){ void idftMultiChannel(const vector<Mat> &src, OutputArray dst){
Mat *channels = new Mat[src.size()]; Mat *channels = new Mat[src.size()];
for(int i = 0 ; unsigned(i) < src.size(); i++){ for(int i = 0 ; unsigned(i) < src.size(); i++){
idft(src[i], channels[i]); idft(src[i], channels[i]);
Mat realImg[2]; Mat realImg[2];
split(channels[i], realImg); split(channels[i], realImg);
channels[i] = realImg[0] / src[i].cols / src[i].rows; channels[i] = realImg[0] / src[i].cols / src[i].rows;
} }
Mat D; Mat D;
merge(channels, src.size(), D); merge(channels, src.size(), D);
D.copyTo(dst); D.copyTo(dst);
delete[] channels; delete[] channels;
} }
void addComplex(InputArray aSrc, int bSrc, OutputArray dst){ void addComplex(InputArray aSrc, int bSrc, OutputArray dst){
Mat panels[2]; Mat panels[2];
split(aSrc.getMat(), panels); split(aSrc.getMat(), panels);
panels[0] = panels[0] + bSrc; panels[0] = panels[0] + bSrc;
merge(panels, 2, dst); merge(panels, 2, dst);
} }
void divComplexByReal(InputArray aSrc, InputArray bSrc, OutputArray dst){ void divComplexByReal(InputArray aSrc, InputArray bSrc, OutputArray dst){
Mat aPanels[2]; Mat aPanels[2];
Mat bPanels[2]; Mat bPanels[2];
split(aSrc.getMat(), aPanels); split(aSrc.getMat(), aPanels);
split(bSrc.getMat(), bPanels); split(bSrc.getMat(), bPanels);
Mat realPart; Mat realPart;
Mat imaginaryPart; Mat imaginaryPart;
divide(aPanels[0], bSrc.getMat(), realPart); divide(aPanels[0], bSrc.getMat(), realPart);
divide(aPanels[1], bSrc.getMat(), imaginaryPart); divide(aPanels[1], bSrc.getMat(), imaginaryPart);
aPanels[0] = realPart; aPanels[0] = realPart;
aPanels[1] = imaginaryPart; aPanels[1] = imaginaryPart;
Mat rst; Mat rst;
merge(aPanels, 2, dst); merge(aPanels, 2, dst);
} }
void divComplexByRealMultiChannel(const vector<Mat> &numer, void divComplexByRealMultiChannel(const vector<Mat> &numer,
const vector<Mat> &denom, vector<Mat> &dst) const vector<Mat> &denom, vector<Mat> &dst)
{ {
for(int i = 0; unsigned(i) < numer.size(); i++) for(int i = 0; unsigned(i) < numer.size(); i++)
{ {
divComplexByReal(numer[i], denom[i], dst[i]); divComplexByReal(numer[i], denom[i], dst[i]);
} }
} }
// power of 2 of the absolute value of the complex // power of 2 of the absolute value of the complex
Mat pow2absComplex(InputArray src){ Mat pow2absComplex(InputArray src){
Mat S = src.getMat(); Mat S = src.getMat();
Mat sPanels[2]; Mat sPanels[2];
split(S, sPanels); split(S, sPanels);
return sPanels[0].mul(sPanels[0]) + sPanels[1].mul(sPanels[1]); return sPanels[0].mul(sPanels[0]) + sPanels[1].mul(sPanels[1]);
} }
} }
namespace cv namespace cv
...@@ -180,129 +180,129 @@ namespace ximgproc ...@@ -180,129 +180,129 @@ namespace ximgproc
void l0Smooth(InputArray src, OutputArray dst, double lambda, double kappa) void l0Smooth(InputArray src, OutputArray dst, double lambda, double kappa)
{ {
Mat S = src.getMat(); Mat S = src.getMat();
CV_Assert(!S.empty()); CV_Assert(!S.empty());
CV_Assert(S.depth() == CV_8U || S.depth() == CV_16U CV_Assert(S.depth() == CV_8U || S.depth() == CV_16U
|| S.depth() == CV_32F || S.depth() == CV_64F); || S.depth() == CV_32F || S.depth() == CV_64F);
dst.create(src.size(), src.type()); dst.create(src.size(), src.type());
if(S.data == dst.getMat().data){ if(S.data == dst.getMat().data){
S = S.clone(); S = S.clone();
} }
if(S.depth() == CV_8U) if(S.depth() == CV_8U)
{ {
S.convertTo(S, CV_32F, 1/255.0f); S.convertTo(S, CV_32F, 1/255.0f);
} }
else if(S.depth() == CV_16U) else if(S.depth() == CV_16U)
{ {
S.convertTo(S, CV_32F, 1/65535.0f); S.convertTo(S, CV_32F, 1/65535.0f);
}else if(S.depth() == CV_64F){ }else if(S.depth() == CV_64F){
S.convertTo(S, CV_32F); S.convertTo(S, CV_32F);
} }
const double betaMax = 100000; const double betaMax = 100000;
// gradient operators in frequency domain // gradient operators in frequency domain
Mat otfFx, otfFy; Mat otfFx, otfFy;
float kernel[2] = {-1, 1}; float kernel[2] = {-1, 1};
float kernel_inv[2] = {1,-1}; float kernel_inv[2] = {1,-1};
psf2otf(Mat(1,2,CV_32FC1, kernel_inv), otfFx, S.rows, S.cols); psf2otf(Mat(1,2,CV_32FC1, kernel_inv), otfFx, S.rows, S.cols);
psf2otf(Mat(2,1,CV_32FC1, kernel_inv), otfFy, S.rows, S.cols); psf2otf(Mat(2,1,CV_32FC1, kernel_inv), otfFy, S.rows, S.cols);
vector<Mat> denomConst; vector<Mat> denomConst;
Mat tmp = pow2absComplex(otfFx) + pow2absComplex(otfFy); Mat tmp = pow2absComplex(otfFx) + pow2absComplex(otfFy);
for(int i = 0; i < S.channels(); i++){ for(int i = 0; i < S.channels(); i++){
denomConst.push_back(tmp); denomConst.push_back(tmp);
} }
// input image in frequency domain // input image in frequency domain
vector<Mat> numerConst; vector<Mat> numerConst;
dftMultiChannel(S, numerConst); dftMultiChannel(S, numerConst);
/********************************* /*********************************
* solver * solver
*********************************/ *********************************/
double beta = 2 * lambda; double beta = 2 * lambda;
while(beta < betaMax){ while(beta < betaMax){
// h, v subproblem // h, v subproblem
Mat h, v; Mat h, v;
filter2D(S, h, -1, Mat(1, 2, CV_32FC1, kernel), Point(0, 0), filter2D(S, h, -1, Mat(1, 2, CV_32FC1, kernel), Point(0, 0),
0, BORDER_REPLICATE); 0, BORDER_REPLICATE);
filter2D(S, v, -1, Mat(2, 1, CV_32FC1, kernel), Point(0, 0), filter2D(S, v, -1, Mat(2, 1, CV_32FC1, kernel), Point(0, 0),
0, BORDER_REPLICATE); 0, BORDER_REPLICATE);
Mat hvMag = h.mul(h) + v.mul(v); Mat hvMag = h.mul(h) + v.mul(v);
Mat mask; Mat mask;
if(S.channels() == 1) if(S.channels() == 1)
{ {
threshold(hvMag, mask, lambda/beta, 1, THRESH_BINARY); threshold(hvMag, mask, lambda/beta, 1, THRESH_BINARY);
} }
else if(S.channels() > 1) else if(S.channels() > 1)
{ {
Mat *channels = new Mat[S.channels()]; Mat *channels = new Mat[S.channels()];
split(hvMag, channels); split(hvMag, channels);
hvMag = channels[0]; hvMag = channels[0];
for(int i = 1; i < S.channels(); i++){ for(int i = 1; i < S.channels(); i++){
hvMag = hvMag + channels[i]; hvMag = hvMag + channels[i];
} }
threshold(hvMag, mask, lambda/beta, 1, THRESH_BINARY); threshold(hvMag, mask, lambda/beta, 1, THRESH_BINARY);
Mat in[] = {mask, mask, mask}; Mat in[] = {mask, mask, mask};
merge(in, 3, mask); merge(in, 3, mask);
delete[] channels; delete[] channels;
} }
h = h.mul(mask); h = h.mul(mask);
v = v.mul(mask); v = v.mul(mask);
// S subproblem // S subproblem
vector<Mat> denom(S.channels()); vector<Mat> denom(S.channels());
for(int i = 0; i < S.channels(); i++){ for(int i = 0; i < S.channels(); i++){
denom[i] = beta * denomConst[i] + 1; denom[i] = beta * denomConst[i] + 1;
} }
Mat hGrad, vGrad; Mat hGrad, vGrad;
filter2D(h, hGrad, -1, Mat(1, 2, CV_32FC1, kernel_inv)); filter2D(h, hGrad, -1, Mat(1, 2, CV_32FC1, kernel_inv));
filter2D(v, vGrad, -1, Mat(2, 1, CV_32FC1, kernel_inv)); filter2D(v, vGrad, -1, Mat(2, 1, CV_32FC1, kernel_inv));
vector<Mat> hvGradFreq; vector<Mat> hvGradFreq;
dftMultiChannel(hGrad+vGrad, hvGradFreq); dftMultiChannel(hGrad+vGrad, hvGradFreq);
vector<Mat> numer(S.channels()); vector<Mat> numer(S.channels());
for(int i = 0; i < S.channels(); i++){ for(int i = 0; i < S.channels(); i++){
numer[i] = numerConst[i] + hvGradFreq[i] * beta; numer[i] = numerConst[i] + hvGradFreq[i] * beta;
} }
vector<Mat> sFreq(S.channels()); vector<Mat> sFreq(S.channels());
divComplexByRealMultiChannel(numer, denom, sFreq); divComplexByRealMultiChannel(numer, denom, sFreq);
idftMultiChannel(sFreq, S); idftMultiChannel(sFreq, S);
beta = beta * kappa; beta = beta * kappa;
} }
Mat D = dst.getMat(); Mat D = dst.getMat();
if(D.depth() == CV_8U) if(D.depth() == CV_8U)
{ {
S.convertTo(D, CV_8U, 255); S.convertTo(D, CV_8U, 255);
} }
else if(D.depth() == CV_16U) else if(D.depth() == CV_16U)
{ {
S.convertTo(D, CV_16U, 65535); S.convertTo(D, CV_16U, 65535);
}else if(D.depth() == CV_64F){ }else if(D.depth() == CV_64F){
S.convertTo(D, CV_64F); S.convertTo(D, CV_64F);
}else{ }else{
S.copyTo(D); S.copyTo(D);
} }
} }
} }
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment