code_device/hgdriver/ImageProcess/ImageApplyChannel.cpp

#include "ImageApplyChannel.h"

CImageApplyChannel::CImageApplyChannel()
	: m_channel(Invalid)
	, m_scale(0)
{
}

CImageApplyChannel::CImageApplyChannel(Channel channel)
	: m_channel(channel)
{
	switch (m_channel)
	{
	case Red_Plus:
		m_scale = 0.333333;
		break;
	case Green_Plus:
		m_scale = 1;
		break;
	case Blue_Plus:
		m_scale = 1;
		break;
	default:
		m_scale = 0;
	}
}

CImageApplyChannel::CImageApplyChannel(Channel channel, double scale)
	: m_channel(channel)
	, m_scale(scale)
{
}

CImageApplyChannel::~CImageApplyChannel()
{
}

void CImageApplyChannel::apply(cv::Mat& pDib, int side)
{
	(void)side;
	if (pDib.empty()) return;

	cv::Mat dst(pDib.rows, pDib.cols, CV_8UC1);
	cv::Mat mv[3];
	cv::split(pDib, mv);
	cv::Mat mask, mask1, mask2;
	switch (m_channel)
	{
	case Red:
		cv::extractChannel(pDib, dst, 2);
		break;
	case Green:
		cv::extractChannel(pDib, dst, 1);
		break;
	case Blue:
		cv::extractChannel(pDib, dst, 0);
		break;
	case All:
		colourless(pDib, dst, 80);
		break;
	case Except_Red:
		except_channel(pDib, dst, 2);
		break;
	case Except_Green:
		except_channel(pDib, dst, 1);
		break;
	case Except_Blue:
		except_channel(pDib, dst, 0);
		break;
	case Red_Plus:
		channel_plus(pDib, dst, 2, m_scale);
		break;
	case Green_Plus:
		channel_plus(pDib, dst, 1, m_scale);
		break;
	case Blue_Plus:
		channel_plus(pDib, dst, 0, m_scale);
		break;
	default:
		break;
	}
	pDib.release();
	pDib = dst;

#ifdef LOG
	FileTools::write_log("imgprc.txt", "exit CImageApplyChannel apply");
#endif // LOG
}

void CImageApplyChannel::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++;
	}
}

void CImageApplyChannel::except_channel(const cv::Mat& src, cv::Mat& dst, int channel)
{
	cv::Mat mv[3];
	cv::split(src, mv);
	cv::Mat mask, mask1, mask2;
	switch (channel)
	{
	case 0:
		mask1 = mv[0] - mv[1];
		mask2 = mv[0] - mv[2];
		break;
	case 1:
		mask1 = mv[1] - mv[0];
		mask2 = mv[1] - mv[2];
		break;
	case 2:
		mask1 = mv[2] - mv[1];
		mask2 = mv[2] - mv[0];
		break;
	default:
		break;
	}
	cv::min(mask1, mask2, mask);

	cv::cvtColor(src, dst, cv::COLOR_BGR2GRAY);
	dst -= mask;
}

void CImageApplyChannel::colourless(const cv::Mat& src, cv::Mat& dst, uchar threshold)
{
	if (src.channels() != 3)
	{
		dst = src;
		return;
	}

	cv::Mat hsv;
	cv::cvtColor(src, hsv, cv::COLOR_BGR2HSV_FULL);
	cv::Mat mv_hsv[3];
	cv::split(hsv, mv_hsv);
	size_t total = mv_hsv[1].total();
	uchar* ptr_s = mv_hsv[1].data;
	uchar* ptr_v = mv_hsv[2].data;
	for (size_t i = 0; i < total; i++)
		if (ptr_s[i] > threshold)
		{
			ptr_s[i] = 0;
			ptr_v[i] = 255;
		}
	cv::merge(mv_hsv, 3, hsv);
	cv::cvtColor(hsv, hsv, cv::COLOR_HSV2BGR_FULL);
	cv::cvtColor(hsv, dst, cv::COLOR_BGR2GRAY);
}

void CImageApplyChannel::channel_plus(const cv::Mat& src, cv::Mat& dst, int channel, double scale)
{
	cv::Mat mv[3];
	cv::split(src, mv);
	cv::Mat temp;

	temp = mv[channel] * 2 - mv[(channel + 1) % 3] - mv[(channel + 2) % 3];

	//cv::imwrite("111/temp.jpg", temp);
	dst = mv[channel] + temp * scale;
}