#include "StdAfx.h"
|
#include "ImageMerger.h"
|
#include "CHImageControls/CHImageProcess.h"
|
|
|
CImageMerger::CImageMerger(int nThreadCount, IImageMerger2Parent* pIIM2P) : CWorkThreadPools(nThreadCount), m_pIIM2P(pIIM2P)
|
{
|
m_strImagePath = _T("");
|
m_nCameraType = -1;
|
m_nCameraCount = 0;
|
m_nScanCount = 0;
|
m_nRotationType = MergeRotationType_None;
|
m_dMergeScale = 1.0;
|
|
m_nMergeImageCount = 0;
|
m_nMergedImageCount = 0;
|
}
|
|
CImageMerger::~CImageMerger(void)
|
{
|
}
|
|
void CImageMerger::SetIIM2P( IImageMerger2Parent* pIIM2P )
|
{
|
m_csMergeImage.Lock();
|
m_pIIM2P = pIIM2P;
|
m_csMergeImage.Unlock();
|
}
|
|
void CImageMerger::WorkThreadProcess( PVOID pParameter )
|
{
|
if (m_pIIM2P==NULL) return;
|
if (pParameter==NULL) return;
|
CMergeThreadData* pThreadData = static_cast<CMergeThreadData*>(pParameter);
|
|
// load image
|
CString strLoadFilename = m_strImagePath + pThreadData->m_strImageFile;
|
|
CCHImageData sourceImage;
|
if (sourceImage.LoadImage(strLoadFilename)==FALSE)
|
{
|
return;
|
}
|
|
// check channels
|
int nSourceChannels = sourceImage.GetChannels();
|
int nTargetChannels = m_MergeImage.GetChannels();
|
if (nTargetChannels != nSourceChannels)
|
{
|
return;
|
}
|
|
// image flip
|
CCHImageData *pFlipImage = &sourceImage;
|
CCHImageData flipeImage;
|
switch(pThreadData->m_nFlipType)
|
{
|
case MergeFlipType_Vertical:
|
if (CCHImageProcess::ImageFlip(&sourceImage, &flipeImage, CHImageControls::FlipTypeVert)==1)
|
{
|
pFlipImage = &flipeImage;
|
}
|
else pFlipImage = NULL;
|
break;
|
|
case MergeFlipType_Horizontal:
|
if (CCHImageProcess::ImageFlip(&sourceImage, &flipeImage, CHImageControls::FlipTypeHoriz)==1)
|
{
|
pFlipImage = &flipeImage;
|
}
|
else pFlipImage = NULL;
|
break;
|
}
|
|
if (pFlipImage==NULL)
|
{
|
return;
|
}
|
|
// image rotation
|
CCHImageData *pRotationImage = pFlipImage;
|
CCHImageData rotationImage;
|
switch(pThreadData->m_nRotationType)
|
{
|
case MergeRotationType_Left: // left
|
if (CCHImageProcess::ImageRotate(pRotationImage, &rotationImage, CHImageControls::RotateTypeLeft)==1)
|
{
|
pRotationImage = &rotationImage;
|
}
|
else pRotationImage = NULL;
|
break;
|
|
case MergeRotationType_Right: // right
|
if (CCHImageProcess::ImageRotate(pRotationImage, &rotationImage, CHImageControls::RotateTypeRight)==1)
|
{
|
pRotationImage = &rotationImage;
|
}
|
else pRotationImage = NULL;
|
break;
|
}
|
|
if (pRotationImage==NULL)
|
{
|
return;
|
}
|
|
// ¿øº» À̹ÌÁö ¹öÆÛ ½ÃÀÛ À§Ä¡
|
int nSourceStep = pRotationImage->GetWidthStep();
|
char* pSourceBuffer = pRotationImage->GetImageBuffer() + (pThreadData->m_nSourcePosY * nSourceStep) + (pThreadData->m_nSourcePosX * nSourceChannels);
|
|
// Ÿ°Ù À̹ÌÁö ¹öÆÛ ½ÃÀÛ À§Ä¡
|
int nTargetStep = m_MergeImage.GetWidthStep();
|
char* pTargetBuffer = m_MergeImage.GetImageBuffer() + (pThreadData->m_nTargetPosY * nTargetStep) + (pThreadData->m_nTargetPosX * nTargetChannels);
|
|
// À̹ÌÁö ¹öÆÛ º¹»ç
|
for (int nIdx=0; nIdx<pThreadData->m_nTargetHeight; nIdx++)
|
{
|
memcpy(pTargetBuffer, pSourceBuffer, sizeof(char)*(pThreadData->m_nSourceWidth*nSourceChannels));
|
pSourceBuffer = pSourceBuffer + nSourceStep;
|
pTargetBuffer = pTargetBuffer + nTargetStep;
|
}
|
|
m_csMergeImage.Lock();
|
m_nMergedImageCount++;
|
if (m_nMergedImageCount>=m_nMergeImageCount)
|
{
|
m_pIIM2P->IIM2P_SetMergeComplete(m_nCameraType, m_nMergedImageCount);
|
}
|
m_csMergeImage.Unlock();
|
}
|
|
BOOL CImageMerger::CalculateThreadData_None(int nCameraWidth, int nGlassHeight, CMergeThreadData* pThreadData)
|
{
|
if (m_pIIM2P==NULL) return FALSE;
|
if (pThreadData==NULL) return FALSE;
|
|
int nMarginLeft = 0;
|
int nMarginRight = 0;
|
if (m_pIIM2P->IIM2P_GetCameraMarginPixel(m_nCameraType, pThreadData->m_nCameraIndex, pThreadData->m_nScanIndex, nMarginLeft, nMarginRight)==FALSE)
|
{
|
return FALSE;
|
}
|
|
int nGlassStart = 0;
|
if (m_pIIM2P->IIM2P_GetGlassStartPixel(m_nCameraType, pThreadData->m_nCameraIndex, pThreadData->m_nScanIndex, nGlassStart)==FALSE)
|
{
|
return FALSE;
|
}
|
|
pThreadData->m_nFlipType = (pThreadData->m_nScanIndex%2==0) ? MergeFlipType_None: MergeFlipType_Vertical; // ¿ª¹æÇâÀϽà flip
|
|
pThreadData->m_nSourcePosX = (int)((nMarginLeft * m_dMergeScale) + 0.5);
|
pThreadData->m_nSourceWidth = (int)(((nCameraWidth - nMarginLeft - nMarginRight) * m_dMergeScale) + 0.5);
|
|
pThreadData->m_nSourcePosY = (int)((nGlassStart * m_dMergeScale) + 0.5);
|
pThreadData->m_nSourceHeight = (int)((nGlassHeight * m_dMergeScale) + 0.5);
|
|
return TRUE;
|
}
|
|
BOOL CImageMerger::CalculateThreadData_Right(int nCameraWidth, int nGlassHeight, CMergeThreadData* pThreadData)
|
{
|
int nMarginLeft = 0;
|
int nMarginRight = 0;
|
if (m_pIIM2P->IIM2P_GetCameraMarginPixel(m_nCameraType, pThreadData->m_nCameraIndex, pThreadData->m_nScanIndex, nMarginLeft, nMarginRight)==FALSE)
|
{
|
return FALSE;
|
}
|
|
int nGlassStart = 0;
|
if (m_pIIM2P->IIM2P_GetGlassStartPixel(m_nCameraType, pThreadData->m_nCameraIndex, pThreadData->m_nScanIndex, nGlassStart)==FALSE)
|
{
|
return FALSE;
|
}
|
|
pThreadData->m_nFlipType = (pThreadData->m_nScanIndex%2==0) ? MergeFlipType_None: MergeFlipType_Vertical; // ¿ª¹æÇâÀϽà flip
|
|
pThreadData->m_nSourcePosX = (int)((nGlassStart * m_dMergeScale) + 0.5);
|
pThreadData->m_nSourceWidth = (int)((nGlassHeight * m_dMergeScale) + 0.5);
|
|
pThreadData->m_nSourcePosY = (int)((nMarginLeft * m_dMergeScale) + 0.5);
|
pThreadData->m_nSourceHeight = (int)(((nCameraWidth - nMarginLeft - nMarginRight) * m_dMergeScale) + 0.5);
|
|
return TRUE;
|
}
|
|
BOOL CImageMerger::CalculateThreadData_Left(int nCameraWidth, int nGlassHeight, CMergeThreadData* pThreadData)
|
{
|
int nMarginLeft = 0;
|
int nMarginRight = 0;
|
if (m_pIIM2P->IIM2P_GetCameraMarginPixel(m_nCameraType, pThreadData->m_nCameraIndex, pThreadData->m_nScanIndex, nMarginLeft, nMarginRight)==FALSE)
|
{
|
return FALSE;
|
}
|
|
int nGlassStart = 0;
|
if (m_pIIM2P->IIM2P_GetGlassStartPixel(m_nCameraType, pThreadData->m_nCameraIndex, pThreadData->m_nScanIndex, nGlassStart)==FALSE)
|
{
|
return FALSE;
|
}
|
|
pThreadData->m_nFlipType = (pThreadData->m_nScanIndex%2==0) ? MergeFlipType_None: MergeFlipType_Vertical; // ¿ª¹æÇâÀϽà flip
|
|
pThreadData->m_nSourcePosX = (int)((nGlassStart * m_dMergeScale) + 0.5);
|
pThreadData->m_nSourceWidth = (int)((nGlassHeight * m_dMergeScale) + 0.5);
|
|
pThreadData->m_nSourcePosY = (int)((nMarginRight * m_dMergeScale) + 0.5);
|
pThreadData->m_nSourceHeight = (int)(((nCameraWidth - nMarginLeft - nMarginRight) * m_dMergeScale) + 0.5);
|
|
return TRUE;
|
}
|
|
int CImageMerger::SetMergeData( int nCameraType, int nCameraCount, int nScanCount, const CString& strImagePath, int nRotationType, int nMergeChannels, double dMergeScale )
|
{
|
if (m_pIIM2P==NULL) return 0;
|
|
m_csMergeImage.Lock();
|
|
m_nMergeImageCount = 0;
|
m_nMergedImageCount = 0;
|
m_nCameraType = nCameraType;
|
m_nCameraCount = nCameraCount;
|
m_nScanCount = nScanCount;
|
m_strImagePath = strImagePath;
|
m_nRotationType = nRotationType;
|
m_dMergeScale = dMergeScale;
|
|
int nCameraWidth = m_pIIM2P->IIM2P_GetCameraWidthPixel(m_nCameraType);
|
int nGlassHeight = m_pIIM2P->IIM2P_GetGlassHeightPixel(m_nCameraType);
|
|
int nTotalMergeWidth = (m_nRotationType==MergeRotationType_None) ? 0: nGlassHeight;
|
int nTotalMergeHeight = (m_nRotationType==MergeRotationType_None) ? nGlassHeight: 0;
|
|
VectorMergeThreadData vecThreadData;
|
|
for (int nCameraIdx=0; nCameraIdx<m_nCameraCount; nCameraIdx++)
|
{
|
for (int nScanIdx=0; nScanIdx<m_nScanCount; nScanIdx++)
|
{
|
CMergeThreadData *pThreadData = new CMergeThreadData(this);
|
if (pThreadData==NULL) continue;
|
|
// set thread data
|
pThreadData->m_nCameraIndex = nCameraIdx;
|
pThreadData->m_nScanIndex = nScanIdx;
|
pThreadData->m_nRotationType = m_nRotationType;
|
|
// set source image pos
|
BOOL bResult = FALSE;
|
switch(pThreadData->m_nRotationType)
|
{
|
case MergeRotationType_None: // none
|
bResult = CalculateThreadData_None(nCameraWidth, nGlassHeight, pThreadData);
|
break;
|
|
case MergeRotationType_Left: // left
|
bResult = CalculateThreadData_Left(nCameraWidth, nGlassHeight, pThreadData);
|
break;
|
|
case MergeRotationType_Right: // right
|
bResult = CalculateThreadData_Right(nCameraWidth, nGlassHeight, pThreadData);
|
break;
|
}
|
|
if (bResult==FALSE)
|
{
|
delete pThreadData;
|
continue;
|
}
|
|
// set image file name
|
pThreadData->m_strImageFile.Format(_T("\\%d_%d.jpg"), nCameraIdx, nScanIdx);
|
|
// set target image size
|
pThreadData->m_nTargetWidth = pThreadData->m_nSourceWidth;
|
pThreadData->m_nTargetHeight = pThreadData->m_nSourceHeight;
|
|
// set target image pos
|
switch(pThreadData->m_nRotationType)
|
{
|
case MergeRotationType_None: // none
|
pThreadData->m_nTargetPosX = nTotalMergeWidth;
|
pThreadData->m_nTargetPosY = 0;
|
break;
|
|
case MergeRotationType_Left: // left
|
pThreadData->m_nTargetPosX = 0;
|
pThreadData->m_nTargetPosY = nTotalMergeHeight;
|
break;
|
|
case MergeRotationType_Right: // right
|
pThreadData->m_nTargetPosX = 0;
|
pThreadData->m_nTargetPosY = nTotalMergeHeight;
|
break;
|
}
|
|
// add merge pos
|
if (pThreadData->m_nRotationType==MergeRotationType_None)
|
{
|
nTotalMergeWidth += pThreadData->m_nTargetWidth;
|
}
|
else
|
{
|
nTotalMergeHeight += pThreadData->m_nTargetHeight;
|
}
|
|
vecThreadData.push_back(pThreadData);
|
|
m_nMergeImageCount++;
|
}
|
}
|
|
// create merge image
|
if (m_MergeImage.CreateImage(nTotalMergeWidth, nTotalMergeHeight, 8, nMergeChannels)==FALSE)
|
{
|
m_csMergeImage.Unlock();
|
return 0;
|
}
|
m_csMergeImage.Unlock();
|
|
|
for (VectorMergeThreadDataIt it=vecThreadData.begin(); it!=vecThreadData.end(); it++)
|
{
|
CMergeThreadData *pThreadData = *it;
|
|
if (pThreadData->m_nRotationType==MergeRotationType_Left)
|
{
|
pThreadData->m_nTargetPosY = nTotalMergeHeight - (pThreadData->m_nTargetPosY + pThreadData->m_nTargetHeight);
|
}
|
|
if (CreateWorkThread(pThreadData)==FALSE)
|
{
|
continue;
|
}
|
}
|
|
return m_nMergeImageCount;
|
}
|
|
BOOL CImageMerger::SaveImage( const CString& strFilename, int nQuality )
|
{
|
return m_MergeImage.SaveImage(strFilename, nQuality);
|
}
|
