#include "StdAfx.h"
|
#include "AlignFinder.h"
|
#include "CHImageControls/CHImageProcess.h"
|
#include <tmmintrin.h>
|
#include <smmintrin.h>
|
#include "EdgeFind.h"
|
|
using namespace CHImageControls;
|
|
inline bool CompareMaxSize(SPixelBlob& a, SPixelBlob& b)
|
{
|
return (a.dMatchValue > b.dMatchValue);
|
}
|
|
CAlignFinder::CAlignFinder(int nIndex) : m_nIndex(nIndex)
|
{
|
Reset();
|
}
|
|
CAlignFinder::~CAlignFinder(void)
|
{
|
Reset();
|
}
|
|
void CAlignFinder::Reset()
|
{
|
ResetImages();
|
m_pTempImage = NULL;
|
m_findParam.Reset();
|
}
|
|
void CAlignFinder::ResetImages()
|
{
|
m_SourceImage.ReleaseImage();
|
m_EdgeImage.ReleaseImage();
|
m_ThresImage.ReleaseImage();
|
m_BlobImage.ReleaseImage();
|
m_ResultImage.ReleaseImage();
|
}
|
|
BOOL CAlignFinder::SaveSourceImage(const CString& strFilename)
|
{
|
return m_SourceImage.SaveImage(strFilename);
|
}
|
|
BOOL CAlignFinder::SaveEdgeImage(const CString& strFilename)
|
{
|
return m_EdgeImage.SaveImage(strFilename);
|
}
|
|
BOOL CAlignFinder::SaveThresholdImage(const CString& strFilename)
|
{
|
return m_ThresImage.SaveImage(strFilename);
|
}
|
|
BOOL CAlignFinder::SaveBlobImage(const CString& strFilename)
|
{
|
return m_BlobImage.SaveImage(strFilename);
|
}
|
|
BOOL CAlignFinder::SaveResultImage(const CString& strFilename)
|
{
|
return m_ResultImage.SaveImage(strFilename);
|
}
|
|
BOOL CAlignFinder::GetSourceImage(CCHImageData *pImageData)
|
{
|
return m_SourceImage.CopyImageTo(pImageData);
|
}
|
|
BOOL CAlignFinder::GetEdgeImage(CCHImageData *pImageData)
|
{
|
return m_EdgeImage.CopyImageTo(pImageData);
|
}
|
|
BOOL CAlignFinder::GetThresholdImage(CCHImageData *pImageData)
|
{
|
return m_ThresImage.CopyImageTo(pImageData);
|
}
|
|
BOOL CAlignFinder::GetBlobImage(CCHImageData *pImageData)
|
{
|
return m_BlobImage.CopyImageTo(pImageData);
|
}
|
|
BOOL CAlignFinder::GetResultImage(CCHImageData *pImageData)
|
{
|
return m_ResultImage.CopyImageTo(pImageData);
|
}
|
|
|
|
SAlignFindResult CAlignFinder::FindAlign(CCHImageData *pImageData, const SAlignFindParam& findParam, CCHImageData *pTempImage)
|
{
|
/////////////////////////////////////IMAGE LOAD FOR TEST !!!! /////////////////////
|
// CCHImageData *tempImage = new CCHImageData;
|
// tempImage->LoadImageW(_T("D:\\Align1.BMP"));
|
//
|
// m_pTempImage = pTempImage;
|
// m_findParam = findParam;
|
//
|
// return FindAlign(tempImage, pTempImage
|
|
m_pTempImage = pTempImage;
|
|
m_findParam = findParam;
|
|
return FindAlign(pImageData, pTempImage);
|
}
|
|
SAlignFindResult CAlignFinder::FindAlign(CCHImageData *pImageData, CCHImageData *pTempImage)
|
{
|
m_pTempImage = pTempImage;
|
//¾ó¶óÀÎ ÆÄÀεå
|
if (pImageData==NULL) return SAlignFindResult();
|
|
if (pImageData->GetImageExist()==FALSE) return SAlignFindResult();
|
|
|
|
if (pImageData->GetChannels()!=1) return SAlignFindResult();
|
else
|
{
|
int a = pImageData->GetChannels();
|
}
|
|
return FindAlign((BYTE*)pImageData->GetImageBuffer(), pImageData->GetWidth(), pImageData->GetHeight());
|
}
|
|
|
SAlignFindResult CAlignFinder::FindAlign(BYTE* pImage, int nWidth, int nHeight, const SAlignFindParam& findParam)
|
{
|
m_pTempImage = NULL;
|
|
m_findParam = findParam;
|
|
return FindAlign(pImage, nWidth, nHeight);
|
}
|
|
SAlignFindResult CAlignFinder::FindAlign(BYTE* pImage, int nWidth, int nHeight)
|
{
|
SAlignFindResult findResult;
|
if (pImage==NULL) return findResult;
|
|
ResetImages();
|
|
findResult.nResultCode = 0;
|
|
// step1. Áß°£°á°ú À̹ÌÁö »ý¼º
|
if (m_SourceImage.CreateImage(nWidth, nHeight)==FALSE) return findResult;
|
if (m_EdgeImage.CreateImage(nWidth, nHeight)==FALSE) return findResult;
|
memcpy(m_SourceImage.GetImageBuffer(), pImage, sizeof(BYTE)*nWidth*nHeight);
|
|
// step3. matching
|
if (FindAlignMatching(findResult)==1)
|
{
|
return findResult;
|
}
|
|
/*< LYW 20211013 - #3671 Delete Start >*/
|
// step2. edge find
|
// if (FindAlignEdge(findResult) == 1)
|
// {
|
// return findResult;
|
// }
|
/*< LYW 20211013 - #3671 Delete End >*/
|
|
|
return findResult;
|
}
|
|
int CAlignFinder::FindAlignMatching(SAlignFindResult& findResult)
|
{
|
findResult.nResultProcess = AlignProcess_Match;
|
|
if (m_findParam.bMatchProcess==FALSE)
|
{
|
return 0;
|
}
|
|
if (m_pTempImage==NULL)
|
{
|
findResult.nResultCode = AlignMatch_None;
|
return 0;
|
}
|
|
if (!m_pTempImage->GetImageExist())
|
{
|
findResult.nResultCode = AlignMatch_NoTemplate;
|
return 0;
|
}
|
|
if (m_pTempImage->GetChannels()!=1)
|
{
|
findResult.nResultCode = AlignMatch_NotOneChannels;
|
return 0;
|
}
|
|
double dResultX, dResultY;
|
CCHImageData resultImage;
|
if (CCHImageProcess::ImageMatching(&m_SourceImage, m_pTempImage,
|
dResultX, dResultY, findResult.dMatchValue, &resultImage)!=ResultSuccess)
|
{
|
findResult.nResultCode = AlignMatch_MatchFail;
|
return 0;
|
}
|
|
CCHImageData tempImage;
|
CCHImageProcess::ImageNormalize(&resultImage, &m_BlobImage, 0, 255);
|
|
/*< LYW 20211013 - #3671 Delete Start >*/
|
// if (findResult.dMatchValue < m_findParam.dMatchRate)
|
// {
|
// findResult.nResultCode = AlignMatch_LowScore;
|
// return 0;
|
// }
|
/*< LYW 20211013 - #3671 Delete End >*/
|
|
// step5. Make Result À̹ÌÁö
|
findResult.nResultCode = AlignMatch_Success;
|
double dHalfWidth = double(m_pTempImage->GetWidth()) / 2.0;
|
double dHalfHeight = double(m_pTempImage->GetHeight()) / 2.0;
|
findResult.dPosX = dResultX + dHalfWidth;
|
findResult.dPosY = dResultY + dHalfHeight;
|
|
if (m_SourceImage.CopyImageTo(&m_ResultImage))
|
{
|
m_ResultImage.DrawRectangle(CPoint((int)(dResultX+0.5), (int)(dResultY+0.5)), CPoint((int)(dResultX+m_pTempImage->GetWidth()+0.5), (int)(dResultY+m_pTempImage->GetHeight()+0.5)), RGB(255,255,255), 2);
|
}
|
|
/*< LYW 20211013 - #3671 ADD Start >*/
|
if (findResult.dMatchValue < m_findParam.dMatchRate)
|
{
|
findResult.nResultCode = AlignMatch_LowScore;
|
return 0;
|
}
|
/*< LYW 20211013 - #3671 ADD End >*/
|
return 1;
|
}
|
|
int CAlignFinder::FindAlignEdge(SAlignFindResult& findResult)
|
{
|
findResult.nResultProcess = AlignProcess_Edge;
|
|
if (m_findParam.bEdgeProcess==FALSE)
|
{
|
return AlignEdge_None;
|
}
|
|
// step1. Sobel Edge ¿¬»ê
|
int nWidth = m_SourceImage.GetWidth();
|
int nHeight = m_SourceImage.GetHeight();
|
|
if (ImageSobelEdge((BYTE*)m_SourceImage.GetImageBuffer(), (BYTE*)m_EdgeImage.GetImageBuffer(), nWidth, nHeight)!=1)
|
{
|
findResult.nResultCode = AlignEdge_EdgeFail;
|
return 0;
|
}
|
|
// step2. Binary Threshold ¿¬»ê
|
if (m_EdgeImage.CopyImageTo(&m_ThresImage)==FALSE)
|
{
|
findResult.nResultCode = AlignEdge_None;
|
return 0;
|
}
|
|
if (ImageThresholding((BYTE*)m_ThresImage.GetImageBuffer(), nWidth, nHeight, m_findParam.nEdgeThreshold)!=1)
|
{
|
findResult.nResultCode = AlignEdge_BinaryFail;
|
return 0;
|
}
|
|
// step3. Blob Analysis ¿¬»ê
|
if (m_ThresImage.CopyImageTo(&m_BlobImage)==FALSE)
|
{
|
findResult.nResultCode = AlignEdge_None;
|
return 0;
|
}
|
|
VectorPixelBlob pixelBlob;
|
if (ImageBlobAnalysis((BYTE*)m_BlobImage.GetImageBuffer(), nWidth, nHeight, pixelBlob,
|
m_findParam.nMergeRange, m_findParam.nAlignHeight, m_findParam.nAlignWidth)!=1)
|
{
|
findResult.nResultCode = AlignEdge_BlobFail;
|
return 0;
|
}
|
|
// step4. Blob Matching °ª °è»ê
|
//m_findParam.bMeasureThickness = 1; // Çü¸ñ¾¾ ÀÌ°Å ÁÖ¼® ²À°É¾î¿ä Edge Find ¾ÈµÇ¿ä
|
if (m_findParam.bMeasureThickness)
|
{
|
if (AlignMeasureThickness((BYTE*)m_BlobImage.GetImageBuffer(), nWidth, nHeight, pixelBlob, m_findParam)==0)
|
{
|
if(pixelBlob.size() > 0)
|
{
|
findResult.dMatchValue = pixelBlob[0].dMatchValue;
|
}
|
findResult.nResultCode = AlignEdge_BlobFail;
|
return 0;
|
}
|
}
|
|
findResult.dMatchValue = pixelBlob[0].dMatchValue;
|
if (findResult.dMatchValue<m_findParam.dEdgeRate)
|
{
|
findResult.nResultCode = AlignEdge_LowScore;
|
return 0;
|
}
|
|
// step5. Make Result À̹ÌÁö
|
findResult.nResultCode = AlignEdge_Success;
|
findResult.dPosX = pixelBlob[0].GetCenterX();
|
findResult.dPosY = pixelBlob[0].GetCenterY();
|
if (m_SourceImage.CopyImageTo(&m_ResultImage))
|
{
|
m_ResultImage.DrawRectangle(CPoint(pixelBlob[0].nLeft, pixelBlob[0].nTop), CPoint(pixelBlob[0].nRight, pixelBlob[0].nBottom), RGB(255,255,255), 2);
|
}
|
|
return 1;
|
}
|
|
int CAlignFinder::ImageSobelEdge(BYTE* pSrcImage, BYTE *pDstImage, int nWidth, int nHeight)
|
{
|
if (pSrcImage==NULL || pDstImage==NULL) return 0;
|
|
__m128i zeroData = _mm_setzero_si128();
|
__m128i currentData = _mm_setzero_si128();
|
__m128i sobelData = _mm_set1_epi16(2);
|
__m128i lowUnpack = _mm_setzero_si128(); // low unpack
|
__m128i highUnpack = _mm_setzero_si128(); // high unpack
|
__m128i multiData = _mm_setzero_si128();
|
__m128i TopKernel = _mm_setzero_si128();
|
__m128i BottomKernel = _mm_setzero_si128();
|
__m128i tempData = _mm_setzero_si128();
|
|
register BYTE *pSrcImageX, *pDstImageX;
|
register int nShiftOne, nShiftTwo;
|
register int nY0X2 = 2;
|
register int nY1X0 = nWidth;
|
register int nY1X2 = nWidth + 2;
|
register int nY2X0 = 2*nWidth;
|
register int nY2X2 = 2*nWidth + 2;
|
register int nLast = (nWidth % 8) ? 6: 2;
|
|
for (int y=0; y<nHeight-2; y++)
|
{
|
pSrcImageX = pSrcImage + (y*nWidth);
|
pDstImageX = pDstImage + ((y+1)*nWidth) + 1;
|
|
*(pDstImageX-1) = 0;
|
|
for (int x=0; x<nWidth; x+=8)
|
{
|
// [1] vertical kernel
|
|
// get pixel data (y+2,x)
|
currentData = _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X0));
|
tempData = _mm_unpacklo_epi8(currentData, zeroData); // low
|
highUnpack = _mm_unpackhi_epi8(currentData, zeroData); // high
|
|
nShiftOne = _mm_extract_epi16(highUnpack, 0);
|
nShiftTwo = _mm_extract_epi16(highUnpack, 1);
|
|
// left shift 2byte
|
highUnpack = _mm_srli_si128(tempData, 2);
|
highUnpack = _mm_insert_epi16(highUnpack, nShiftOne, 7);
|
|
// mul * 2
|
multiData = _mm_mullo_epi16(highUnpack, sobelData);
|
|
// left shift 2byte
|
highUnpack = _mm_srli_si128(highUnpack, 2);
|
highUnpack = _mm_insert_epi16(highUnpack, nShiftTwo, 7);
|
|
BottomKernel = _mm_add_epi16(tempData, multiData);
|
BottomKernel = _mm_add_epi16(BottomKernel, highUnpack); // top kernel value
|
|
// get pixel data (y,x)
|
currentData = _mm_loadu_si128((__m128i*)(pSrcImageX));
|
lowUnpack = _mm_unpacklo_epi8(currentData, zeroData); // low
|
highUnpack = _mm_unpackhi_epi8(currentData, zeroData); // high
|
|
nShiftOne = _mm_extract_epi16(highUnpack, 0);
|
nShiftTwo = _mm_extract_epi16(highUnpack, 1);
|
|
// left shift 2byte
|
highUnpack = _mm_srli_si128(lowUnpack, 2);
|
highUnpack = _mm_insert_epi16(highUnpack, nShiftOne, 7);
|
|
// mul * 2
|
multiData = _mm_mullo_epi16(highUnpack, sobelData);
|
|
// left shift 2byte
|
highUnpack = _mm_srli_si128(highUnpack, 2);
|
highUnpack = _mm_insert_epi16(highUnpack, nShiftTwo, 7);
|
|
TopKernel = _mm_add_epi16(lowUnpack, multiData);
|
TopKernel = _mm_add_epi16(TopKernel, highUnpack); // top kernel value
|
|
TopKernel = _mm_sub_epi16(TopKernel, BottomKernel); // top + bottom
|
TopKernel = _mm_abs_epi16(TopKernel); // horizontal result
|
|
// lowUnpack, TopKernel, sobelData, currentData,
|
|
// [1] Horizontal kernel
|
// get pixel data (y+1,x)
|
currentData = _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X0));
|
highUnpack = _mm_unpacklo_epi8(currentData, zeroData); // low
|
highUnpack = _mm_mullo_epi16(highUnpack, sobelData); // mul * 2
|
lowUnpack = _mm_add_epi16(lowUnpack, highUnpack); // add result
|
|
// get pixel data (y+2,x)
|
// currentData = _mm_loadu_si128((__m128i*)(pSrcImage+((y+2)*nWidth)+x));
|
// highUnpack = _mm_unpacklo_epi8(currentData, zeroData); // low
|
lowUnpack = _mm_add_epi16(lowUnpack, tempData); // add result
|
|
// get pixel data (y,x+2)
|
currentData = _mm_loadu_si128((__m128i*)(pSrcImageX+nY0X2));
|
highUnpack = _mm_unpacklo_epi8(currentData, zeroData); // low
|
lowUnpack = _mm_sub_epi16(lowUnpack, highUnpack); // sub result
|
|
// get pixel data (y+1,x+2)
|
currentData = _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X2));
|
highUnpack = _mm_unpacklo_epi8(currentData, zeroData); // low
|
highUnpack = _mm_mullo_epi16(highUnpack, sobelData); // mul * 2
|
lowUnpack = _mm_sub_epi16(lowUnpack, highUnpack); // sub result
|
|
// get pixel data (y+2,x+2)
|
currentData = _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X2));
|
highUnpack = _mm_unpacklo_epi8(currentData, zeroData); // low
|
lowUnpack = _mm_sub_epi16(lowUnpack, highUnpack); // sub result
|
|
lowUnpack = _mm_abs_epi16(lowUnpack); // abs result
|
TopKernel = _mm_add_epi16(TopKernel, lowUnpack); // add horizontal + vertical
|
|
TopKernel = _mm_srai_epi16(TopKernel, 1); // shift right 1 <add>
|
|
TopKernel = _mm_packus_epi16(TopKernel, TopKernel); // last result
|
|
_mm_storel_epi64( (__m128i*)(pDstImageX), TopKernel);
|
|
pSrcImageX += 8;
|
pDstImageX += 8;
|
}
|
|
*(pDstImageX-nLast) = 0;
|
}
|
|
memset(pDstImage, 0, nWidth);
|
memset(pDstImage+((nHeight-1)*nWidth), 0, nWidth);
|
|
return 1;
|
}
|
|
int CAlignFinder::ImageThresholding(BYTE* pImage, int nWidth, int nHeight, int nThresValue)
|
{
|
if (pImage==NULL) return 0;
|
|
register BYTE *pBuffer = pImage;
|
|
__m128i _x80 = _mm_set1_epi8('\x80');
|
__m128i ThresData = _mm_set1_epi8(UCHAR(nThresValue)^0x80);
|
__m128i v0, v1;
|
|
register int i;
|
register int nTotalSize = nWidth*nHeight;
|
|
for(i=0; i<=nTotalSize-32; i+=32 )
|
{
|
v0 = _mm_loadu_si128( (const __m128i*)(pBuffer) );
|
v1 = _mm_loadu_si128( (const __m128i*)(pBuffer+16) );
|
v0 = _mm_cmpgt_epi8( _mm_xor_si128(v0, _x80), ThresData );
|
v1 = _mm_cmpgt_epi8( _mm_xor_si128(v1, _x80), ThresData );
|
_mm_storeu_si128( (__m128i*)(pBuffer), v0 );
|
_mm_storeu_si128( (__m128i*)(pBuffer+16), v1 );
|
pBuffer+=32;
|
}
|
|
for( ; i <=nTotalSize-8; i+=8 )
|
{
|
v0 = _mm_loadl_epi64( (const __m128i*)(pBuffer) );
|
v0 = _mm_cmpgt_epi8( _mm_xor_si128(v0, _x80), ThresData );
|
_mm_storel_epi64( (__m128i*)(pBuffer), v0 );
|
pBuffer+=8;
|
}
|
|
for (; i<nTotalSize; i++)
|
{
|
*(pBuffer++) = (*pBuffer>nThresValue) ? 255: 0;
|
}
|
|
return 1;
|
}
|
|
int CAlignFinder::ImageBlobAnalysis(BYTE *pImage, int nWidth, int nHeight, VectorPixelBlob& vectorBlob, int nBlob, int nAlignWidth, int nAlignHeight)
|
{
|
if (pImage==NULL) return 0;
|
|
int i, j, y, x;
|
|
// top & bottom margin
|
BYTE *pBuf1 = pImage;
|
BYTE *pBuf2 = pImage + (nHeight-1)*nWidth;
|
for (i=0; i<nBlob; i++)
|
{
|
memset(pBuf1, 0, sizeof(BYTE)*nWidth);
|
memset(pBuf2, 0, sizeof(BYTE)*nWidth);
|
pBuf1 += nWidth;
|
pBuf2 -= nWidth;
|
}
|
|
// left & right margin
|
pBuf1 = pImage;
|
for (i=0; i<nHeight; i++)
|
{
|
memset(pBuf1, 0, sizeof(BYTE)*nBlob);
|
memset(pBuf1+(nWidth-nBlob-1), 0, sizeof(BYTE)*nBlob);
|
pBuf1 += nWidth;
|
}
|
|
const int nWeightCount = 4;
|
double pWeight[nWeightCount] = {0.3, 0.3, 0.4, 0.0};
|
double pDistValue[nWeightCount];
|
double dAlignRatio = double(nAlignWidth)/float(nAlignHeight);
|
|
size_t nSize;
|
std::vector<CPoint> vectorPixel;
|
SPixelBlob pixelBlob;
|
register BYTE *pSrcImgY = pImage + (nBlob*nWidth) + nBlob;
|
register BYTE *pSrcImgX, *pSubX, *pSubY;
|
|
int nBlobMin = -nBlob;
|
int nBlobMax = nBlob+1;
|
|
for (i=nBlob; i<nHeight-nBlob; i++)
|
{
|
pSrcImgX = pSrcImgY;
|
for (j=nBlob; j<nWidth-nBlob; j++)
|
{
|
if (*pSrcImgX > 200)
|
{
|
*pSrcImgX = 128;
|
vectorPixel.push_back(CPoint(j, i));
|
|
// new pixel blob
|
pixelBlob.Reset();
|
|
while ((nSize=vectorPixel.size())>0)
|
{
|
x = vectorPixel[nSize-1].x;
|
y = vectorPixel[nSize-1].y;
|
|
// delete end point
|
vectorPixel.pop_back();
|
|
// add point to blob
|
pixelBlob.vectorPoint.push_back(CPoint(x, y));
|
|
// get current point
|
pSubY = pImage + ((y+nBlobMin)*nWidth) + (x+nBlobMin);
|
|
for (int sy=nBlobMin; sy<nBlobMax; sy++)
|
{
|
pSubX = pSubY;
|
for (int sx=nBlobMin; sx<nBlobMax; sx++)
|
{
|
if (*pSubX > 200)
|
{
|
*pSubX = 128;
|
vectorPixel.push_back(CPoint(x+sx, y+sy));
|
}
|
pSubX++;
|
}
|
pSubY += nWidth;
|
}
|
|
if (pixelBlob.nLeft>x) pixelBlob.nLeft = x;
|
if (pixelBlob.nRight<x) pixelBlob.nRight = x;
|
if (pixelBlob.nTop>y) pixelBlob.nTop = y;
|
if (pixelBlob.nBottom<y) pixelBlob.nBottom = y;
|
}
|
|
vectorPixel.clear();
|
|
// calculate blob match value
|
pDistValue[0] = double(nAlignWidth - pixelBlob.GetWidth()) / double(nAlignWidth); // width size
|
pDistValue[1] = double(nAlignHeight - pixelBlob.GetHeight()) / double(nAlignHeight); // height size
|
// (align_ratio - blob_ratio) / align_ratio
|
pDistValue[2] = ( dAlignRatio-(double(pixelBlob.GetWidth())/double(pixelBlob.GetHeight())) ) / dAlignRatio;
|
|
for (int i=0; i<nWeightCount; i++)
|
{
|
pDistValue[i] = (pDistValue[i] < 0.0) ? -pDistValue[i]: pDistValue[i]; // abs
|
pDistValue[i] = 1.0 - pDistValue[i]; // 1 - value
|
pDistValue[i] = (pDistValue[i] < 0.0) ? 0.0: pDistValue[i]; // min(0, value)
|
|
pixelBlob.dMatchValue += (pDistValue[i] * pWeight[i]);
|
}
|
|
vectorBlob.push_back(pixelBlob);
|
|
} // end if
|
pSrcImgX++;
|
} //end for j
|
pSrcImgY += nWidth;
|
}// end for i
|
|
if (vectorBlob.size()==0) return 0;
|
|
// sort blob max size
|
std::sort(vectorBlob.begin(), vectorBlob.end(), CompareMaxSize);
|
|
return 1;
|
}
|
|
SThicknessResult CAlignFinder::FindAlignMarkThickness(BYTE *pProcImg, int nWidth, int nHeight, CPoint ptResult, int nRefWidth, int nRefHeight)
|
{
|
SThicknessResult MeasureResult;
|
|
if(ptResult.x < nRefWidth / 2
|
|| ptResult.x > nWidth - nRefWidth / 2
|
|| ptResult.y < nRefHeight / 2
|
|| ptResult.y > nHeight - nRefHeight / 2)
|
return MeasureResult;
|
|
CRect rtROI;
|
const int nBaseWidth = nRefWidth / 9;
|
const int nBaseHeight = nRefHeight / 9;
|
|
//Left
|
rtROI.left = ptResult.x - nRefWidth / 2 + nBaseWidth;
|
rtROI.top = ptResult.y - nRefHeight / 2;
|
rtROI.right = rtROI.left + nBaseWidth;
|
rtROI.bottom = rtROI.top + nRefHeight;
|
|
MeasureResult.rtSizeL.left = rtROI.left;
|
MeasureResult.rtSizeL.right = rtROI.right;
|
MeasureResult.rtSizeL.top = CEdgeFind::ImageProjection_Vert(pProcImg, nWidth, nHeight, rtROI, 100, 5, 1);
|
MeasureResult.rtSizeL.bottom = CEdgeFind::ImageProjection_Vert_R(pProcImg, nWidth, nHeight, rtROI, 100, 5, 1);
|
|
//Right
|
rtROI.right = ptResult.x + nRefWidth / 2 - nBaseWidth;
|
rtROI.left = rtROI.right - nBaseWidth;
|
|
MeasureResult.rtSizeR.left = rtROI.left;
|
MeasureResult.rtSizeR.right = rtROI.right;
|
MeasureResult.rtSizeR.top = CEdgeFind::ImageProjection_Vert(pProcImg, nWidth, nHeight, rtROI, 100, 5, 1);
|
MeasureResult.rtSizeR.bottom = CEdgeFind::ImageProjection_Vert_R(pProcImg, nWidth, nHeight, rtROI, 100, 5, 1);
|
|
//top
|
rtROI.left = ptResult.x - nRefWidth / 2;
|
rtROI.top = ptResult.y - nRefHeight / 2 + nBaseHeight;
|
rtROI.right = rtROI.left + nRefWidth;
|
rtROI.bottom = rtROI.top + nBaseHeight;
|
|
MeasureResult.rtSizeT.top = rtROI.top;
|
MeasureResult.rtSizeT.bottom = rtROI.bottom;
|
MeasureResult.rtSizeT.left = CEdgeFind::ImageProjection(pProcImg, nWidth, nHeight, rtROI, 100, 5, 1);
|
MeasureResult.rtSizeT.right = CEdgeFind::ImageProjection_R(pProcImg, nWidth, nHeight, rtROI, 100, 5, 1);
|
|
//bottom
|
rtROI.bottom = ptResult.y + nRefHeight / 2 - nBaseHeight;
|
rtROI.top = rtROI.bottom - nBaseHeight;
|
|
MeasureResult.rtSizeB.top = rtROI.top;
|
MeasureResult.rtSizeB.bottom = rtROI.bottom;
|
MeasureResult.rtSizeB.left = CEdgeFind::ImageProjection(pProcImg, nWidth, nHeight, rtROI, 100, 5, 1);
|
MeasureResult.rtSizeB.right = CEdgeFind::ImageProjection_R(pProcImg, nWidth, nHeight, rtROI, 100, 5, 1);
|
|
return MeasureResult;
|
}
|
|
int CAlignFinder::AlignMeasureThickness( BYTE *pImage, int nWidth, int nHeight, VectorPixelBlob& vectorBlob, const SAlignFindParam& sAlignFindParam )
|
{
|
int nLRThickness = sAlignFindParam.nEDThicknessLR;
|
int nTBThickness = sAlignFindParam.nEDThicknessTB;
|
int nThicknessRange = sAlignFindParam.nEDThicknessRange;
|
|
VectorPixelBlob vecResult;
|
|
for (VectorPixelBlobIt it=vectorBlob.begin(); it!=vectorBlob.end(); it++)
|
{
|
// check score
|
if (it->dMatchValue >= sAlignFindParam.dEdgeRate)
|
{
|
|
CPoint ptResult;
|
ptResult.x = it->GetCenterX();
|
ptResult.y = it->GetCenterY();
|
|
it->sThicknessResult = FindAlignMarkThickness(pImage, nWidth, nHeight, ptResult, it->GetWidth(), it->GetHeight());
|
|
int lh = it->sThicknessResult.rtSizeL.Height();
|
int rh = it->sThicknessResult.rtSizeR.Height();
|
int tw = it->sThicknessResult.rtSizeT.Width();
|
int bw = it->sThicknessResult.rtSizeB.Width();
|
if(it->sThicknessResult.IsAllSuccess() == FALSE
|
/* || it->sThicknessResult.rtSizeL.Height() > nLRThickness + nThicknessRange
|
|| it->sThicknessResult.rtSizeL.Height() < nLRThickness - nThicknessRange
|
|| it->sThicknessResult.rtSizeR.Height() > nLRThickness + nThicknessRange
|
|| it->sThicknessResult.rtSizeR.Height() < nLRThickness - nThicknessRange
|
|| it->sThicknessResult.rtSizeT.Width() > nTBThickness + nThicknessRange
|
|| it->sThicknessResult.rtSizeT.Width() < nTBThickness - nThicknessRange
|
|| it->sThicknessResult.rtSizeB.Width() > nTBThickness + nThicknessRange
|
|| it->sThicknessResult.rtSizeB.Width() < nTBThickness - nThicknessRange
|
*/
|
|| lh > nLRThickness + nThicknessRange
|
|| lh < nLRThickness - nThicknessRange
|
|| rh > nLRThickness + nThicknessRange
|
|| rh < nLRThickness - nThicknessRange
|
|| tw > nTBThickness + nThicknessRange
|
|| tw < nTBThickness - nThicknessRange
|
|| bw > nTBThickness + nThicknessRange
|
|| bw < nTBThickness - nThicknessRange
|
)
|
{
|
continue;
|
}
|
|
vecResult.push_back(*it);
|
}
|
}
|
|
vectorBlob = vecResult;
|
|
return (int)vectorBlob.size();
|
}
|
