图像修复-CDD修复模型
原理：
C++代码（灰度图像）：
//CDD Inpaint
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <time.h>
using namespace cv;
using namespace std;
enum { PIXEL_WHITE = 1 };
typedef struct coord
{
int i;
int j;
int color;
}Coord;
std::vector<Coord> create_mask(cv::Mat& mask);
void CDD_GRAY(
cv::Mat& input_array, std::vector<Coord>& mask_array, cv::Mat& output_array,
int* total_iters, int total_stages, float* lambdas, float* as);
int main(int argc, char* argv[])
{
cv::Mat output_array;
/* Create the windows */
cv::namedWindow("1", cv::WINDOW_AUTOSIZE);
cv::namedWindow("2", cv::WINDOW_AUTOSIZE);
cv::namedWindow("3", cv::WINDOW_AUTOSIZE);
/* Load and normalize the image */
cv::Mat image_array = cv::imread("CDD.png");
image_array.convertTo(image_array, CV_32FC1);
cv::cvtColor(image_array, image_array, cv::COLOR_BGR2GRAY);
cv::normalize(image_array, image_array, 0, 1, cv::NORM_MINMAX, CV_32FC1);
cv::imshow("1", image_array);
/* Load the mask and fill the vector*/
cv::Mat mask_array = cv::imread("1.png");
std::vector<Coord> mask_data = create_mask(mask_array);
/*
CDD PDE Inpainting.
*/
int total_iters[] = { 6000 };
int total_stages = 2;
float lambdas[] = { 0.2 };
float as[] = { 0.5 };
CDD_GRAY(image_array, mask_data, output_array, total_iters, total_stages, lambdas, as);
cv::normalize(output_array, output_array, 0, 255.0, cv::NORM_MINMAX, CV_8UC1);
output_array.convertTo(output_array, CV_8UC1);
/* Display the output */
cv::imshow("2", mask_array);
cv::imshow("3", output_array);
cv::waitKey(0);
}
void CDD_GRAY(
cv::Mat& input_array, std::vector<Coord>& mask_array, cv::Mat& output_array,
int* total_iters, int total_stages, float* lambdas, float* as)
{
typedef unsigned char logical_type;
//初始化输出图像
input_array.copyTo(output_array);
//掩模图像的大小
int size_mask = mask_array.size();
//在每个stage计算CDD
for (int stage = 0; stage < total_stages; stage++)
{
int total_iter = total_iters[stage];
float lambda = lambdas[stage];
float a = as[stage];
float UO, UN, UW, US, UE, UNE, UNW, USW, USE;
float Un, Ue, Uw, Us;
float Wn, We, Ww, Ws;
float Hon, Hoe, How, Hos;
float Hoo;
float Kn, Ke, Kw, Ks;
float grad_E1, grad_O1, grad_W1, grad_S2, grad_N2, grad_O2;
float grad_NE2, grad_NW1, grad_SW2, grad_SE2, grad_NE1, grad_NW2, grad_SE1, grad_SW1;
float UNW1, UNW2,UNW3, UN2, UNE1, UNE2, UNE3,UE2, UW2, US2, USE1, USE2,USE3, USW1, USW2,USW3;
//算法运行
for (int iter = 0; iter < total_iter; iter++)
{
for (int cont = 0; cont < size_mask; cont++)
{
Coord coord = mask_array.at(cont);
int row = coord.i;
int col = coord.j;
UO = input_array.at<float>(row, col);
UW = input_array.at<float>(row - 1, col);
UE = input_array.at<float>(row + 1, col);
UN = input_array.at<float>(row, col + 1);
US = input_array.at<float>(row, col - 1);
UNW = input_array.at<float>(row - 1, col + 1);
USW = input_array.at<float>(row - 1, col - 1);
UNE = input_array.at<float>(row + 1, col + 1);
USE = input_array.at<float>(row + 1, col - 1);
UE2 = input_array.at<float>(row + 2, col);
UW2 = input_array.at<float>(row - 2, col);
US2 = input_array.at<float>(row, col - 2);
UN2 = input_array.at<float>(row, col + 2);
UNW1 = input_array.at<float>(row - 2, col + 1);
UNW2 = input_array.at<float>(row - 1, col + 2);
UNW3 = input_array.at<float>(row - 2, col + 2);
UNE1 = input_array.at<float>(row + 1, col + 2);
UNE2 = input_array.at<float>(row + 2, col + 1);
UNE3 = input_array.at<float>(row + 2, col + 2);
USE1 = input_array.at<float>(row + 2, col - 1);
USE2 = input_array.at<float>(row + 1, col - 2);
USE3 = input_array.at<float>(row + 2, col - 2);
USW1 = input_array.at<float>(row - 1, col - 2);
USW2 = input_array.at<float>(row - 2, col - 1);
USW3 = input_array.at<float>(row - 2, col - 2);
grad_O1 = ((UE - UO) / sqrt((UE - UO) * (UE - UO) + ((UNE - USE) / 2.0) * ((UNE - USE) / 2.0) + a * a)) - ((UW - UO) / sqrt((UW - UO) * (UW - UO) + ((UNW - USW) / 2.0) * ((UNW - USW) / 2.0) + a * a));
grad_E1 = ((UE2 - UE) / sqrt((UE2 - UE) * (UE2 - UE) + ((UNE2 - USE1) / 2.0) * ((UNE2 - USE1) / 2.0) + a * a)) - ((UO - UE) / sqrt((UO - UE) * (UO - UE) + ((UN - US) / 2.0) * ((UN - US) / 2.0) + a * a));
grad_W1 = ((UO - UW) / sqrt((UO - UW) * (UO - UW) + ((UN - US) / 2.0) * ((UN - US) / 2.0) + a * a)) - ((UW2 - UW) / sqrt((UW2 - UW) * (UW2 - UW) + ((UNW1 - USW2) / 2.0) * ((UNW1 - USW2) / 2.0) + a * a));
grad_NW1 = ((UN - UNW) / sqrt((UN - UNW) * (UN - UNW) + ((UN2 - UO) / 2.0) * ((UN2 - UO) / 2.0) + a * a)) - ((UNW1 - UNW) / sqrt((UNW1 - UNW) * (UNW1 - UNW) + ((UNW3 - UW2) / 2.0) * ((UNW3 - UW2) / 2.0) + a * a));
grad_SW1 = ((US - USW) / sqrt((US - USW) * (US - USW) + ((UO - US2) / 2.0) * ((UO - US2) / 2.0) + a * a)) - ((USW2 - USW) / sqrt((USW2 - USW) * (USW2 - USW) + ((UW2 - USW3) / 2.0) * ((UW2 - USW3) / 2.0) + a * a));
grad_NE1 = ((UNE2 - UNE) / sqrt((UNE2 - UNE) * (UNE2 - UNE) + ((UNE3 - UE2) / 2.0) * ((UNE3 - UE2) / 2.0) + a * a)) - ((UN - UNE) / sqrt((UN - UNE) * (UN - UNE) + ((UN2 - UO) / 2.0) * ((UN2 - UO) / 2.0) + a * a));
grad_SE1 = ((USE1 - USE) / sqrt((USE1 - USE) * (USE1 - USE) + ((UE2 - USE3) / 2.0) * ((UE2 - USE3) / 2.0) + a * a)) - ((US - USE) / sqrt((US - USE) * (US - USE) + ((UO - US2) / 2.0) * ((UO - US2) / 2.0) + a * a));
grad_O2 = ((UN - UO) / sqrt((UN - UO) * (UN - UO) + ((UNE - UNW) / 2.0) * ((UNE - UNW) / 2.0) + a * a)) - ((US - UO) / sqrt((US - UO) * (US - UO) + ((USE - USW) / 2.0) * ((USE - USW) / 2.0) + a * a));
grad_S2 = ((UO - US) / sqrt((UO - US) * (UO - US) + ((UE - UW) / 2.0) * ((UE - UW) / 2.0) + a * a)) - ((US2 - US) / sqrt((US2 - US) * (US2 - US) + ((USE2 - USW1) / 2.0) * ((USE2 - USW1) / 2.0) + a * a));
grad_N2 = ((UN2 - UN) / sqrt((UN2 - UN) * (UN2 - UN) + ((UNE1 - UNW2) / 2.0) * ((UNE1 - UNW2) / 2.0) + a * a)) - ((UO - UN) / sqrt((UO - UN) * (UO - UN) + ((UE - UW) / 2.0) * ((UE - UW) / 2.0) + a * a));
grad_NW2 = ((UNW2 - UNW) / sqrt((UNW2 - UNW) * (UNW2 - UNW) + ((UN2 - UNW3) / 2.0) * ((UN2 - UNW3) / 2.0) + a * a)) - ((UW - UNW) / sqrt((UW - UNW) * (UW - UNW) + ((UO - UW2) / 2.0) * ((UO - UW2) / 2.0) + a * a));
grad_SW2 = ((UW - USW) / sqrt((UW - USW) * (UW - USW) + ((UO - UW2) / 2.0) * ((UO - UW2) / 2.0) + a * a)) - ((USW1 - USW) / sqrt((USW1 - USW) * (USW1 - USW) + ((US2 - USW3) / 2.0) * ((US2 - USW3) / 2.0) + a * a));
grad_NE2 = ((UNE1 - UNE) / sqrt((UNE1 - UNE) * (UNE1 - UNE) + ((UNE3 - UN2) / 2.0) * ((UNE3 - UN2) / 2.0) + a * a)) - ((UE - UNE) / sqrt((UE - UNE) * (UE - UNE) + ((UE2 - UO) / 2.0) * ((UE2 - UO) / 2.0) + a * a));
grad_SE2 = ((UE - USE) / sqrt((UE - USE) * (UE - USE) + ((UE2 - UO) / 2.0) * ((UE2 - UO) / 2.0) + a * a)) - ((USE2 - USE) / sqrt((USE2 - USE) * (USE2 - USE) + ((USE3 - US2) / 2.0) * ((USE3 - US2) / 2.0) + a * a));
Kn = sqrt((grad_N2 - grad_O2) * (grad_N2 - grad_O2) + ((grad_NE1 - grad_NW1) / 2.0) * ((grad_NE1 - grad_NW1) / 2.0));
Ke = sqrt((grad_E1 - grad_O1) * (grad_E1 - grad_O1) + ((grad_NE2 - grad_SE2) / 2.0) * ((grad_NE2 - grad_SE2) / 2.0));
Kw = sqrt((grad_W1 - grad_O1) * (grad_W1 - grad_O1) + ((grad_NW2 - grad_SW2) / 2.0) * ((grad_NW2 - grad_SW2) / 2.0));
Ks = sqrt((grad_S2 - grad_O2) * (grad_S2 - grad_O2) + ((grad_SE1 - grad_SW1) / 2.0) * ((grad_SE1 - grad_SW1) / 2.0));
Un = sqrt((UO - UN) * (UO - UN) + ((UNE - UNW) / 2.0) * ((UNE - UNW) / 2.0));
Ue = sqrt((UO - UE) * (UO - UE) + ((UNE - USE) / 2.0) * ((UNE - USE) / 2.0));
Uw = sqrt((UO - UW) * (UO - UW) + ((UNW - USW) / 2.0) * ((UNW - USW) / 2.0));
Us = sqrt((UO - US) * (UO - US) + ((USE - USW) / 2.0) * ((USE - USW) / 2.0));
Wn = Kn / sqrt(Un * Un + a * a);
We = Ke / sqrt(Ue * Ue + a * a);
Ww = Kw / sqrt(Uw * Uw + a * a);
Ws = Ks / sqrt(Us * Us + a * a);
Hon = Wn / (Wn + We + Ww + Ws + lambda);
Hoe = We / (Wn + We + Ww + Ws + lambda);
How = Ww / (Wn + We + Ww + Ws + lambda);
Hos = Ws / (Wn + We + Ww + Ws + lambda);
Hoo = lambda / (Wn + We + Ww + Ws + lambda);
input_array.at<float>(row, col) = (Hon * UN + Hoe * UE + How * UW + Hos * US + Hoo * UO);
output_array.at<float>(row, col) = input_array.at<float>(row, col);
}
printf("%d\n", iter);
}
}
}
/*
Save the inpainting domain to dinamic vector
*/
std::vector<Coord> create_mask(cv::Mat& mask)
{
std::vector<Coord> mask_data;
for (int i = 2; i < mask.rows - 2; i++)
{
for (int j = 2; j < mask.cols - 2; j++)
{
if (mask.at<cv::Vec3b>(i, j)[0] != 0)
{
Coord xy;
xy.i = i;
xy.j = j;
xy.color = PIXEL_WHITE;
mask_data.push_back(xy);
}
}
}
return mask_data;
}
C++代码（RGB图像）：
//CDD Inpaint
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <time.h>
using namespace cv;
using namespace std;
enum { PIXEL_WHITE = 1 };
typedef struct coord
{
int i;
int j;
int color;
}Coord;
std::vector<Coord> create_mask(cv::Mat& mask);
void CDD_RGB(
cv::Mat& input_array, std::vector<Coord>& mask_array, cv::Mat& output_array,
int* total_iters, int total_stages, float* lambdas, float* as);
int main(int argc, char* argv[])
{
cv::Mat output_array;
/* Create the windows */
cv::namedWindow("1", cv::WINDOW_AUTOSIZE);
cv::namedWindow("2", cv::WINDOW_AUTOSIZE);
cv::namedWindow("3", cv::WINDOW_AUTOSIZE);
/* Load and normalize the image */
cv::Mat image_array = cv::imread("CDD3.png");
cv::imshow("1", image_array);
image_array.convertTo(image_array, CV_32FC3);
cv::normalize(image_array, image_array, 0, 1, cv::NORM_MINMAX, CV_32FC3);
/* Load the mask and fill the vector*/
cv::Mat mask_array = cv::imread("1.png");
std::vector<Coord> mask_data = create_mask(mask_array);
/*
CDD PDE Inpainting.
*/
int total_iters[] = { 6000 };
int total_stages = 2;
float lambdas[] = { 0.2 };
float as[] = { 0.5 };
double t = getTickCount();//当前滴答数
CDD_RGB(image_array, mask_data, output_array, total_iters, total_stages, lambdas, as);
t = ((double)getTickCount() - t) / getTickFrequency();
printf("算法用时：%f秒\n", t);
cv::normalize(output_array, output_array, 0, 255.0, cv::NORM_MINMAX, CV_8UC3);
output_array.convertTo(output_array, CV_8UC3);
imwrite("resjsj.png", output_array);
/* Display the output */
cv::imshow("2", mask_array);
cv::imshow("3", output_array);
cv::waitKey(0);
}
void CDD_RGB(
cv::Mat& input_array, std::vector<Coord>& mask_array, cv::Mat& output_array,
int* total_iters, int total_stages, float* lambdas, float* as)
{
typedef unsigned char logical_type;
//初始化输出图像
input_array.copyTo(output_array);
//掩模图像的大小
int size_mask = mask_array.size();
//在每个stage计算CDD
for (int stage = 0; stage < total_stages; stage++)
{
int total_iter = total_iters[stage];
float lambda = lambdas[stage];
float a = as[stage];
float UO1,UO2,UO3,UN1,UN2,UN3,UW1,UW2,UW3,US1,US2,US3,UE1,UE2,UE3,UNE1,UNE2,UNE3,UNW1,UNW2,UNW3,USW1,USW2,USW3,USE1,USE2,USE3;
float Un1, Ue1, Uw1, Us1, Un2, Ue2, Uw2, Us2, Un3, Ue3, Uw3, Us3;
float Wn1, We1, Ww1, Ws1, Wn2, We2, Ww2, Ws2, Wn3, We3, Ww3, Ws3;
float Hon1, Hoe1, How1, Hos1, Hon2, Hoe2, How2, Hos2, Hon3, Hoe3, How3, Hos3;
float Hoo1,Hoo2,Hoo3;
float Kn1, Ke1, Kw1, Ks1, Kn2, Ke2, Kw2, Ks2, Kn3, Ke3, Kw3, Ks3;
float grad_E11, grad_O11, grad_W11, grad_S21, grad_N21, grad_O21;
float grad_NE21, grad_NW11, grad_SW21, grad_SE21, grad_NE11, grad_NW21, grad_SE11, grad_SW11;
float UNW11, UNW21, UN21, UNE11, UNE21, UE21, UW21, US21, USE11, USE21, USW11, USW21;
float grad_E12, grad_O12, grad_W12, grad_S22, grad_N22, grad_O22;
float grad_NE22, grad_NW12, grad_SW22, grad_SE22, grad_NE12, grad_NW22, grad_SE12, grad_SW12;
float UNW12, UNW22, UN22, UNE12, UNE22, UE22, UW22, US22, USE12, USE22, USW12, USW22;
float grad_E13, grad_O13, grad_W13, grad_S23, grad_N23, grad_O23;
float grad_NE23, grad_NW13, grad_SW23, grad_SE23, grad_NE13, grad_NW23, grad_SE13, grad_SW13;
float UNW13, UNW23, UN23, UNE13, UNE23, UE23, UW23, US23, USE13, USE23, USW13, USW23;
float UNW31, UNW32, UNW33, UNE31, UNE32, UNE33, USW31, USW32, USW33, USE31, USE32, USE33;
//算法运行
for (int iter = 0; iter < total_iter; iter++)
{
for (int cont = 0; cont < size_mask; cont++)
{
Coord coord = mask_array.at(cont);
int row = coord.i;
int col = coord.j;
UO1 = input_array.at<cv::Vec3f>(row, col)[0];
UO2 = input_array.at<cv::Vec3f>(row, col)[1];
UO3 = input_array.at<cv::Vec3f>(row, col)[2];
UW1 = input_array.at<cv::Vec3f>(row - 1, col)[0];
UW2 = input_array.at<cv::Vec3f>(row - 1, col)[1];
UW3 = input_array.at<cv::Vec3f>(row - 1, col)[2];
UE1 = input_array.at<cv::Vec3f>(row + 1, col)[0];
UE2 = input_array.at<cv::Vec3f>(row + 1, col)[1];
UE3 = input_array.at<cv::Vec3f>(row + 1, col)[2];
UN1 = input_array.at<cv::Vec3f>(row, col + 1)[0];
UN2 = input_array.at<cv::Vec3f>(row, col + 1)[1];
UN3 = input_array.at<cv::Vec3f>(row, col + 1)[2];
US1 = input_array.at<cv::Vec3f>(row, col - 1)[0];
US2 = input_array.at<cv::Vec3f>(row, col - 1)[1];
US3 = input_array.at<cv::Vec3f>(row, col - 1)[2];
UNW1 = input_array.at<cv::Vec3f>(row - 1, col + 1)[0];
UNW2 = input_array.at<cv::Vec3f>(row - 1, col + 1)[1];
UNW3 = input_array.at<cv::Vec3f>(row - 1, col + 1)[2];
USW1 = input_array.at<cv::Vec3f>(row - 1, col - 1)[0];
USW2 = input_array.at<cv::Vec3f>(row - 1, col - 1)[1];
USW3 = input_array.at<cv::Vec3f>(row - 1, col - 1)[2];
UNE1 = input_array.at<cv::Vec3f>(row + 1, col + 1)[0];
UNE2 = input_array.at<cv::Vec3f>(row + 1, col + 1)[1];
UNE3 = input_array.at<cv::Vec3f>(row + 1, col + 1)[2];
USE1 = input_array.at<cv::Vec3f>(row + 1, col - 1)[0];
USE2 = input_array.at<cv::Vec3f>(row + 1, col - 1)[1];
USE3 = input_array.at<cv::Vec3f>(row + 1, col - 1)[2];
UNW11 = input_array.at<cv::Vec3f>(row - 2, col + 1)[0];
UNW12 = input_array.at<cv::Vec3f>(row - 2, col + 1)[1];
UNW13 = input_array.at<cv::Vec3f>(row - 2, col + 1)[2];
UNW21 = input_array.at<cv::Vec3f>(row - 1, col + 2)[0];
UNW22 = input_array.at<cv::Vec3f>(row - 1, col + 2)[1];
UNW23 = input_array.at<cv::Vec3f>(row - 1, col + 2)[2];
UNW31 = input_array.at<cv::Vec3f>(row - 2, col + 2)[0];
UNW32 = input_array.at<cv::Vec3f>(row - 2, col + 2)[1];
UNW33 = input_array.at<cv::Vec3f>(row - 2, col + 2)[2];
UN21 = input_array.at<cv::Vec3f>(row, col + 2)[0];
UN22 = input_array.at<cv::Vec3f>(row, col + 2)[1];
UN23 = input_array.at<cv::Vec3f>(row, col + 2)[2];
UNE11 = input_array.at<cv::Vec3f>(row + 1, col + 2)[0];
UNE12 = input_array.at<cv::Vec3f>(row + 1, col + 2)[1];
UNE13 = input_array.at<cv::Vec3f>(row + 1, col + 2)[2];
UNE21 = input_array.at<cv::Vec3f>(row + 2, col + 1)[0];
UNE22 = input_array.at<cv::Vec3f>(row + 2, col + 1)[1];
UNE23 = input_array.at<cv::Vec3f>(row + 2, col + 1)[2];
UNE31 = input_array.at<cv::Vec3f>(row + 2, col + 2)[0];
UNE32 = input_array.at<cv::Vec3f>(row + 2, col + 2)[1];
UNE33 = input_array.at<cv::Vec3f>(row + 2, col + 2)[2];
UE21 = input_array.at<cv::Vec3f>(row + 2, col)[0];
UE22 = input_array.at<cv::Vec3f>(row + 2, col)[1];
UE23 = input_array.at<cv::Vec3f>(row + 2, col)[2];
UW21 = input_array.at<cv::Vec3f>(row - 2, col)[0];
UW22 = input_array.at<cv::Vec3f>(row - 2, col)[1];
UW23 = input_array.at<cv::Vec3f>(row - 2, col)[2];
US21 = input_array.at<cv::Vec3f>(row, col - 2)[0];
US22 = input_array.at<cv::Vec3f>(row, col - 2)[1];
US23 = input_array.at<cv::Vec3f>(row, col - 2)[2];
USE11 = input_array.at<cv::Vec3f>(row + 2, col - 1)[0];
USE12 = input_array.at<cv::Vec3f>(row + 2, col - 1)[1];
USE13 = input_array.at<cv::Vec3f>(row + 2, col - 1)[2];
USE21 = input_array.at<cv::Vec3f>(row + 1, col - 2)[0];
USE22 = input_array.at<cv::Vec3f>(row + 1, col - 2)[1];
USE23 = input_array.at<cv::Vec3f>(row + 1, col - 2)[2];
USE31 = input_array.at<cv::Vec3f>(row + 2, col - 2)[0];
USE32 = input_array.at<cv::Vec3f>(row + 2, col - 2)[1];
USE33 = input_array.at<cv::Vec3f>(row + 2, col - 2)[2];
USW11 = input_array.at<cv::Vec3f>(row - 1, col - 2)[0];
USW12 = input_array.at<cv::Vec3f>(row - 1, col - 2)[1];
USW13 = input_array.at<cv::Vec3f>(row - 1, col - 2)[2];
USW21 = input_array.at<cv::Vec3f>(row - 2, col - 1)[0];
USW22 = input_array.at<cv::Vec3f>(row - 2, col - 1)[1];
USW23 = input_array.at<cv::Vec3f>(row - 2, col - 1)[2];
USW31 = input_array.at<cv::Vec3f>(row - 2, col - 2)[0];
USW32 = input_array.at<cv::Vec3f>(row - 2, col - 2)[1];
USW33 = input_array.at<cv::Vec3f>(row - 2, col - 2)[2];
grad_O11 = ((UE1 - UO1) / sqrt((UE1 - UO1) * (UE1 - UO1) + ((UNE1 - USE1) / 2.0) * ((UNE1 - USE1) / 2.0) + a * a)) - ((UW1 - UO1) / sqrt((UW1 - UO1) * (UW1 - UO1) + ((UNW1 - USW1) / 2.0) * ((UNW1 - USW1) / 2.0) + a * a));
grad_E11 = ((UE21 - UE1) / sqrt((UE21 - UE1) * (UE21 - UE1) + ((UNE21 - USE11) / 2.0) * ((UNE21 - USE11) / 2.0) + a * a)) - ((UO1 - UE1) / sqrt((UO1 - UE1) * (UO1 - UE1) + ((UN1 - US1) / 2.0) * ((UN1 - US1) / 2.0) + a * a));
grad_W11 = ((UO1 - UW1) / sqrt((UO1 - UW1) * (UO1 - UW1) + ((UN1 - US1) / 2.0) * ((UN1 - US1) / 2.0) + a * a)) - ((UW21 - UW1) / sqrt((UW21 - UW1) * (UW21 - UW1) + ((UNW11 - USW21) / 2.0) * ((UNW11 - USW21) / 2.0) + a * a));
grad_NW11 = ((UN1 - UNW1) / sqrt((UN1 - UNW1) * (UN1 - UNW1) + ((UN21 - UO1) / 2.0) * ((UN21 - UO1) / 2.0) + a * a)) - ((UNW11 - UNW1) / sqrt((UNW11 - UNW1) * (UNW11 - UNW1) + ((UNW31 - UW21) / 2.0) * ((UNW31 - UW21) / 2.0) + a * a));
grad_SW11 = ((US1 - USW1) / sqrt((US1 - USW1) * (US1 - USW1) + ((UO1 - US21) / 2.0) * ((UO1 - US21) / 2.0) + a * a)) - ((USW21 - USW1) / sqrt((USW21 - USW1) * (USW21 - USW1) + ((UW21 - USW31) / 2.0) * ((UW21 - USW31) / 2.0) + a * a));
grad_NE11 = ((UNE21 - UNE1) / sqrt((UNE21 - UNE1) * (UNE21 - UNE1) + ((UNE31 - UE21) / 2.0) * ((UNE31 - UE21) / 2.0) + a * a)) - ((UN1 - UNE1) / sqrt((UN1 - UNE1) * (UN1 - UNE1) + ((UN21 - UO1) / 2.0) * ((UN21 - UO1) / 2.0) + a * a));
grad_SE11 = ((USE11 - USE1) / sqrt((USE11 - USE1) * (USE11 - USE1) + ((UE21 - USE31) / 2.0) * ((UE21 - USE31) / 2.0) + a * a)) - ((US1 - USE1) / sqrt((US1 - USE1) * (US1 - USE1) + ((UO1 - US21) / 2.0) * ((UO1 - US21) / 2.0) + a * a));
grad_O21 = ((UN1 - UO1) / sqrt((UN1 - UO1) * (UN1 - UO1) + ((UNE1 - UNW1) / 2.0) * ((UNE1 - UNW1) / 2.0) + a * a)) - ((US1 - UO1) / sqrt((US1 - UO1) * (US1 - UO1) + ((USE1 - USW1) / 2.0) * ((USE1 - USW1) / 2.0) + a * a));
grad_S21 = ((UO1 - US1) / sqrt((UO1 - US1) * (UO1 - US1) + ((UE1 - UW1) / 2.0) * ((UE1 - UW1) / 2.0) + a * a)) - ((US21 - US1) / sqrt((US21 - US1) * (US21 - US1) + ((USE21 - USW11) / 2.0) * ((USE21 - USW11) / 2.0) + a * a));
grad_N21 = ((UN21 - UN1) / sqrt((UN21 - UN1) * (UN21 - UN1) + ((UNE11 - UNW21) / 2.0) * ((UNE11 - UNW21) / 2.0) + a * a)) - ((UO1 - UN1) / sqrt((UO1 - UN1) * (UO1 - UN1) + ((UE1 - UW1) / 2.0) * ((UE1 - UW1) / 2.0) + a * a));
grad_NW21 = ((UNW21 - UNW1) / sqrt((UNW21 - UNW1) * (UNW21 - UNW1) + ((UN21 - UNW31) / 2.0) * ((UN21 - UNW31) / 2.0) + a * a)) - ((UW1 - UNW1) / sqrt((UW1 - UNW1) * (UW1 - UNW1) + ((UO1 - UW21) / 2.0) * ((UO1 - UW21) / 2.0) + a * a));
grad_SW21 = ((UW1 - USW1) / sqrt((UW1 - USW1) * (UW1 - USW1) + ((UO1 - UW21) / 2.0) * ((UO1 - UW21) / 2.0) + a * a)) - ((USW11 - USW1) / sqrt((USW11 - USW1) * (USW11 - USW1) + ((US21 - USW31) / 2.0) * ((US21 - USW31) / 2.0) + a * a));
grad_NE21 = ((UNE11 - UNE1) / sqrt((UNE11 - UNE1) * (UNE11 - UNE1) + ((UNE31 - UN21) / 2.0) * ((UNE31 - UN21) / 2.0) + a * a)) - ((UE1 - UNE1) / sqrt((UE1 - UNE1) * (UE1 - UNE1) + ((UE21 - UO1) / 2.0) * ((UE21 - UO1) / 2.0) + a * a));
grad_SE21 = ((UE1 - USE1) / sqrt((UE1 - USE1) * (UE1 - USE1) + ((UE21 - UO1) / 2.0) * ((UE21 - UO1) / 2.0) + a * a)) - ((USE21 - USE1) / sqrt((USE21 - USE1) * (USE21 - USE1) + ((USE31 - US21) / 2.0) * ((USE31 - US21) / 2.0) + a * a));
Kn1 = sqrt((grad_N21 - grad_O21) * (grad_N21 - grad_O21) + ((grad_NE11 - grad_NW11) / 2.0) * ((grad_NE11 - grad_NW11) / 2.0));
Ke1 = sqrt((grad_E11 - grad_O11) * (grad_E11 - grad_O11) + ((grad_NE21 - grad_SE21) / 2.0) * ((grad_NE21 - grad_SE21) / 2.0));
Kw1 = sqrt((grad_W11 - grad_O11) * (grad_W11 - grad_O11) + ((grad_NW21 - grad_SW21) / 2.0) * ((grad_NW21 - grad_SW21) / 2.0));
Ks1 = sqrt((grad_S21 - grad_O21) * (grad_S21 - grad_O21) + ((grad_SE11 - grad_SW11) / 2.0) * ((grad_SE11 - grad_SW11) / 2.0));
grad_O12 = ((UE2 - UO2) / sqrt((UE2 - UO2) * (UE2 - UO2) + ((UNE2 - USE2) / 2.0) * ((UNE2 - USE2) / 2.0) + a * a)) - ((UW2 - UO2) / sqrt((UW2 - UO2) * (UW2 - UO2) + ((UNW2 - USW2) / 2.0) * ((UNW2 - USW2) / 2.0) + a * a));
grad_E12 = ((UE22 - UE2) / sqrt((UE22 - UE2) * (UE22 - UE2) + ((UNE22 - USE12) / 2.0) * ((UNE22 - USE12) / 2.0) + a * a)) - ((UO2 - UE2) / sqrt((UO2 - UE2) * (UO2 - UE2) + ((UN2 - US2) / 2.0) * ((UN2 - US2) / 2.0) + a * a));
grad_W12 = ((UO2 - UW2) / sqrt((UO2 - UW2) * (UO2 - UW2) + ((UN2 - US2) / 2.0) * ((UN2 - US2) / 2.0) + a * a)) - ((UW22 - UW2) / sqrt((UW22 - UW2) * (UW22 - UW2) + ((UNW12 - USW22) / 2.0) * ((UNW12 - USW22) / 2.0) + a * a));
grad_NW12 = ((UN2 - UNW2) / sqrt((UN2 - UNW2) * (UN2 - UNW2) + ((UN22 - UO2) / 2.0) * ((UN22 - UO2) / 2.0) + a * a)) - ((UNW12 - UNW2) / sqrt((UNW12 - UNW2) * (UNW12 - UNW2) + ((UNW32 - UW22) / 2.0) * ((UNW32 - UW22) / 2.0) + a * a));
grad_SW12 = ((US2 - USW2) / sqrt((US2 - USW2) * (US2 - USW2) + ((UO2 - US22) / 2.0) * ((UO2 - US22) / 2.0) + a * a)) - ((USW22 - USW2) / sqrt((USW22 - USW2) * (USW22 - USW2) + ((UW22 - USW32) / 2.0) * ((UW22 - USW32) / 2.0) + a * a));
grad_NE12 = ((UNE22 - UNE2) / sqrt((UNE22 - UNE2) * (UNE22 - UNE2) + ((UNE32 - UE22) / 2.0) * ((UNE32 - UE22) / 2.0) + a * a)) - ((UN2 - UNE2) / sqrt((UN2 - UNE2) * (UN2 - UNE2) + ((UN22 - UO2) / 2.0) * ((UN22 - UO2) / 2.0) + a * a));
grad_SE12 = ((USE12 - USE2) / sqrt((USE12 - USE2) * (USE12 - USE2) + ((UE22 - USE32) / 2.0) * ((UE22 - USE32) / 2.0) + a * a)) - ((US2 - USE2) / sqrt((US2 - USE2) * (US2 - USE2) + ((UO2 - US22) / 2.0) * ((UO2 - US22) / 2.0) + a * a));
grad_O22 = ((UN2 - UO2) / sqrt((UN2 - UO2) * (UN2 - UO2) + ((UNE2 - UNW2) / 2.0) * ((UNE2 - UNW2) / 2.0) + a * a)) - ((US2 - UO2) / sqrt((US2 - UO2) * (US2 - UO2) + ((USE2 - USW2) / 2.0) * ((USE2 - USW2) / 2.0) + a * a));
grad_S22 = ((UO2 - US2) / sqrt((UO2 - US2) * (UO2 - US2) + ((UE2 - UW2) / 2.0) * ((UE2 - UW2) / 2.0) + a * a)) - ((US22 - US2) / sqrt((US22 - US2) * (US22 - US2) + ((USE22 - USW12) / 2.0) * ((USE22 - USW12) / 2.0) + a * a));
grad_N22 = ((UN22 - UN2) / sqrt((UN22 - UN2) * (UN22 - UN2) + ((UNE12 - UNW22) / 2.0) * ((UNE12 - UNW22) / 2.0) + a * a)) - ((UO2 - UN2) / sqrt((UO2 - UN2) * (UO2 - UN2) + ((UE2 - UW2) / 2.0) * ((UE2 - UW2) / 2.0) + a * a));
grad_NW22 = ((UNW22 - UNW2) / sqrt((UNW22 - UNW2) * (UNW22 - UNW2) + ((UN22 - UNW32) / 2.0) * ((UN22 - UNW32) / 2.0) + a * a)) - ((UW2 - UNW2) / sqrt((UW2 - UNW2) * (UW2 - UNW2) + ((UO2 - UW22) / 2.0) * ((UO2 - UW22) / 2.0) + a * a));
grad_SW22 = ((UW2 - USW2) / sqrt((UW2 - USW2) * (UW2 - USW2) + ((UO2 - UW22) / 2.0) * ((UO2 - UW22) / 2.0) + a * a)) - ((USW12 - USW2) / sqrt((USW12 - USW2) * (USW12 - USW2) + ((US22 - USW32) / 2.0) * ((US22 - USW32) / 2.0) + a * a));
grad_NE22 = ((UNE12 - UNE2) / sqrt((UNE12 - UNE2) * (UNE12 - UNE2) + ((UNE32 - UN22) / 2.0) * ((UNE32 - UN22) / 2.0) + a * a)) - ((UE2 - UNE2) / sqrt((UE2 - UNE2) * (UE2 - UNE2) + ((UE22 - UO2) / 2.0) * ((UE22 - UO2) / 2.0) + a * a));
grad_SE22 = ((UE2 - USE2) / sqrt((UE2 - USE2) * (UE2 - USE2) + ((UE22 - UO2) / 2.0) * ((UE22 - UO2) / 2.0) + a * a)) - ((USE22 - USE2) / sqrt((USE22 - USE2) * (USE22 - USE2) + ((USE32 - US22) / 2.0) * ((USE32 - US22) / 2.0) + a * a));
Kn2 = sqrt((grad_N22 - grad_O22) * (grad_N22 - grad_O22) + ((grad_NE12 - grad_NW12) / 2.0) * ((grad_NE12 - grad_NW12) / 2.0));
Ke2 = sqrt((grad_E12 - grad_O12) * (grad_E12 - grad_O12) + ((grad_NE22 - grad_SE22) / 2.0) * ((grad_NE22 - grad_SE22) / 2.0));
Kw2 = sqrt((grad_W12 - grad_O12) * (grad_W12 - grad_O12) + ((grad_NW22 - grad_SW22) / 2.0) * ((grad_NW22 - grad_SW22) / 2.0));
Ks2 = sqrt((grad_S22 - grad_O22) * (grad_S22 - grad_O22) + ((grad_SE12 - grad_SW12) / 2.0) * ((grad_SE12 - grad_SW12) / 2.0));
grad_O13 = ((UE3 - UO3) / sqrt((UE3 - UO3) * (UE3 - UO3) + ((UNE3 - USE3) / 2.0) * ((UNE3 - USE3) / 2.0) + a * a)) - ((UW3 - UO3) / sqrt((UW3 - UO3) * (UW3 - UO3) + ((UNW3 - USW3) / 2.0) * ((UNW3 - USW3) / 2.0) + a * a));
grad_E13 = ((UE23 - UE3) / sqrt((UE23 - UE3) * (UE23 - UE3) + ((UNE23 - USE13) / 2.0) * ((UNE23 - USE13) / 2.0) + a * a)) - ((UO3 - UE3) / sqrt((UO3 - UE3) * (UO3 - UE3) + ((UN3 - US3) / 2.0) * ((UN3 - US3) / 2.0) + a * a));
grad_W13 = ((UO3 - UW3) / sqrt((UO3 - UW3) * (UO3 - UW3) + ((UN3 - US3) / 2.0) * ((UN3 - US3) / 2.0) + a * a)) - ((UW23 - UW3) / sqrt((UW23 - UW3) * (UW23 - UW3) + ((UNW13 - USW23) / 2.0) * ((UNW13 - USW23) / 2.0) + a * a));
grad_NW13 = ((UN3 - UNW3) / sqrt((UN3 - UNW3) * (UN3 - UNW3) + ((UN23 - UO3) / 2.0) * ((UN23 - UO3) / 2.0) + a * a)) - ((UNW13 - UNW3) / sqrt((UNW13 - UNW3) * (UNW13 - UNW3) + ((UNW33 - UW23) / 2.0) * ((UNW33 - UW23) / 2.0) + a * a));
grad_SW13 = ((US3 - USW3) / sqrt((US3 - USW3) * (US3 - USW3) + ((UO3 - US23) / 2.0) * ((UO3 - US23) / 2.0) + a * a)) - ((USW23 - USW3) / sqrt((USW23 - USW3) * (USW23 - USW3) + ((UW23 - USW33) / 2.0) * ((UW23 - USW33) / 2.0) + a * a));
grad_NE13 = ((UNE23 - UNE3) / sqrt((UNE23 - UNE3) * (UNE23 - UNE3) + ((UNE33 - UE23) / 2.0) * ((UNE33 - UE23) / 2.0) + a * a)) - ((UN3 - UNE3) / sqrt((UN3 - UNE3) * (UN3 - UNE3) + ((UN23 - UO3) / 2.0) * ((UN23 - UO3) / 2.0) + a * a));
grad_SE13 = ((USE13 - USE3) / sqrt((USE13 - USE3) * (USE13 - USE3) + ((UE23 - USE33) / 2.0) * ((UE23 - USE33) / 2.0) + a * a)) - ((US3 - USE3) / sqrt((US3 - USE3) * (US3 - USE3) + ((UO3 - US23) / 2.0) * ((UO3 - US23) / 2.0) + a * a));
grad_O23 = ((UN3 - UO3) / sqrt((UN3 - UO3) * (UN3 - UO3) + ((UNE3 - UNW3) / 2.0) * ((UNE3 - UNW3) / 2.0) + a * a)) - ((US3 - UO3) / sqrt((US3 - UO3) * (US3 - UO3) + ((USE3 - USW3) / 2.0) * ((USE3 - USW3) / 2.0) + a * a));
grad_S23 = ((UO3 - US3) / sqrt((UO3 - US3) * (UO3 - US3) + ((UE3 - UW3) / 2.0) * ((UE3 - UW3) / 2.0) + a * a)) - ((US23 - US3) / sqrt((US23 - US3) * (US23 - US3) + ((USE23 - USW13) / 2.0) * ((USE23 - USW13) / 2.0) + a * a));
grad_N23 = ((UN23 - UN3) / sqrt((UN23 - UN3) * (UN23 - UN3) + ((UNE13 - UNW23) / 2.0) * ((UNE13 - UNW23) / 2.0) + a * a)) - ((UO3 - UN3) / sqrt((UO3 - UN3) * (UO3 - UN3) + ((UE3 - UW3) / 2.0) * ((UE3 - UW3) / 2.0) + a * a));
grad_NW23 = ((UNW23 - UNW3) / sqrt((UNW23 - UNW3) * (UNW23 - UNW3) + ((UN23 - UNW33) / 2.0) * ((UN23 - UNW33) / 2.0) + a * a)) - ((UW3 - UNW3) / sqrt((UW3 - UNW3) * (UW3 - UNW3) + ((UO3 - UW23) / 2.0) * ((UO3 - UW23) / 2.0) + a * a));
grad_SW23 = ((UW3 - USW3) / sqrt((UW3 - USW3) * (UW3 - USW3) + ((UO3 - UW23) / 2.0) * ((UO3 - UW23) / 2.0) + a * a)) - ((USW13 - USW3) / sqrt((USW13 - USW3) * (USW13 - USW3) + ((US23 - USW33) / 2.0) * ((US23 - USW33) / 2.0) + a * a));
grad_NE23 = ((UNE13 - UNE3) / sqrt((UNE13 - UNE3) * (UNE13 - UNE3) + ((UNE33 - UN23) / 2.0) * ((UNE33 - UN23) / 2.0) + a * a)) - ((UE3 - UNE3) / sqrt((UE3 - UNE3) * (UE3 - UNE3) + ((UE23 - UO3) / 2.0) * ((UE23 - UO3) / 2.0) + a * a));
grad_SE23 = ((UE3 - USE3) / sqrt((UE3 - USE3) * (UE3 - USE3) + ((UE23 - UO3) / 2.0) * ((UE23 - UO3) / 2.0) + a * a)) - ((USE23 - USE3) / sqrt((USE23 - USE3) * (USE23 - USE3) + ((USE33 - US23) / 2.0) * ((USE33 - US23) / 2.0) + a * a));
Kn3 = sqrt((grad_N23 - grad_O23) * (grad_N23 - grad_O23) + ((grad_NE13 - grad_NW13) / 2.0) * ((grad_NE13 - grad_NW13) / 2.0));
Ke3 = sqrt((grad_E13 - grad_O13) * (grad_E13 - grad_O13) + ((grad_NE23 - grad_SE23) / 2.0) * ((grad_NE23 - grad_SE23) / 2.0));
Kw3 = sqrt((grad_W13 - grad_O13) * (grad_W13 - grad_O13) + ((grad_NW23 - grad_SW23) / 2.0) * ((grad_NW23 - grad_SW23) / 2.0));
Ks3 = sqrt((grad_S23 - grad_O23) * (grad_S23 - grad_O23) + ((grad_SE13 - grad_SW13) / 2.0) * ((grad_SE13 - grad_SW13) / 2.0));
Un1 = sqrt((UO1 - UN1) * (UO1 - UN1) + ((UNE1 - UNW1) / 2.0) * ((UNE1 - UNW1) / 2.0));
Ue1 = sqrt((UO1 - UE1) * (UO1 - UE1) + ((UNE1 - USE1) / 2.0) * ((UNE1 - USE1) / 2.0));
Uw1 = sqrt((UO1 - UW1) * (UO1 - UW1) + ((UNW1 - USW1) / 2.0) * ((UNW1 - USW1) / 2.0));
Us1 = sqrt((UO1 - US1) * (UO1 - US1) + ((USE1 - USW1) / 2.0) * ((USE1 - USW1) / 2.0));
Un2 = sqrt((UO2 - UN2) * (UO2 - UN2) + ((UNE2 - UNW2) / 2.0) * ((UNE2 - UNW2) / 2.0));
Ue2 = sqrt((UO2 - UE2) * (UO2 - UE2) + ((UNE2 - USE2) / 2.0) * ((UNE2 - USE2) / 2.0));
Uw2 = sqrt((UO2 - UW2) * (UO2 - UW2) + ((UNW2 - USW2) / 2.0) * ((UNW2 - USW2) / 2.0));
Us2 = sqrt((UO2 - US2) * (UO2 - US2) + ((USE2 - USW2) / 2.0) * ((USE2 - USW2) / 2.0));
Un3 = sqrt((UO3 - UN3) * (UO3 - UN3) + ((UNE3 - UNW3) / 2.0) * ((UNE3 - UNW3) / 2.0));
Ue3 = sqrt((UO3 - UE3) * (UO3 - UE3) + ((UNE3 - USE3) / 2.0) * ((UNE3 - USE3) / 2.0));
Uw3 = sqrt((UO3 - UW3) * (UO3 - UW3) + ((UNW3 - USW3) / 2.0) * ((UNW3 - USW3) / 2.0));
Us3 = sqrt((UO3 - US3) * (UO3 - US3) + ((USE3 - USW3) / 2.0) * ((USE3 - USW3) / 2.0));
Wn1 = Kn1 / sqrt(Un1 * Un1 + a * a);
We1 = Ke1 / sqrt(Ue1 * Ue1 + a * a);
Ww1 = Kw1 / sqrt(Uw1 * Uw1 + a * a);
Ws1 = Ks1 / sqrt(Us1 * Us1 + a * a);
Wn2 = Kn2 / sqrt(Un2 * Un2 + a * a);
We2 = Ke2 / sqrt(Ue2 * Ue2 + a * a);
Ww2 = Kw2 / sqrt(Uw2 * Uw2 + a * a);
Ws2 = Ks2 / sqrt(Us2 * Us2 + a * a);
Wn3 = Kn3 / sqrt(Un3 * Un3 + a * a);
We3 = Ke3 / sqrt(Ue3 * Ue3 + a * a);
Ww3 = Kw3 / sqrt(Uw3 * Uw3 + a * a);
Ws3 = Ks3 / sqrt(Us3 * Us3 + a * a);
Hon1 = Wn1 / (Wn1 + We1 + Ww1 + Ws1 + lambda);
Hoe1 = We1 / (Wn1 + We1 + Ww1 + Ws1 + lambda);
How1 = Ww1 / (Wn1 + We1 + Ww1 + Ws1 + lambda);
Hos1 = Ws1 / (Wn1 + We1 + Ww1 + Ws1 + lambda);
Hon2 = Wn2 / (Wn2 + We2 + Ww2 + Ws2 + lambda);
Hoe2 = We2 / (Wn2 + We2 + Ww2 + Ws2 + lambda);
How2 = Ww2 / (Wn2 + We2 + Ww2 + Ws2 + lambda);
Hos2 = Ws2 / (Wn2 + We2 + Ww2 + Ws2 + lambda);
Hon3 = Wn3 / (Wn3 + We3 + Ww3 + Ws3 + lambda);
Hoe3 = We3 / (Wn3 + We3 + Ww3 + Ws3 + lambda);
How3 = Ww3 / (Wn3 + We3 + Ww3 + Ws3 + lambda);
Hos3 = Ws3 / (Wn3 + We3 + Ww3 + Ws3 + lambda);
Hoo1 = lambda / (Wn1 + We1 + Ww1 + Ws1 + lambda);
Hoo2 = lambda / (Wn2 + We2 + Ww2 + Ws2 + lambda);
Hoo3 = lambda / (Wn3 + We3 + Ww3 + Ws3 + lambda);
input_array.at<cv::Vec3f>(row, col)[0] = (Hon1 * UN1 + Hoe1 * UE1 + How1 * UW1 + Hos1 * US1 + Hoo1 * UO1);
input_array.at<cv::Vec3f>(row, col)[1] = (Hon2 * UN2 + Hoe2 * UE2 + How2 * UW2 + Hos2 * US2 + Hoo2 * UO2);
input_array.at<cv::Vec3f>(row, col)[2] = (Hon3 * UN3 + Hoe3 * UE3 + How3 * UW3 + Hos3 * US3 + Hoo3 * UO3);
output_array.at<cv::Vec3f>(row, col)[0] = input_array.at<cv::Vec3f>(row, col)[0];
output_array.at<cv::Vec3f>(row, col)[1] = input_array.at<cv::Vec3f>(row, col)[1];
output_array.at<cv::Vec3f>(row, col)[2] = input_array.at<cv::Vec3f>(row, col)[2];
}
printf("%d\n", iter);
}
}
}
/*
Save the inpainting domain to dinamic vector
*/
std::vector<Coord> create_mask(cv::Mat& mask)
{
std::vector<Coord> mask_data;
for (int i = 2; i < mask.rows - 2; i++)
{
for (int j = 2; j < mask.cols - 2; j++)
{
if (mask.at<cv::Vec3b>(i, j)[0] != 0)
{
Coord xy;
xy.i = i;
xy.j = j;
xy.color = PIXEL_WHITE;
mask_data.push_back(xy);
}
}
}
return mask_data;
}
测试图：
转载请注明出处，欢迎讨论和交流!
