尝试自己写简单的retinex

#include "opencv2/opencv.hpp"
#include <string>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <algorithm>
using namespace std;
using namespace cv;


//image是原始图像，conv是原始图像加卷积后的图像，deconv是解卷积后的图像
int deconvolution(Mat image,Mat conv,Mat& deconv)
{
int height = image.size().height;
int width = image.size().width;
for (int i=0;i<height;i++)
{
for (int j=0;j<width;j++)
{//0.02,4
deconv.at<float>(i,j) = 0.02*(1.0*image.at<uchar>(i,j)-conv.at<uchar>(i,j)/10.0);
   if (deconv.at<float>(i,j)<0)
   {
//int ttt = conv.at<uchar>(i,j)*0.2;
//printf("1:%d\n",image.at<uchar>(i,j));
//printf("2:%d\n",ttt);
deconv.at<float>(i,j)=0.02*image.at<uchar>(i,j)*0.04;//deconv.at<float>(i,j)*(-1.0);
   }
   
}
}

//double gamma = 1/2.2;
//Mat ss;
//deconv.copyTo(ss);
//cv::pow(ss, gamma, deconv);

//deconv.copyTo(ss);
//cv::pow(ss, 1/1.2, deconv);


double minVal,maxVal;
double minVal1,maxVal1;
cv::Point minLoc,maxLoc;
minMaxLoc( image, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
minMaxLoc( deconv, &minVal1, &maxVal1, &minLoc, &maxLoc, Mat() );


float x = 1.0*maxVal/255;
if(maxVal1>0)
deconv.convertTo(deconv,-1 , 1.0f/maxVal1, 0);





return 0;
}


int convolution(Mat image,Mat kernels,Mat& convolutioned)
{
filter2D(image,convolutioned,image.depth(),kernels);


convertScaleAbs(convolutioned,convolutioned);


return 0;
}


int demin(Mat image,Mat& demined,double mins)
{
//double minVal,maxVal;
//cv::Point minLoc,maxLoc;
//minMaxLoc( image, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
image.convertTo(image,CV_32FC1,1.0,0);
Mat subs(image.size(),CV_32FC1);
subs.setTo(mins);
printf("00:%f\n",subs.at<float>(0,0));
//subs = cv::Scalar::all(mins);
cv::log(subs,subs);
cv::log(image,image);

cv::subtract(image,subs,demined);
convertScaleAbs(demined,demined);
demined.convertTo(demined,CV_32FC1,1.0,0);
cv::exp(demined,demined);


double minVal,maxVal;
cv::Point minLoc,maxLoc;
minMaxLoc( demined, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
demined.convertTo(demined,CV_8UC1,1.0/maxVal,0);
return 0;
}


int demin_sig(Mat image,Mat& demined)
{
double minVal,maxVal;
cv::Point minLoc,maxLoc;
minMaxLoc( image, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
Mat subs(image.size(),image.type());
subs = cv::Scalar::all(minVal);
cv::subtract(image,subs,demined);
convertScaleAbs(demined,demined);


return 0;
}
int mymultiply(Mat image1,double coef,Mat& image)
{
image1.convertTo(image1,CV_32FC1);
Mat image2(image1.size(),image1.type());
image2.setTo(coef);
multiply(image1,image2,image);
convertScaleAbs(image,image);
image.convertTo(image,CV_8UC1);
return 0;
}


int demin_value(Mat image,double& mins)
{
double minVal,maxVal;
cv::Point minLoc,maxLoc;
minMaxLoc( image, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
mins = minVal;
/*Mat subs(image.size(),image.type());
subs = cv::Scalar::all(minVal);
cv::subtract(image,subs,demined);
convertScaleAbs(demined,demined);*/


return 0;
}


void main()
{
Mat rgb = imread("oo.jpg");
//cvtColor(rgb,rgb,COLOR_RGB2HSV);
Mat vec[3];
Mat vec1[3];
Mat vec2[3];
vector<Mat> mat_vec;
split(rgb,vec1);
//cvtColor(rgb,rgb,COLOR_HSV2RGB);

vec2[0] = vec1[0];
mymultiply(vec1[1],1.05,vec2[1]);
mymultiply(vec1[2],1.07,vec2[2]);
mat_vec.push_back(vec2[0]);
mat_vec.push_back(vec2[1]);
mat_vec.push_back(vec2[2]);
Mat sss;
cv::merge(mat_vec,sss);
vec[0] = vec2[0];
vec[1] = vec2[1];
vec[2] = vec2[2];
mat_vec.clear();
imshow("sss",sss);
waitKey(0);
/*double mins,mins0,mins1,mins2;
demin_value(vec1[0],mins0);
demin_value(vec1[1],mins1);
demin_value(vec1[2],mins2);


mins = mins0>mins1?mins1:mins0;
mins = mins>mins2?mins2:mins;


demin(vec1[0],vec2[0],mins);
demin(vec1[1],vec2[1],mins);
demin(vec1[2],vec2[2],mins);
Mat demins;
mat_vec.push_back(vec2[0]);
mat_vec.push_back(vec2[1]);
mat_vec.push_back(vec2[2]);
cv::merge(mat_vec,demins);
imshow("rgb",rgb);
imshow("demins",demins);
waitKey(0);*/
Mat pro0(vec[0].size(),CV_32FC1),pro1(vec[0].size(),CV_32FC1),pro2(vec[0].size(),CV_32FC1);


Mat kern=(Mat_<char>(5,5)<<0,0,1,0,0,
                      0,1,2,1,0,
                      1,2,0,2,1,
                      0,1,2,1,0,
                      0,0,1,0,0);


/*Mat kern=(Mat_<char>(3,3)<<0,1,0,
1,0,1,
0,1,0);*/
/*Mat kern=(Mat_<char>(3,3)<<-1,-1,-1,
-1,18,-1,
-1,-1,-1);*/


/*filter2D(vec[0],pro,vec[0].depth(),kern);


convertScaleAbs(pro,pro);*/
convolution(vec[0],kern,pro0);
convolution(vec[1],kern,pro1);
convolution(vec[2],kern,pro2);


Mat deconv0(pro0.size(),CV_32FC1);
Mat deconv1(pro0.size(),CV_32FC1);
Mat deconv2(pro0.size(),CV_32FC1);


deconvolution(vec[0],pro0,deconv0);
deconvolution(vec[1],pro1,deconv1);
deconvolution(vec[2],pro2,deconv2);


vector<Mat> new_vecs;
new_vecs.push_back(deconv0);
new_vecs.push_back(deconv1);
new_vecs.push_back(deconv2);
//new_vecs[0] = deconv0;
//new_vecs[1] = deconv1;
//new_vecs[2] = deconv2;


Mat news;
cv::merge(new_vecs,news);
imshow("pro0",pro0);
imshow("vec[0]",vec[0]);
imshow("chan 0",deconv0);
imshow("chan 1",deconv1);
imshow("chan 2",deconv2);
imshow("original",rgb);
imshow("recovered de",news);
news.convertTo(news,CV_8UC3,255,0);
imwrite("3221.jpg",news);
    Mat hsv;
cvtColor(news,hsv,COLOR_BGR2YUV);
Mat spiltss[3];
split(hsv,spiltss);
imshow("spiltss",spiltss[0]);
double gamma = 1/1.2;
Mat ss,ss1;
spiltss[0].copyTo(ss);
ss.convertTo(ss,CV_32FC1,1.0/255,0);
cv::pow(ss, gamma, ss1);
ss1.convertTo(ss1,CV_8UC1,255,0);


double minVal,maxVal;
cv::Point minLoc,maxLoc;
minMaxLoc( ss1, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );


Mat subs(ss1.size(),ss1.type());
subs = cv::Scalar::all(minVal);
Mat demined;
cv::subtract(ss1,subs,demined);
convertScaleAbs(demined,demined);
demined.copyTo(ss1);
imshow("ss1",ss1);
waitKey(0);
spiltss[0] = ss1;
vector<Mat> hvss;
hvss.push_back(spiltss[0]);
hvss.push_back(spiltss[1]);
hvss.push_back(spiltss[2]);
cv::merge(hvss,hsv);
cvtColor(hsv,news,COLOR_YUV2BGR);
imshow("hg",news);
waitKey(0);

}

lliyuanzh@163.com