code_device/hgdriver/ImageProcess/ImageApplyDiscardBlank.cpp

#include "ImageApplyDiscardBlank.h"
#include "ImageProcess_Public.h"

CImageApplyDiscardBlank::CImageApplyDiscardBlank(double threshold, int edge, double devTh, double meanTh, int dilate)
	: m_threshold(threshold)
	, m_edge(edge)
	, m_devTh(devTh)
	, m_meanTh(meanTh)
	, m_dilate(dilate)
{
}

CImageApplyDiscardBlank::~CImageApplyDiscardBlank(void)
{
}

void CImageApplyDiscardBlank::apply(cv::Mat& pDib, int side)
{
	if (apply(pDib, m_threshold, m_edge, m_devTh, m_meanTh, m_dilate))
		pDib.release();
}

void CImageApplyDiscardBlank::apply(std::vector<cv::Mat>& mats, bool isTwoSide)
{
	(void)isTwoSide;
	int i = 0;
	for (cv::Mat& var : mats) {
		if (i != 0 && isTwoSide == false)
			break;
		if (!var.empty())
			apply(var, 0);
		i++;
	}
}

bool maxMinCompare(const cv::Mat& img, const cv::Mat& mask, double devTh, double bgc)
{
	double min, max;
	cv::minMaxLoc(img, &min, &max, 0, 0, mask);
	
	return abs(max - bgc) < devTh && abs(min - bgc) < devTh;
}

static int a = 0;
bool CImageApplyDiscardBlank::apply(const cv::Mat& pDib, double threshold, int edge, double devTh, double meanTh, int dilate)
{
	if (pDib.empty())
		return true;

	double resizeScale = 1.0;
	while ((pDib.cols * resizeScale > 500) && (pDib.rows * resizeScale > 500))
		resizeScale /= 2;

	cv::Mat img_resize;
	cv::resize(pDib, img_resize, cv::Size(), resizeScale, resizeScale, cv::INTER_LINEAR);
	//cv::dilate(img_resize, img_resize, cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(dilate, dilate)));
	cv::blur(img_resize, img_resize, cv::Size(dilate, dilate));

	cv::Scalar bgc = hg::getBackGroundColor(img_resize, cv::Mat(), 20);
	if (pDib.channels() == 3)
		if ((bgc[0] + bgc[1] + bgc[2]) < meanTh * 3)
			return false;
	if (pDib.channels() == 1)
		if (bgc[0] < meanTh )
			return false;

	//cv::imwrite(std::to_string(a) + "r.jpg", img_resize);
	cv::Mat threshold_img;
	if (img_resize.channels() == 3)
	{
		cv::cvtColor(img_resize, threshold_img, cv::COLOR_BGR2GRAY);
		cv::threshold(threshold_img, threshold_img, threshold, 255, cv::THRESH_BINARY);
	}
	else
		cv::threshold(img_resize, threshold_img, threshold, 255, cv::THRESH_BINARY);

	std::vector<std::vector<cv::Point>> contours;
	std::vector<cv::Vec4i> h1;
	hg::findContours(threshold_img, contours, h1, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

	std::vector<cv::Point> contour;
	for (const std::vector<cv::Point>& sub : contours)
		for (const cv::Point& p : sub)
			contour.push_back(p);

	cv::RotatedRect rect = hg::getBoundingRect(contour);
	rect.size = cv::Size2f(rect.size.width - edge * resizeScale * 2, rect.size.height - edge * resizeScale * 2);
	cv::Point2f box[4];
	rect.points(box);

	contour.clear();
	contours.clear();
	for (size_t i = 0; i < 4; i++)
		contour.push_back(box[i]);
	contours.push_back(contour);

	cv::Mat mask = cv::Mat::zeros(img_resize.size(), CV_8UC1);
	hg::fillPolys(mask, contours, cv::Scalar::all(255));
	//cv::imwrite(std::to_string(a) + "m.jpg", mask);
	a++;
	bool b = true;
	if (img_resize.channels() == 3)
	{
		cv::Mat bgr[3];
		cv::split(img_resize, bgr);
		for (size_t i = 0; i < 3; i++)
		{
			b &= maxMinCompare(bgr[i], mask, devTh, bgc[i]);
			if (!b) break;
		}
	}
	else
		b &= maxMinCompare(img_resize, mask, devTh, bgc[0]);
	return b;
}