眼镜反光检测

参考文章：https://blog.csdn.net/weiwei9363/article/details/85046877#_45

首先我们可以手机一批数据使用数据训练一哥网络模型，

测试代码（.h5模型在CSDN里可以下载）

import tensorflow as tf
import os
import glob
from skimage import io
import matplotlib.pyplot as plt 

os.environ['CUDA_VISIBLE_DEVICES'] = '1'

import numpy as np
from keras.layers import  Input,Conv2D,BatchNormalization,Activation,Subtract
from keras.models import Model, load_model
from keras.callbacks import CSVLogger, ModelCheckpoint, LearningRateScheduler
from keras.optimizers import Adam
import keras.backend as K

model = load_model('FCN_baseline.h5')

img = io.imread('./CVC-612/bbdd_png/7.jpg')
img = img.astype('float') / 255.0
img = np.expand_dims(img, axis=0)

specular_mask = model.predict(img)
th = 0.4
specular_mask[specular_mask > 0.6] = 1.0
specular_mask[specular_mask <= 0.6] = 0

plt.subplot(1,2,1)
plt.imshow(img[0, :,:,:])
plt.subplot(1,2,2)
plt.imshow(specular_mask[0, :,:,0], cmap='gray')
plt.show()

效果：

-------------------------------》输出=================》》

效果还可以，但是速度比较慢。

二：对与已经识别出来的反光模块，我们就可以做反光消除了，具体代码如下，main函数

#include <iostream>
#include <map>
#include <opencv2/opencv.hpp>
#include "FastDigitalImageInpainting.hpp"

std::map<std::string, std::string> path =
{
	{"Image", "G:/反光/Fast-Digital-Image-Inpainting-master/data/image.png"},
	{"Mask", "G:/反光/Fast-Digital-Image-Inpainting-master/data/mask.png"},
	{"Output", "G:/反光/Fast-Digital-Image-Inpainting-master/data/inpaint.png"}
};

void main()
{
	cv::Mat src = cv::imread(path["Image"]);
	cv::Mat mask = cv::imread(path["Mask"]);
	cv::Mat res;

	cv::imshow("src", src);
	cv::imshow("mask", mask);
	cv::waitKey(1);

	std::cout << "inpainting...";
	inpaint(src, mask, K, res, 500);
	std::cout << " done!" << std::endl;

	cv::imwrite(path["Output"], res);
	cv::imshow("Convolutional Inpainting (Result)", res);
	cv::waitKey();
}

头文件FastDigitalImageInpainting.hpp

#pragma once

#include <opencv2/opencv.hpp>

static const float a(0.073235f);
static const float b(0.176765f);
static const cv::Mat K = (cv::Mat_<float>(3, 3) << a, b, a, b, 0.0f, b, a, b, a);

void inpaint(const cv::Mat &src, const cv::Mat &mask, const cv::Mat kernel, cv::Mat &dst, int maxNumOfIter = 100)
{
	assert(src.type() == mask.type() && mask.type() == CV_8UC3);
	assert(src.size() == mask.size());
	assert(kernel.type() == CV_32F);

	// fill in the missing region with the input's average color
	auto avgColor = cv::sum(src) / (src.cols * src.rows);
	cv::Mat avgColorMat(1, 1, CV_8UC3);
	avgColorMat.at<cv::Vec3b>(0, 0) = cv::Vec3b(avgColor[0], avgColor[1], avgColor[2]);
	cv::resize(avgColorMat, avgColorMat, src.size(), 0.0, 0.0, cv::INTER_NEAREST);
	cv::Mat result = (mask / 255).mul(src) + (1 - mask / 255).mul(avgColorMat);

	// convolution
	int bSize = K.cols / 2;
	cv::Mat kernel3ch, inWithBorder;
	result.convertTo(result, CV_32FC3);
	cv::cvtColor(kernel, kernel3ch, cv::COLOR_GRAY2BGR);

	cv::copyMakeBorder(result, inWithBorder, bSize, bSize, bSize, bSize, cv::BORDER_REPLICATE);
	cv::Mat resInWithBorder = cv::Mat(inWithBorder, cv::Rect(bSize, bSize, result.cols, result.rows));

	const int ch = result.channels();
	for (int itr = 0; itr < maxNumOfIter; ++itr)
	{
		cv::copyMakeBorder(result, inWithBorder, bSize, bSize, bSize, bSize, cv::BORDER_REPLICATE);

		for (int r = 0; r < result.rows; ++r)
		{
			const uchar *pMask = mask.ptr(r);
			float *pRes = result.ptr<float>(r);
			for (int c = 0; c < result.cols; ++c)
			{
				if (pMask[ch * c] == 0)
				{
					cv::Rect rectRoi(c, r, K.cols, K.rows);
					cv::Mat roi(inWithBorder, rectRoi);

					auto sum = cv::sum(kernel3ch.mul(roi));
					pRes[ch * c + 0] = sum[0];
					pRes[ch * c + 1] = sum[1];
					pRes[ch * c + 2] = sum[2];
				}
			}
		}

		// for debugging
		cv::imshow("Inpainting...", result / 255.0f);
		cv::waitKey(1);
	}

	result.convertTo(dst, CV_8UC3);
}

运行效果如下：