generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rename stuff, adds logging and replace shitty else if chain by switch

Browse Source
This commit is contained in:
Adrien BAK 2014-09-29 15:49:42 +09:00
parent 1f6acc23fa
commit 33c15d6309
3 changed files with 57 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
modules/photo/src/seamless_cloning.cpp
View File

@ -39,10 +39,15 @@
//
//M*/
#include <string>
#include "precomp.hpp"
#include "opencv2/photo.hpp"
#include "opencv2/highgui.hpp"
#include <stdlib.h>
#include <iostream>
#include "seamless_cloning.hpp"
using namespace std;
@ -87,6 +92,8 @@ void cv::seamlessClone(InputArray _src, InputArray _dst, InputArray _mask, Point
int lenx = maxx - minx;
int leny = maxy - miny;
Mat patch = Mat::zeros(Size(leny, lenx), CV_8UC3);
int minxd = p.y - lenx/2;
int maxxd = p.y + lenx/2;
int minyd = p.x - leny/2;
@ -97,15 +104,26 @@ void cv::seamlessClone(InputArray _src, InputArray _dst, InputArray _mask, Point
Rect roi_d(minyd,minxd,leny,lenx);
Rect roi_s(miny,minx,leny,lenx);
std::cout << "p : " << p.x << "\t"<<p.y<<"\n";
std::cout << "min : " << miny << "\t"<<minx<<"\n";
std::cout << "mind : " << minyd << "\t"<<minxd<<"\n";
Mat destinationROI = dst_mask(roi_d);
Mat sourceROI = cs_mask(roi_s);
gray(roi_s).copyTo(destinationROI);
src(roi_s).copyTo(sourceROI,gray(roi_s));
src(roi_s).copyTo(patch, gray(roi_s));
destinationROI = cd_mask(roi_d);
cs_mask(roi_s).copyTo(destinationROI);
imwrite("/home/adrien/DATA/tmp/dst_mask.png", dst_mask);
imwrite("/home/adrien/DATA/tmp/cs_mask.png", cs_mask);
imwrite("/home/adrien/DATA/tmp/cd_mask.png", cd_mask);
imwrite("/home/adrien/DATA/tmp/patch.png", patch);
Cloning obj;
obj.normal_clone(dest,cd_mask,dst_mask,blend,flags);

13
modules/photo/src/seamless_cloning.hpp
View File

@ -53,7 +53,7 @@ namespace cv
class Cloning
{
public:
void normal_clone(const cv::Mat &I, const cv::Mat &mask, const cv::Mat &wmask, cv::Mat &cloned, int num);
void normal_clone(const cv::Mat& destination, const cv::Mat &mask, const cv::Mat &wmask, cv::Mat &cloned, int flag);
void illum_change(cv::Mat &I, cv::Mat &mask, cv::Mat &wmask, cv::Mat &cloned, float alpha, float beta);
void local_color_change(cv::Mat &I, cv::Mat &mask, cv::Mat &wmask, cv::Mat &cloned, float red_mul, float green_mul, float blue_mul);
void texture_flatten(cv::Mat &I, cv::Mat &mask, cv::Mat &wmask, double low_threshold, double high_threhold, int kernel_size, cv::Mat &cloned);
@ -61,15 +61,11 @@ namespace cv
protected:
void init_var(const cv::Mat &I, const cv::Mat &wmask);
void initialization(const cv::Mat &I, const cv::Mat &mask, const cv::Mat &wmask);
void compute_derivatives(const cv::Mat &I, const cv::Mat &mask, const cv::Mat &wmask);
void scalar_product(cv::Mat mat, float r, float g, float b);
void array_product(cv::Mat mat1, cv::Mat mat2, cv::Mat mat3);
void poisson(const cv::Mat &I, const cv::Mat &gx, const cv::Mat &gy, const cv::Mat &sx, const cv::Mat &sy);
void evaluate(const cv::Mat &I, const cv::Mat &wmask, const cv::Mat &cloned);
void getGradientx(const cv::Mat &img, cv::Mat &gx);
void getGradienty(const cv::Mat &img, cv::Mat &gy);
void lapx(const cv::Mat &img, cv::Mat &gxx);
void lapy(const cv::Mat &img, cv::Mat &gyy);
void dst(double *mod_diff, double *sineTransform,int h,int w);
void idst(double *mod_diff, double *sineTransform,int h,int w);
void transpose(double *mat, double *mat_t,int h,int w);
@ -77,6 +73,11 @@ namespace cv
void poisson_solver(const cv::Mat &img, cv::Mat &gxx , cv::Mat &gyy, cv::Mat &result);
void computeGradientX(const cv::Mat &img, cv::Mat &gx);
void computeGradientY(const cv::Mat &img, cv::Mat &gy);
void computeLaplacianX(const cv::Mat &img, cv::Mat &gxx);
void computeLaplacianY(const cv::Mat &img, cv::Mat &gyy);
private:
std::vector <cv::Mat> rgb_channel, rgbx_channel, rgby_channel, output;
cv::Mat grx, gry, sgx, sgy, srx32, sry32, grx32, gry32, smask, smask1;

60
modules/photo/src/seamless_cloning_impl.cpp
View File

@ -47,7 +47,7 @@ using namespace cv;
using namespace std;
void Cloning::getGradientx( const Mat &img, Mat &gx)
void Cloning::computeGradientX( const Mat &img, Mat &gx)
{
Mat kernel = Mat::zeros(1, 3, CV_8S);
kernel.at<char>(0,2) = 1;
@ -55,7 +55,7 @@ void Cloning::getGradientx( const Mat &img, Mat &gx)
filter2D(img, gx, CV_32F, kernel);
}
void Cloning::getGradienty( const Mat &img, Mat &gy)
void Cloning::computeGradientY( const Mat &img, Mat &gy)
{
Mat kernel = Mat::zeros(3, 1, CV_8S);
kernel.at<char>(2,0) = 1;
@ -63,7 +63,7 @@ void Cloning::getGradienty( const Mat &img, Mat &gy)
filter2D(img, gy, CV_32F, kernel);
}
void Cloning::lapx( const Mat &img, Mat &gxx)
void Cloning::computeLaplacianX( const Mat &img, Mat &gxx)
{
Mat kernel = Mat::zeros(1, 3, CV_8S);
kernel.at<char>(0,0) = -1;
@ -71,7 +71,7 @@ void Cloning::lapx( const Mat &img, Mat &gxx)
filter2D(img, gxx, CV_32F, kernel);
}
void Cloning::lapy( const Mat &img, Mat &gyy)
void Cloning::computeLaplacianY( const Mat &img, Mat &gyy)
{
Mat kernel = Mat::zeros(3, 1, CV_8S);
kernel.at<char>(0,0) = -1;
@ -339,15 +339,15 @@ void Cloning::init_var(const Mat &I, const Mat &wmask)
gry32 = Mat(I.size(),CV_32FC3);
}
void Cloning::initialization(const Mat &I, const Mat &mask, const Mat &wmask)
void Cloning::compute_derivatives(const Mat &I, const Mat &mask, const Mat &wmask)
{
init_var(I,wmask);
getGradientx(I,grx);
getGradienty(I,gry);
computeGradientX(I,grx);
computeGradientY(I,gry);
getGradientx(mask,sgx);
getGradienty(mask,sgy);
computeGradientX(mask,sgx);
computeGradientY(mask,sgy);
Mat Kernel(Size(3, 3), CV_8UC1);
Kernel.setTo(Scalar(1));
@ -392,8 +392,8 @@ void Cloning::poisson(const Mat &I, const Mat &gx, const Mat &gy, const Mat &sx,
Mat gxx = Mat(I.size(),CV_32FC3);
Mat gyy = Mat(I.size(),CV_32FC3);
lapx(fx,gxx);
lapy(fy,gyy);
computeLaplacianX(fx,gxx);
computeLaplacianY(fy,gyy);
split(gxx,rgbx_channel);
split(gyy,rgby_channel);
@ -421,23 +421,23 @@ void Cloning::evaluate(const Mat &I, const Mat &wmask, const Mat &cloned)
merge(output,cloned);
}
void Cloning::normal_clone(const Mat &I, const Mat &mask, const Mat &wmask, Mat &cloned, int num)
void Cloning::normal_clone(const Mat &destination, const Mat &mask, const Mat &wmask, Mat &cloned, int flag)
{
int w = I.size().width;
int h = I.size().height;
int channel = I.channels();
int w = destination.size().width;
int h = destination.size().height;
int channel = destination.channels();
initialization(I,mask,wmask);
compute_derivatives(destination,mask,wmask);
if(num == 1)
switch(flag)
{
case NORMAL_CLONE:
array_product(srx32,sgx,smask);
array_product(sry32,sgy,smask);
break;
}
else if(num == 2)
{
case MIXED_CLONE:
for(int i=0;i < h; i++)
{
@ -464,36 +464,36 @@ void Cloning::normal_clone(const Mat &I, const Mat &mask, const Mat &wmask, Mat
}
}
}
break;
}
else if(num == 3)
{
case MONOCHROME_TRANSFER:
Mat gray = Mat(mask.size(),CV_8UC1);
Mat gray8 = Mat(mask.size(),CV_8UC3);
cvtColor(mask, gray, COLOR_BGR2GRAY );
vector <Mat> temp;
split(I,temp);
split(destination,temp);
gray.copyTo(temp[2]);
gray.copyTo(temp[1]);
gray.copyTo(temp[0]);
merge(temp,gray8);
getGradientx(gray8,sgx);
getGradienty(gray8,sgy);
computeGradientX(gray8,sgx);
computeGradientY(gray8,sgy);
array_product(srx32,sgx,smask);
array_product(sry32,sgy,smask);
break;
}
evaluate(I,wmask,cloned);
evaluate(destination,wmask,cloned);
}
void Cloning::local_color_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float red_mul=1.0,
float green_mul=1.0, float blue_mul=1.0)
{
initialization(I,mask,wmask);
compute_derivatives(I,mask,wmask);
array_product(srx32,sgx,smask);
array_product(sry32,sgy,smask);
@ -505,7 +505,7 @@ void Cloning::local_color_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, flo
void Cloning::illum_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float alpha, float beta)
{
initialization(I,mask,wmask);
compute_derivatives(I,mask,wmask);
array_product(srx32,sgx,smask);
array_product(sry32,sgy,smask);
@ -534,7 +534,7 @@ void Cloning::illum_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float alp
void Cloning::texture_flatten(Mat &I, Mat &mask, Mat &wmask, double low_threshold,
double high_threshold, int kernel_size, Mat &cloned)
{
initialization(I,mask,wmask);
compute_derivatives(I,mask,wmask);
Mat out = Mat(mask.size(),CV_8UC1);
Canny(mask,out,low_threshold,high_threshold,kernel_size);