twain2/ImageMatQueue.cpp

#include "StdAfx.h"
#include "ImageMatQueue.h"
#include "PublicFunc.h"
#include "filetools.h"
#include "ImageOutHole.h"
#include "ImageMultiOutput.h"

using namespace cv;
using namespace std;

#define DECODE_COLOR_BGR  1
#define DECODE_GRAY       6

ImageMatQueue::ImageMatQueue(void)
	: bRun(false), iscanning(false),
	can_multi_outputR(false)
{
	m_threadProc = NULL;
	at_prced_image_remains = 0;
	atm_orgin_image_remains = 0;
}

void ImageMatQueue::run()
{
	if (m_threadProc)
	{
		bRun = false;
		at_prced_image_remains = 0;
		atm_orgin_image_remains = 0;
		m_threadProc->join();
		delete m_threadProc;
		m_threadProc = NULL;
	}
	bRun = true;
	at_prced_image_remains = 0;
	atm_orgin_image_remains = 0;
	m_threadProc = new thread(&ImageMatQueue::proc, this);
}

ImageMatQueue::~ImageMatQueue(void)
{
	if (m_threadProc)
	{
		bRun = false;
		at_prced_image_remains = 0;
		atm_orgin_image_remains = 0;
		m_threadProc->join();
		delete m_threadProc;
		m_threadProc = NULL;
	}
}

void ImageMatQueue::pushMat(JpegBuffer& data)
{
	std::lock_guard<std::mutex> lock(m_mtxJB);
	m_pImages.Put(data);
	atm_orgin_image_remains++;
}

cv::Mat ImageMatQueue::popMat()
{
	std::lock_guard<std::mutex> lock(m_mtxJB);
	cv::Mat mat = _popMat();
	at_prced_image_remains--;
	return mat;
}

bool ImageMatQueue::valid()
{
	return (at_prced_image_remains != 0);
}

void ImageMatQueue::clear()
{
	m_images.Clear();
	m_pImages.Clear();
	at_prced_image_remains = 0;
	atm_orgin_image_remains = 0;
}

void ImageMatQueue::setparam(SFreeImage param)
{
	scanParam = param;
	m_iaList.clear();
	if (param.m_bAutoDiscardBlank || param.m_bAutoDiscardBlankInvoice)
	{
		m_iaList.push_back(shared_ptr<CImageApply>(new CImageProcDiscardBlank(param.m_bAutoDiscardBlank ? true : false)));
	}
	bool m_bAutoCrop = false;
	if (param.m_HardWareParams.PaperType == 90)
		m_bAutoCrop = true;

	m_iaList.push_back(shared_ptr<CImageApply>(new CAutoCrop(param.m_bFillBlackRect, param.m_bAutoDeskew, param.m_bAutoCrop, papersize.GetPaperSize(param.m_HardWareParams.PaperType, param.m_fXResolution), papersize.GetPaperSize(param.m_HardWareParams.PaperType, 200.0), param.m_nPixelType)));

	if (param.m_nFilter)
	{
		m_iaList.push_back(shared_ptr<CImageApply>(new CImageChannel(param.m_nFilter)));
	}

	if (param.m_fBrightness != 0 || param.m_fContrast != 0 || param.m_fGamma != 1.0)
	{
		m_iaList.push_back(shared_ptr<CImageApply>(new CImageAdjustColors(param.m_fBrightness, param.m_fContrast, param.m_fGamma)));
	}
	if (param.m_fXResolution != 200.0)
	{
		m_iaList.push_back(shared_ptr< CImageApply>(new CImageApplyResize(200.0, param.m_fXResolution, param.m_bAutoCrop, papersize.GetPaperSize(param.m_HardWareParams.PaperType, param.m_fXResolution))));
	}

	if (param.m_wRotation != 0 || param.m_bBackRotate180)
	{
		m_iaList.push_back(shared_ptr<CImageApply>(new CImageRotation(param.m_wRotation, param.m_bBackRotate180)));
	}
}

cv::Mat ImageMatQueue::_popMat()
{
	return m_images.Take();
}

void ImageMatQueue::EnqueueMat(cv::Mat &mat)
{
	std::lock_guard<std::mutex> lock(m_Locker);
	m_images.Put(mat);
	at_prced_image_remains++;
}

void ImageMatQueue::PaniusCount()
{
	std::lock_guard<std::mutex> lock(m_Locker);
	atm_orgin_image_remains--;
}

void ImageMatQueue::SetScanningStatus(bool isscannning)
{
	std::lock_guard<std::mutex> lock(m_Locker);
	iscanning = isscannning;
}

void ImageMatQueue::release_img_prc_thread()
{
	if (m_threadProc)
	{
		bRun = false;
		at_prced_image_remains = 0;
		atm_orgin_image_remains = 0;
		m_threadProc->join();
		delete m_threadProc;
		m_threadProc = NULL;
		iscanning = false;
	}
}

bool ImageMatQueue::empty()
{
	return ((atm_orgin_image_remains == 0 &&
		at_prced_image_remains == 0) && (!iscanning));
}

void ImageMatQueue::proc()
{
	while (bRun)
	{
		this_thread::sleep_for(chrono::milliseconds(5));
		{
			if (m_pImages.Size() != 0)//m_images.Size() == 0 &&
			{
				vector<cv::Mat> mats = m_pImages.Take().getMats();
				if (scanParam.m_OutHole.EnOutHole&& mats.size() == 2)//ȷ<><C8B7><EFBFBD>ܹ<EFBFBD><DCB9><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ
				{
					ImageOutHole outhole;
					if (!mats[0].empty() && !mats[1].empty())
					{
						outhole.puncture(mats[0], mats[1], 50.0, scanParam.m_OutHole.OutHoleRatio / 100.0, 50);
					}
				}

				for (int i = 0; i < mats.size(); i++)
				{

					if (!mats[i].empty())
					{
						for (int j = 0; j < m_iaList.size(); j++)
						{
							if (mats[i].empty())//<2F>޳<EFBFBD><DEB3>հ<EFBFBD>ҳ
								break;

							m_iaList[j]->apply(mats[i], i);
						}
					}
				}

				for (int i = 0; i < mats.size(); i++)
				{
					if (!scanParam.m_bDuplex&&i == 1)
					{
						mats[i].release();
						break;
					}

					if (!mats[i].empty())
					{
						EnqueueMat(mats[i]);
					}
				}

				if (scanParam.m_bMultiOutput)
				{
					for (int i = 0; i < mats.size(); i++)
					{
						ImageMultiOutput m_mlt;
						Mat m_filterMat = m_mlt.GetMultiFilterMat(mats[i], 2);
						if (!m_filterMat.empty())
						{
							if (!scanParam.m_bDuplex&&i == 1)
							{
								mats[i].release();
								break;
							}

							if (!m_filterMat.empty())
							{
								EnqueueMat(m_filterMat);
							}
						}
					}
				}
				PaniusCount();
			}
		}
	}
}