twain2/hugaotwainds/ImageMatQueue.cpp

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

using namespace boost;

ImageMatQueue::ImageMatQueue(void)
{
	locking_queue<cv::Mat> imgqueue;
	pixType = -1;
	duplexFlag = TRUE;
	origin_images_remain = 0;
}

void ImageMatQueue::run()
{
	if (!bRun)
	{
		bRun = true;
		m_threadProc = boost::thread(&ImageMatQueue::proc, this);
	}
}

void ImageMatQueue::setmultioutputR(bool canoutput/*=false*/)
{
	can_multi_outputR = canoutput;
}

ImageMatQueue::~ImageMatQueue(void)
{
	bRun = false;
	boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
}

void ImageMatQueue::pushMat(JpegBuffer& data)
{
	m_pImages.push(data);
	origin_images_remain++;
}

cv::Mat ImageMatQueue::popMat()
{
	return _popMat();
}

bool ImageMatQueue::valid()
{
	return !m_images.empty();
}

void ImageMatQueue::clear()
{
	while (m_images.size()) { m_images.pop(true); }
	while (m_pImages.size()) { m_pImages.pop(true); }
	origin_images_remain = 0;
}

void ImageMatQueue::setlist(std::vector<std::shared_ptr<CImageApply>> list)
{
	m_iaList = list;
}

cv::Mat ImageMatQueue::_popMat()
{
	cv::Mat image = m_images.pop(true);
	return image;
}

bool ImageMatQueue::empty()
{
	return m_images.empty() && origin_images_remain == 0 && !scanFlag;
}

void ImageMatQueue::setscanflag(bool isscan)
{
	scanFlag = isscan;
}

void ImageMatQueue::setduplexflag(BOOL value)
{
	duplexFlag = value;
}

static int num = 0;
static int iii = 0;
void ImageMatQueue::proc()
{
	while (bRun)
	{
		boost::this_thread::sleep_for(boost::chrono::milliseconds(5));
		{
			if (m_images.empty() && !m_pImages.empty())
			{
				if (pixType != -1)
				{
					vector<cv::Mat> mats;
					if (m_pImages.size() > 0)
					{
						mats = m_pImages.pop(true).getMats(pixType);
						if (mats.size() != 2) {
							FileTools::write_log("D:\\decodeerror.txt", "decode image data error");
						}

						if (!mats[0].empty() && !mats[1].empty())
						{
#ifdef LOG
							CString csImageA, csImageB;
							csImageA.Format("D:\\%d.jpg", (++iii));
							csImageB.Format("D:\\%d.jpg", (++iii));

							IplImage qqImgA, qqImgB;
							qqImgA = IplImage(mats[0]); // cv::Mat -> IplImage 
							cvSaveImage(csImageA, &qqImgA);
							qqImgB = IplImage(mats[1]); // cv::Mat -> IplImage 
							cvSaveImage(csImageB, &qqImgB);
#endif // LOG
							std::swap(mats[0], mats[1]);
							for (int j = 0; j < m_iaList.size(); j++)
							{
								m_iaList[j]->apply(mats, duplexFlag);//<2F><>Ҫ<EFBFBD><D2AA>ÿ<EFBFBD><C3BF>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>apply<6C>IJ<EFBFBD><C4B2><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD><D0B6><EFBFBD><EFBFBD>ߵ<EFBFBD>mat<61>Ƿ<EFBFBD>Ϊ<EFBFBD><CEAA> Ŀǰ<C4BF><C7B0>û<EFBFBD><C3BB>
							}

							for (size_t i = 0; i < mats.size(); i++)
							{
								if (!duplexFlag && i == 1)
								{
									mats[i].release();
									break;
								}
#ifdef LOG
								//CString csImage;
								//csImage.Format("d:\\calc\\%d.jpg", (++num));
								//IplImage qqImg;
								//qqImg = IplImage(mats[i]); // cv::Mat -> IplImage 
								//cvSaveImage(csImage, &qqImg);
#endif // LOG
								if(!mats[i].empty())
									m_images.push(mats[i]);
								if (can_multi_outputR)
								{
									ImageMultiOutput m_mlt;
									cv::Mat m_filterMat = m_mlt.GetMultiFilterMat(mats[i], 1);
									if (!m_filterMat.empty())
									{
										m_images.push(m_filterMat);
									}
								}
							}
							origin_images_remain--;//ȷ<><C8B7>ԭͼ<D4AD><CDBC><EFBFBD><EFBFBD>push <20><>pop<6F><70><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>
							mats.clear();
						}
					}
				}
			}
		}
	}
}