#include "StdAfx.h"
|
#include "BlobStorage.h"
|
#include "math.h"
|
|
#include "StopWatch3.h"
|
|
|
|
|
CBlobStorage::CBlobStorage(void)
|
{
|
m_nBlobSpace= m_maxBlob= m_nBlob= 0;
|
m_pBlobDefect= NULL;
|
}
|
CBlobStorage::~CBlobStorage(void)
|
{
|
if(m_pBlobDefect)
|
delete[] m_pBlobDefect;
|
}
|
|
void CBlobStorage::ResetBlobStorage()
|
{
|
m_nSkipUnpaired = 0;
|
m_nSkipClassify = 0;
|
m_nMoveClassify = 0;
|
m_nSkipMerged = 0;
|
|
int i;
|
int nBlob;
|
|
if(m_nBlobSpace < m_nBlob)
|
nBlob= m_nBlobSpace;
|
else
|
nBlob= m_nBlob;
|
|
for(i= 0; i< nBlob; i++)
|
{
|
m_pBlobDefect[i].Reset();
|
}
|
m_nBlob= 0;
|
}
|
void CBlobStorage::TotalResetBlobStorage()
|
{
|
|
m_nSkipUnpaired = 0;
|
m_nSkipClassify = 0;
|
m_nMoveClassify = 0;
|
m_nSkipMerged = 0;
|
|
int i;
|
for(i= 0; i< m_maxBlob; i++)
|
{
|
m_pBlobDefect[i].Reset();
|
}
|
m_nBlob= 0;
|
}
|
|
|
int CBlobStorage::InitBlobStorage(int maxBlob)
|
{
|
if(maxBlob <= m_nBlobSpace)
|
{
|
m_maxBlob= maxBlob;
|
return m_maxBlob;
|
}
|
|
if(m_pBlobDefect != NULL)
|
{
|
delete[] m_pBlobDefect;
|
}
|
|
// 16°³ÀÇ ¿©ºÐÀ» µÐ´Ù..¿Ö? ³»¸É..
|
int BlobSapce= maxBlob+ 16;
|
m_pBlobDefect= new CDefectBlob[BlobSapce];
|
|
|
if(m_pBlobDefect == NULL)
|
{
|
m_maxBlob= m_nBlobSpace= 0;
|
return m_maxBlob;
|
}
|
|
|
m_maxBlob= m_nBlobSpace= maxBlob;
|
|
TotalResetBlobStorage();// ÃʱâÈ ½Ã°£ ´ÜÃàÀ» À§ÇØ TotalReset °è¿ ÇÔ¼ö Ãß°¡.
|
|
return m_maxBlob;
|
}
|
|
DIT_RESULT CBlobStorage::BlobDefectVert()
|
{
|
DIT_RESULT Ret = DIT_CONV_SUCCESS;
|
|
CStopWatch stopWatch;
|
stopWatch.Start();
|
int x, y;
|
|
|
// Index ¸Å±â±â.
|
ZeroMemory(m_bMerged, m_nPair * sizeof(BOOL));
|
ZeroMemory(m_bTemp, m_nPair * sizeof(BOOL));
|
for (x = 0; x < m_nPair; x++)
|
m_lFirstIndex[x] = x;
|
|
|
CDefectPair *pPair;
|
CDefectPair *pPairNext;
|
m_nSkipClassify= 0;
|
// ÀÎÁ¢ µðÆå ¸ÓÁöÇϱâ.
|
|
// 0. °áÇÔ Çȼ¿ ¹à±â ¿Ö°î º¸Á¤.
|
CPairStorage::CorrectDefGray();
|
// 1. Filtering Pairing to Delete.
|
CPairStorage::Filtering_Vert();
|
|
// 2. Áö¿ì°í ³²Àº Pairing Blob Index ¸¸µé±â.
|
int idx, idy;
|
for(x = 0; x < m_nPair; x++)
|
{
|
pPair= m_pPairDefect+ x;
|
if(pPair->s_DefectType == DEFTYPE_DELETE)
|
continue;
|
|
for (y = x + 1; y < m_nPair; y++)
|
{
|
pPairNext= m_pPairDefect+ y;
|
if(pPairNext->s_DefectType == DEFTYPE_DELETE)
|
continue;
|
|
if (m_bMerged[y] || (pPair->s_DefectType != pPairNext->s_DefectType))
|
continue;
|
|
idx= pPairNext->s_nDefectX- pPair->s_nDefectX;
|
idy= pPairNext->s_nDefectY- pPair->s_nDefectY;
|
|
if(idx > 16)
|
break;
|
|
if((idy > 3 || idy < -3)) //
|
continue;
|
if((idx > 3 || idx < -3)) //
|
continue;
|
|
|
m_lFirstIndex[y] = m_lFirstIndex[x];
|
m_bMerged[y] = TRUE;
|
}
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
int nStart = m_nBlob;
|
|
// µðÆåµéÀÇ ¼ö¸¸Å ó¸®. - Blobing
|
int nBlobNum = 0;
|
int nLevelDiff = 0;
|
|
CDefectBlob *pBlob= m_pBlobDefect+ m_nBlob;
|
CDefectBlob *pBlobNext;
|
for (x = 0; x < m_nPair; x++)
|
{
|
pPair= m_pPairDefect+ x;
|
if (pPair->s_DefectType == DEFTYPE_DELETE)
|
{
|
m_nSkipClassify++;
|
continue;
|
}
|
|
if (!m_bTemp[m_lFirstIndex[x]]) // óÀ½ ³ªÅ¸³ °áÇÔ Ã³¸®.
|
{
|
if (m_nBlob >= m_maxBlob)
|
continue;
|
|
// 20150811 °Å´ë CS
|
//////////////////////////////////////////////////////////////////////////
|
//Junho °Å´ëCS
|
if(pPair->s_nZone != 0) // ZONEÀÌ ¾øÀ¸¸é °Å´ë CS´Â ÇÏÁö ¾Ê´Â´Ù.
|
{
|
if(m_Param.m_nCSThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_BLACK)
|
{
|
if(pPair->s_nGraySrc >= m_Param.m_nCSThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
if(m_Param.m_nOriThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_WHITE)
|
{
|
nLevelDiff = static_cast<int>(pPair->s_nGraySrc - pPair->s_nGrayRef);
|
if(nLevelDiff < m_Param.m_nOriThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
}
|
//////////////////////////////////////////////////////////////////////////
|
|
m_bTemp[m_lFirstIndex[x]] = TRUE;
|
|
pBlob->CreateBlob(pPair, m_lFirstIndex[x]);
|
|
|
m_nBlob++;
|
nBlobNum++;
|
pBlob= m_pBlobDefect+ m_nBlob;
|
}
|
else // ³ªÁß¿¡ ³ªÅ¸³ °áÇÔ Ã³¸®.
|
{
|
for(y = m_nBlob - 1; y >= 0; y--)
|
{
|
pBlobNext= m_pBlobDefect+ y;
|
if (pBlobNext->s_nIndex == m_lFirstIndex[x])
|
{
|
// 20150811 °Å´ë CS
|
//////////////////////////////////////////////////////////////////////////
|
//Junho °Å´ëCS
|
if(pPair->s_nZone != 0) // ZONEÀÌ ¾øÀ¸¸é °Å´ë CS´Â ÇÏÁö ¾Ê´Â´Ù.
|
{
|
if(m_Param.m_nCSThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_BLACK)
|
{
|
if(pPair->s_nGraySrc >= m_Param.m_nCSThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
if(m_Param.m_nOriThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_WHITE)
|
{
|
nLevelDiff = static_cast<int>(pPair->s_nGraySrc - pPair->s_nGrayRef);
|
if(nLevelDiff < m_Param.m_nOriThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
}
|
//////////////////////////////////////////////////////////////////////////
|
|
pBlobNext->IncludePair(pPair);
|
break;
|
}
|
}
|
}
|
}
|
|
// ÁÂÇ¥ º¸Á¤.
|
for (x = nStart; x < m_nBlob; x++)
|
{
|
pBlob= m_pBlobDefect+ x;
|
if (pBlob->s_nDefectArea > 0)
|
{
|
pBlob->s_nDefectX = pBlob->s_nDefectX / pBlob->s_nDefectArea;
|
pBlob->s_nDefectY = pBlob->s_nDefectY / pBlob->s_nDefectArea;
|
pBlob->s_sLevelSrcAvg = pBlob->s_nLevelSrcSum / pBlob->s_nDefectArea;
|
pBlob->s_sLevelRefAvg = pBlob->s_nLevelRefSum / pBlob->s_nDefectArea;
|
pBlob->s_sLevelDiffAvg = pBlob->s_nLevelDiffSum / pBlob->s_nDefectArea;
|
pBlob->s_sThresholdAvg = pBlob->s_nThresholdSum / pBlob->s_nDefectArea;
|
|
pBlob->s_nRegionType = m_Param.s_nRegionType;
|
pBlob->s_nDefectRScale = CalcRScale(pBlob->s_ptVertex);
|
}
|
else
|
pBlob->s_bRemoved = TRUE;
|
}
|
|
stopWatch.End();
|
m_BlobTime= stopWatch.GetDurationMilliSecond();
|
return Ret;
|
}
|
|
DIT_RESULT CBlobStorage::BlobDefectVert(CPairStorage *pPairStrg)
|
{
|
DIT_RESULT Ret = DIT_CONV_SUCCESS;
|
|
// °áÇÔ Çȼ¿ ¹à±â ¿Ö°î º¸Á¤.
|
pPairStrg->CorrectDefGray();
|
// PairDefect ÇÊÅ͸µÇϱâ.
|
pPairStrg->Filtering_Vert();
|
|
int x, y;
|
|
int nPair= m_nPair;
|
CDefectPair *pPairDefect= m_pPairDefect;
|
if(pPairStrg != NULL)
|
{
|
nPair= pPairStrg->m_nPair;
|
pPairDefect= pPairStrg->m_pPairDefect;
|
}
|
|
|
// Index ¸Å±â±â.
|
ZeroMemory(m_bMerged, nPair * sizeof(BOOL));
|
ZeroMemory(m_bTemp, nPair * sizeof(BOOL));
|
for (x = 0; x < nPair; x++)
|
m_lFirstIndex[x] = x;
|
|
|
CDefectPair *pPair;
|
CDefectPair *pPairNext;
|
m_nSkipClassify= 0;
|
// ÀÎÁ¢ µðÆå ¸ÓÁöÇϱâ.
|
|
|
int idx, idy;
|
for(x = 0; x < nPair; x++)
|
{
|
pPair= pPairDefect+ x;
|
if(pPair->s_DefectType == DEFTYPE_DELETE)
|
continue;
|
|
for (y = x + 1; y < nPair; y++)
|
{
|
pPairNext= pPairDefect+ y;
|
if(pPairNext->s_DefectType == DEFTYPE_DELETE)
|
continue;
|
|
if (m_bMerged[y] || pPair->s_DefectType != pPairNext->s_DefectType)
|
continue;
|
|
idx= pPairNext->s_nDefectX- pPair->s_nDefectX;
|
idy= pPairNext->s_nDefectY- pPair->s_nDefectY;
|
|
if(idx > 16)
|
break;
|
|
if((idy > 3 || idy < -3)) //
|
continue;
|
if((idx > 3 || idx < -3)) //
|
continue;
|
|
|
m_lFirstIndex[y] = m_lFirstIndex[x];
|
m_bMerged[y] = TRUE;
|
}
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
int nStart = m_nBlob;
|
|
// µðÆåµéÀÇ ¼ö¸¸Å ó¸®. - Blobing
|
int nBlobNum = 0;
|
int nLevelDiff = 0;
|
|
CDefectBlob *pBlob= m_pBlobDefect+ m_nBlob;
|
CDefectBlob *pBlobNext;
|
for (x = 0; x < nPair; x++)
|
{
|
pPair= pPairDefect+ x;
|
if (pPair->s_DefectType == DEFTYPE_DELETE)
|
{
|
m_nSkipClassify++;
|
continue;
|
}
|
|
if (!m_bTemp[m_lFirstIndex[x]]) // óÀ½ ³ªÅ¸³ °áÇÔ Ã³¸®.
|
{
|
if (m_nBlob >= m_maxBlob)
|
continue;
|
|
// 20150811 °Å´ë CS
|
//////////////////////////////////////////////////////////////////////////
|
//Junho °Å´ëCS
|
if(pPair->s_nZone != 0) // ZONEÀÌ ¾øÀ¸¸é °Å´ë CS´Â ÇÏÁö ¾Ê´Â´Ù.
|
{
|
if(m_Param.m_nCSThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_BLACK)
|
{
|
if(pPair->s_nGraySrc >= m_Param.m_nCSThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
if(m_Param.m_nOriThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_WHITE)
|
{
|
nLevelDiff = static_cast<int>(pPair->s_nGraySrc - pPair->s_nGrayRef);
|
if(nLevelDiff < m_Param.m_nOriThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
}
|
//////////////////////////////////////////////////////////////////////////
|
|
m_bTemp[m_lFirstIndex[x]] = TRUE;
|
|
pBlob->CreateBlob(pPair, m_lFirstIndex[x]);
|
|
|
m_nBlob++;
|
nBlobNum++;
|
pBlob= m_pBlobDefect+ m_nBlob;
|
}
|
else // ³ªÁß¿¡ ³ªÅ¸³ °áÇÔ Ã³¸®.
|
{
|
for(y = m_nBlob - 1; y >= 0; y--)
|
{
|
pBlobNext= m_pBlobDefect+ y;
|
if (pBlobNext->s_nIndex == m_lFirstIndex[x])
|
{
|
|
// 20150811 °Å´ë CS
|
//////////////////////////////////////////////////////////////////////////
|
//Junho °Å´ëCS
|
if(pPair->s_nZone != 0) // ZONEÀÌ ¾øÀ¸¸é °Å´ë CS´Â ÇÏÁö ¾Ê´Â´Ù.
|
{
|
if(m_Param.m_nCSThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_BLACK)
|
{
|
if(pPair->s_nGraySrc >= m_Param.m_nCSThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
if(m_Param.m_nOriThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_WHITE)
|
{
|
nLevelDiff = static_cast<int>(pPair->s_nGraySrc - pPair->s_nGrayRef);
|
if(nLevelDiff < m_Param.m_nOriThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
}
|
//////////////////////////////////////////////////////////////////////////
|
|
pBlobNext->IncludePair(pPair);
|
break;
|
}
|
}
|
}
|
}
|
|
// ÁÂÇ¥ º¸Á¤.
|
for (x = nStart; x < m_nBlob; x++)
|
{
|
pBlob= m_pBlobDefect+ x;
|
if (pBlob->s_nDefectArea > 0)
|
{
|
pBlob->s_nDefectX = pBlob->s_nDefectX / pBlob->s_nDefectArea;
|
pBlob->s_nDefectY = pBlob->s_nDefectY / pBlob->s_nDefectArea;
|
pBlob->s_sLevelSrcAvg = pBlob->s_nLevelSrcSum / pBlob->s_nDefectArea;
|
pBlob->s_sLevelRefAvg = pBlob->s_nLevelRefSum / pBlob->s_nDefectArea;
|
pBlob->s_sLevelDiffAvg = pBlob->s_nLevelDiffSum / pBlob->s_nDefectArea;
|
pBlob->s_sThresholdAvg = pBlob->s_nThresholdSum / pBlob->s_nDefectArea;
|
|
pBlob->s_nRegionType = m_Param.s_nRegionType;
|
pBlob->s_nDefectRScale = CalcRScale(pBlob->s_ptVertex);
|
}
|
else
|
pBlob->s_bRemoved = TRUE;
|
}
|
|
|
return Ret;
|
}
|
|
DIT_RESULT CBlobStorage::BlobDefect()
|
{
|
DIT_RESULT Ret = DIT_CONV_SUCCESS;
|
|
int x, y;
|
|
// Index ¸Å±â±â.
|
ZeroMemory(m_bMerged, m_nPairSpace * sizeof(BOOL));
|
ZeroMemory(m_bTemp, m_nPairSpace * sizeof(BOOL));
|
for (x = 0; x < m_nPair; x++)
|
m_lFirstIndex[x] = x;
|
|
|
CDefectPair *pPair;
|
CDefectPair *pPairNext;
|
m_nSkipClassify= 0;
|
|
// °áÇÔ Çȼ¿ ¹à±â ¿Ö°î º¸Á¤.
|
CPairStorage::CorrectDefGray();
|
// PairDefect ÇÊÅ͸µÇϱâ.
|
CPairStorage::Filtering_Hori();
|
|
|
for(x = 0; x < m_nPair; x++)
|
{
|
pPair= m_pPairDefect+ x;
|
if(pPair->s_DefectType == DEFTYPE_DELETE)
|
continue;
|
|
for (y = x + 1; y < m_nPair; y++)
|
{
|
pPairNext= m_pPairDefect+ y;
|
if(pPairNext->s_DefectType == DEFTYPE_DELETE)
|
continue;
|
|
if (m_bMerged[y] || pPair->s_DefectType != pPairNext->s_DefectType)
|
continue;
|
|
if (pPairNext->s_nDefectY - pPair->s_nDefectY > 1) // y´Â xº¸´Ù Å©´Ù.
|
break;
|
|
if (pPairNext->s_nDefectX - pPair->s_nDefectX > 1
|
|| pPairNext->s_nDefectX - pPair->s_nDefectX < -1)
|
continue;
|
|
m_lFirstIndex[y] = m_lFirstIndex[x];
|
m_bMerged[y] = TRUE;
|
}
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
int nStart = m_nBlob;
|
|
// µðÆåµéÀÇ ¼ö¸¸Å ó¸®. - Blobing
|
int nBlobNum = 0;
|
int nLevelDiff = 0;
|
|
CDefectBlob *pBlob= m_pBlobDefect+ m_nBlob;
|
CDefectBlob *pBlobNext;
|
for (x = 0; x < m_nPair; x++)
|
{
|
pPair= m_pPairDefect+ x;
|
if (pPair->s_DefectType == DEFTYPE_DELETE)
|
{
|
m_nSkipClassify++;
|
continue;
|
}
|
|
if (!m_bTemp[m_lFirstIndex[x]]) // óÀ½ ³ªÅ¸³ °áÇÔ Ã³¸®.
|
{
|
if (m_nBlob >= m_maxBlob)
|
continue;
|
|
// 20150811 °Å´ë CS
|
//////////////////////////////////////////////////////////////////////////
|
//Junho °Å´ëCS
|
if(pPair->s_nZone != 0) // ZONEÀÌ ¾øÀ¸¸é °Å´ë CS´Â ÇÏÁö ¾Ê´Â´Ù.
|
{
|
if(m_Param.m_nCSThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_BLACK)
|
{
|
if(pPair->s_nGraySrc >= m_Param.m_nCSThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
if(m_Param.m_nOriThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_WHITE)
|
{
|
nLevelDiff = static_cast<int>(pPair->s_nGraySrc - pPair->s_nGrayRef);
|
if(nLevelDiff < m_Param.m_nOriThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
}
|
//////////////////////////////////////////////////////////////////////////
|
m_bTemp[m_lFirstIndex[x]] = TRUE;
|
|
pBlob->CreateBlob(pPair, m_lFirstIndex[x]);
|
|
|
m_nBlob++;
|
nBlobNum++;
|
pBlob= m_pBlobDefect+ m_nBlob;
|
}
|
else // ³ªÁß¿¡ ³ªÅ¸³ °áÇÔ Ã³¸®.
|
{
|
for(y = m_nBlob - 1; y >= 0; y--)
|
{
|
pBlobNext= m_pBlobDefect+ y;
|
if (pBlobNext->s_nIndex != m_lFirstIndex[x])
|
continue;
|
|
// 20150811 °Å´ë CS
|
//////////////////////////////////////////////////////////////////////////
|
//Junho °Å´ëCS
|
if(pPair->s_nZone != 0) // ZONEÀÌ ¾øÀ¸¸é °Å´ë CS´Â ÇÏÁö ¾Ê´Â´Ù.
|
{
|
if(m_Param.m_nCSThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_BLACK)
|
{
|
if(pPair->s_nGraySrc >= m_Param.m_nCSThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
if(m_Param.m_nOriThres[pPair->s_nZone] != 0)
|
{
|
if(pPair->s_DefectType == DEFTYPE_WHITE)
|
{
|
nLevelDiff = static_cast<int>(pPair->s_nGraySrc - pPair->s_nGrayRef);
|
if(nLevelDiff < m_Param.m_nOriThres[pPair->s_nZone])
|
{
|
pPair->s_DefectType = DEFTYPE_DELETE;
|
m_nSkipClassify++;
|
continue;
|
}
|
}
|
}
|
}
|
//////////////////////////////////////////////////////////////////////////
|
|
pBlobNext->IncludePair(pPair);
|
|
break;
|
}
|
}
|
}
|
|
// ÁÂÇ¥ º¸Á¤.
|
for (x = nStart; x < m_nBlob; x++)
|
{
|
pBlob= m_pBlobDefect+ x;
|
if (pBlob->s_nDefectArea > 0)
|
{
|
pBlob->s_nDefectX = pBlob->s_nDefectX / pBlob->s_nDefectArea;
|
pBlob->s_nDefectY = pBlob->s_nDefectY / pBlob->s_nDefectArea;
|
pBlob->s_sLevelSrcAvg = pBlob->s_nLevelSrcSum / pBlob->s_nDefectArea;
|
pBlob->s_sLevelRefAvg = pBlob->s_nLevelRefSum / pBlob->s_nDefectArea;
|
pBlob->s_sLevelDiffAvg = pBlob->s_nLevelDiffSum / pBlob->s_nDefectArea;
|
pBlob->s_sThresholdAvg = pBlob->s_nThresholdSum / pBlob->s_nDefectArea;
|
|
pBlob->s_nRegionType = m_Param.s_nRegionType;
|
pBlob->s_nDefectRScale = CalcRScale(pBlob->s_ptVertex);
|
}
|
else
|
pBlob->s_bRemoved = TRUE;
|
}
|
|
|
return Ret;
|
}
|
|
void CBlobStorage::ShadowFilterVert(int nStart, double yPitch)
|
{
|
CDefectBlob *pBlob;
|
CDefectBlob *pBlobNext;
|
int x, y;
|
|
// Shadow Filtering : unpairÀÇ °æ¿ì... pitch °Ç³Ê¿¡ °áÇÔÀÌ ÀÖ´Ù¸é.. unpair¸¦ Á¦°Å ÇÏ°Ú´Ù.
|
CRect rect;
|
CPoint pt;
|
for (x= nStart; x < m_nBlob; x++)
|
{
|
pBlob= m_pBlobDefect+ x;
|
pt.x= pBlob->s_nDefectX;
|
|
if (pBlob->s_DefectPos == DEFPOS_LEFT)
|
{
|
pt.y= (LONG)(pBlob->s_nDefectY+ yPitch);
|
}else if(pBlob->s_DefectPos == DEFPOS_RIGHT)
|
{
|
pt.y= (LONG)(pBlob->s_nDefectY- yPitch);
|
}else
|
{
|
continue;
|
}
|
|
for (y = nStart; y < m_nBlob; y++)
|
{
|
if(x == y) continue;
|
pBlobNext= m_pBlobDefect+ y;
|
rect= pBlobNext->s_DefectRect;
|
rect.left -= 3;
|
rect.top -= 3;
|
rect.right += 3;
|
rect.bottom += 3;
|
if(rect.PtInRect(pt))
|
{
|
pBlob->s_bRemoved = TRUE;
|
break;
|
}
|
}
|
}
|
// ÀÌ°É ÀÌ·± ½ÄÀ¸·Î ÇØ¾ß Çϳª?? ¿ì¼±Àº... Ä«ÇÇÇÏ°í ³ªÁß¿¡ ¼öÁ¤
|
int i;
|
int nRemovedIdx = 0;
|
for (i = nStart; i < m_nBlob; i++)
|
{
|
if (!m_pBlobDefect[i].s_bRemoved)
|
{
|
m_pBlobDefect[nStart+ nRemovedIdx] = m_pBlobDefect[i];
|
nRemovedIdx++;
|
}
|
}
|
m_nBlob = nStart+ nRemovedIdx;
|
}
|
|
void CBlobStorage::ShadowFilter(int nStart, double xPitch)
|
{
|
CDefectBlob *pBlob;
|
CDefectBlob *pBlobNext;
|
int x, y;
|
|
|
// Shadow Filtering : unpairÀÇ °æ¿ì... pitch °Ç³Ê¿¡ °áÇÔÀÌ ÀÖ´Ù¸é.. unpair¸¦ Á¦°Å ÇÏ°Ú´Ù.
|
CRect rect;
|
CPoint pt;
|
for (x= nStart; x < m_nBlob; x++)
|
{
|
pBlob= m_pBlobDefect+ x;
|
pt.y= pBlob->s_nDefectY;
|
|
if (pBlob->s_DefectPos == DEFPOS_LEFT)
|
{
|
pt.x= (LONG)(pBlob->s_nDefectX+ xPitch);
|
}else if(pBlob->s_DefectPos == DEFPOS_RIGHT)
|
{
|
pt.x= (LONG)(pBlob->s_nDefectX- xPitch);
|
}else
|
{
|
continue;
|
}
|
|
for (y = nStart; y < m_nBlob; y++)
|
{
|
if(x == y) continue;
|
pBlobNext= m_pBlobDefect+ y;
|
rect= pBlobNext->s_DefectRect;
|
rect.left -= 3;
|
rect.top -= 3;
|
rect.right += 3;
|
rect.bottom += 3;
|
if(rect.PtInRect(pt))
|
{
|
pBlob->s_bRemoved = TRUE;
|
break;
|
}
|
}
|
}
|
// ÀÌ°É ÀÌ·± ½ÄÀ¸·Î ÇØ¾ß Çϳª?? ¿ì¼±Àº... Ä«ÇÇÇÏ°í ³ªÁß¿¡ ¼öÁ¤
|
int i;
|
int nRemovedIdx = 0;
|
for (i = nStart; i < m_nBlob; i++)
|
{
|
if (!m_pBlobDefect[i].s_bRemoved)
|
{
|
m_pBlobDefect[nStart+ nRemovedIdx] = m_pBlobDefect[i];
|
nRemovedIdx++;
|
}
|
}
|
m_nBlob = nStart+ nRemovedIdx;
|
}
|
|
|
DIT_RESULT CBlobStorage::MergeDivision(int nStart, int nMergePixel)
|
{
|
int i, j;
|
// return DIT_CONV_SUCCESS;
|
|
// °³Ã¼ÀÇ °áÇÔÁ¤º¸¸¦ Merge
|
CDefectBlob *pBlob;
|
CDefectBlob *pBlobNext;
|
for (i = nStart; i < m_nBlob; i++)
|
{
|
pBlob= m_pBlobDefect+ i;
|
for (j = i + 1; j < m_nBlob; j++)
|
{
|
pBlobNext= m_pBlobDefect+ j;
|
//choigudal ´Ù¸¥ °áÇÔÀÌ µ¿ÀÏÇÑ À§Ä¡¿¡¼ ÀâÈú °æ¿ì Çϳª¸¸ DefectÀ¸·Î º¸°í. 20090725
|
if (pBlob->s_DefectType != pBlobNext->s_DefectType)
|
continue;
|
|
if (pBlob->s_DefectRect.bottom + nMergePixel < pBlobNext->s_DefectRect.top
|
|| pBlob->s_DefectRect.top - nMergePixel > pBlobNext->s_DefectRect.bottom)
|
continue;
|
|
if (pBlob->s_DefectRect.right + nMergePixel < pBlobNext->s_DefectRect.left
|
|| pBlob->s_DefectRect.left - nMergePixel > pBlobNext->s_DefectRect.right)
|
continue;
|
|
// ÀÎÁ¢ÇØ ÀÖÀ¸¹Ç·Î ÇÕÄ£´Ù.
|
if (!pBlob->s_bRemoved && !pBlobNext->s_bRemoved)
|
{
|
//choigudal ´Ù¸¥ °áÇÔÀÌ µ¿ÀÏÇÑ À§Ä¡¿¡¼ ÀâÈú °æ¿ì Çϳª¸¸ DefectÀ¸·Î º¸°í. 20090725
|
//if(pBlob->s_DefectType == DEFTYPE_WHITE || pBlobNext->s_DefectType == DEFTYPE_WHITE)
|
// pBlob->s_DefectType = DEFTYPE_WHITE;
|
|
//m_pBlobDefect[i] = m_pBlobDefect[i] + m_pBlobDefect[j];
|
pBlob->MergeBlob(*pBlobNext);
|
pBlobNext->s_bRemoved = TRUE;
|
m_nSkipMerged++;
|
}
|
}
|
}
|
|
// °áÇÔÀ» Áö¿î´Ù.
|
int nRemovedIdx = 0;
|
for (i = nStart; i < m_nBlob; i++)
|
{
|
if (!m_pBlobDefect[i].s_bRemoved)
|
{
|
m_pBlobDefect[nStart+ nRemovedIdx] = m_pBlobDefect[i];
|
nRemovedIdx++;
|
}
|
}
|
m_nBlob = nStart+ nRemovedIdx;
|
|
for (i = nStart; i < m_nBlob; i++)
|
m_pBlobDefect[i].s_nDefectRScale = CalcRScale(m_pBlobDefect[i].s_ptVertex);
|
|
return DIT_CONV_SUCCESS;
|
}
|
|
DIT_RESULT CBlobStorage::MergeMix(int nStart, int nMergePixel)
|
{
|
int i, j;
|
|
// °³Ã¼ÀÇ °áÇÔÁ¤º¸¸¦ Merge
|
for (i = nStart; i < m_nBlob; i++)
|
{
|
for (j = m_nBlob - 1; j > i; j--)
|
{
|
if (m_pBlobDefect[j].s_DefectRect.bottom + 1 + nMergePixel < m_pBlobDefect[j].s_DefectRect.top
|
|| m_pBlobDefect[j].s_DefectRect.top - 1 - nMergePixel > m_pBlobDefect[j].s_DefectRect.bottom)
|
continue;
|
|
if (m_pBlobDefect[j].s_DefectRect.right + nMergePixel < m_pBlobDefect[j].s_DefectRect.left
|
|| m_pBlobDefect[j].s_DefectRect.left - nMergePixel > m_pBlobDefect[j].s_DefectRect.right)
|
continue;
|
|
// ÀÎÁ¢ÇØ ÀÖÀ¸¹Ç·Î ÇÕÄ£´Ù. -> TypeÀÌ ´Ù¸£¸é TypeÀ» MIXED·Î ¹Ù²Û´Ù.
|
if (m_pBlobDefect[j].s_DefectType != m_pBlobDefect[j].s_DefectType)
|
m_pBlobDefect[j].s_DefectType = DEFTYPE_MIXED;
|
|
if (!m_pBlobDefect[j].s_bRemoved && !m_pBlobDefect[j].s_bRemoved)
|
{
|
m_pBlobDefect[i].MergeBlob(m_pBlobDefect[j]);
|
m_pBlobDefect[j].s_bRemoved = TRUE;
|
m_nSkipMerged++;
|
}
|
}
|
}
|
|
// °áÇÔÀ» Áö¿î´Ù.
|
int nRemovedIdx = 0;
|
for (i = nStart; i < m_nBlob; i++)
|
{
|
if (!m_pBlobDefect[i].s_bRemoved)
|
{
|
m_pBlobDefect[nStart+ nRemovedIdx] = m_pBlobDefect[i];
|
nRemovedIdx++;
|
}
|
}
|
m_nBlob = nStart+ nRemovedIdx;
|
|
for (i = nStart; i < m_nBlob; i++)
|
m_pBlobDefect[i].s_nDefectRScale = CalcRScale(m_pBlobDefect[i].s_ptVertex);
|
|
return DIT_CONV_SUCCESS;
|
}
|
|
|
void CBlobStorage::CheckDefectRect(CDefectBlob& Defect, int nX, int nY) // CPoint* pVertex, CRect* pRect, int nX, int nY)
|
{
|
CPoint *points= Defect.s_ptVertex;
|
if (nY <= Defect.s_DefectRect.top)
|
{
|
Defect.s_DefectRect.top = nY;
|
if (Defect.s_ptVertex[2].y == nY) // Top Left
|
{
|
if (nX < Defect.s_ptVertex[2].x)
|
{
|
Defect.s_ptVertex[2].x = nX;
|
Defect.s_ptVertex[2].y = nY;
|
}
|
}
|
else
|
{
|
Defect.s_ptVertex[2].x = nX;
|
Defect.s_ptVertex[2].y = nY;
|
}
|
if (Defect.s_ptVertex[3].y == nY) // Top Right
|
{
|
if (nX + 1 > Defect.s_ptVertex[3].x)
|
{
|
Defect.s_ptVertex[3].x = nX + 1;
|
Defect.s_ptVertex[3].y = nY;
|
}
|
}
|
else
|
{
|
Defect.s_ptVertex[3].x = nX + 1;
|
Defect.s_ptVertex[3].y = nY;
|
}
|
}
|
if (nY + 1 >= Defect.s_DefectRect.bottom)
|
{
|
Defect.s_DefectRect.bottom = nY + 1;
|
if (Defect.s_ptVertex[6].y == nY + 1) // Bottom Left
|
{
|
if (nX < Defect.s_ptVertex[6].x)
|
{
|
Defect.s_ptVertex[6].x = nX;
|
Defect.s_ptVertex[6].y = nY + 1;
|
}
|
}
|
else
|
{
|
Defect.s_ptVertex[6].x = nX;
|
Defect.s_ptVertex[6].y = nY + 1;
|
}
|
if (Defect.s_ptVertex[7].y == nY + 1) // Bottom Right
|
{
|
if (nX + 1 > Defect.s_ptVertex[7].x)
|
{
|
Defect.s_ptVertex[7].x = nX + 1;
|
Defect.s_ptVertex[7].y = nY + 1;
|
}
|
}
|
else
|
{
|
Defect.s_ptVertex[7].x = nX + 1;
|
Defect.s_ptVertex[7].y = nY + 1;
|
}
|
}
|
if (nX <= Defect.s_DefectRect.left)
|
{
|
Defect.s_DefectRect.left = nX;
|
if (Defect.s_ptVertex[1].x == nX) // Left Bottom
|
{
|
if (nY + 1 > Defect.s_ptVertex[1].y)
|
{
|
Defect.s_ptVertex[1].x = nX;
|
Defect.s_ptVertex[1].y = nY + 1;
|
}
|
}
|
else
|
{
|
Defect.s_ptVertex[1].x = nX;
|
Defect.s_ptVertex[1].y = nY + 1;
|
}
|
if (Defect.s_ptVertex[0].x == nX) // Left Top
|
{
|
if (nY < Defect.s_ptVertex[0].y)
|
{
|
Defect.s_ptVertex[0].x = nX;
|
Defect.s_ptVertex[0].y = nY;
|
}
|
}
|
else
|
{
|
Defect.s_ptVertex[0].x = nX;
|
Defect.s_ptVertex[0].y = nY;
|
}
|
}
|
if (nX + 1 >= Defect.s_DefectRect.right)
|
{
|
Defect.s_DefectRect.right = nX + 1;
|
if (Defect.s_ptVertex[5].x == nX + 1) // Right Bottom
|
{
|
if (nY + 1 > Defect.s_ptVertex[5].y)
|
{
|
Defect.s_ptVertex[5].x = nX + 1;
|
Defect.s_ptVertex[5].y = nY + 1;
|
}
|
}
|
else
|
{
|
Defect.s_ptVertex[5].x = nX + 1;
|
Defect.s_ptVertex[5].y = nY + 1;
|
}
|
if (Defect.s_ptVertex[4].x == nX + 1) // Right Top
|
{
|
if (nY < Defect.s_ptVertex[4].y)
|
{
|
Defect.s_ptVertex[4].x = nX + 1;
|
Defect.s_ptVertex[4].y = nY;
|
}
|
}
|
else
|
{
|
Defect.s_ptVertex[4].x = nX + 1;
|
Defect.s_ptVertex[4].y = nY;
|
}
|
}
|
}
|
|
int CBlobStorage::CalcRScale(CPoint* pVertex)
|
{
|
double dDeltaX, dDeltaY;
|
double dTemp, dRScale = 0.0;
|
for (int i = 0; i < 8; i++)
|
{
|
for (int j = i; j < 8; j++)
|
{
|
#ifdef MOSIS_DELETE_CalcRScale
|
if (pVertex[i].x == 0 || pVertex[i].x == 32760 || pVertex[i].y == 0 ||pVertex[i].y == 32760
|
|| pVertex[j].x == 0 || pVertex[j].x == 32760 || pVertex[j].y == 0 ||pVertex[j].y == 32760)
|
continue;
|
#endif
|
dDeltaX = (pVertex[i].x - pVertex[j].x) * m_Param.s_dConvResolution;
|
dDeltaY = (pVertex[i].y - pVertex[j].y) * m_Param.s_dScanResolution;
|
dTemp = sqrt(dDeltaX * dDeltaX + dDeltaY * dDeltaY);
|
if (dRScale < dTemp)
|
dRScale = dTemp;
|
}
|
}
|
if (dRScale < 0.0)
|
dRScale = 0.0;
|
|
return static_cast<int>(dRScale + 0.5);
|
}
|
|
int CBlobStorage::GetConvolutionValue(int nX, int nY, double dDist, int nSuppress)
|
{
|
LPBYTE lpBuffer = NULL;
|
int nPitch;
|
double dRestRight;
|
double dRestLeft;
|
int nConvWidth, nConvHeight;
|
|
lpBuffer = m_Param.s_lpBuffer;
|
nConvWidth = m_Param.s_nConvWidth;
|
nConvHeight = m_Param.s_nConvHeight;
|
|
// if (dDist < 0) // -10.4
|
// {
|
// dDist -= 1; // -11.4
|
// nPitch = static_cast<int>(dDist); // -11
|
// dRestRight = nPitch - dDist; // 0.4
|
// dRestLeft = 1.0 - dRestRight; // 0.6
|
// }
|
// else // 10.4
|
// {
|
// nPitch = static_cast<int>(dDist); // 10
|
// dRestLeft = dDist - nPitch; // 0.4
|
// dRestRight = 1.0 - dRestLeft; // 0.6
|
// }
|
|
if (dDist < 0) // -10.4
|
{
|
dDist -= 1; // -11.4
|
nPitch = static_cast<int>(dDist); // -11
|
dRestLeft = nPitch - dDist; // 0.4
|
dRestRight = 1.0 - dRestLeft; // 0.6
|
}
|
else // 10.4
|
{
|
nPitch = static_cast<int>(dDist); // 10
|
dRestRight = dDist - nPitch; // 0.4
|
dRestLeft = 1.0 - dRestRight; // 0.6
|
}
|
|
int nConvolution = 0;
|
int nSourColor = 0, nDestColor = 0, nValue;
|
for (int i = 0; i < nConvWidth; i++)
|
{
|
for (int j = 0; j < nConvHeight; j++)
|
{
|
nValue = lpBuffer[(nY + j) * m_Param.s_nFrameWidth + (nX + i)];
|
if (nValue > nSuppress)
|
nValue = nSuppress;
|
nSourColor += nValue;
|
|
nValue = static_cast<int>((lpBuffer[(nY + j) * m_Param.s_nFrameWidth + (nX + i) + nPitch] * dRestLeft) + (lpBuffer[(nY + j) * m_Param.s_nFrameWidth + (nX + i) + nPitch + 1] * dRestRight));
|
if (nValue > nSuppress)
|
nValue = nSuppress;
|
nDestColor += nValue;
|
}
|
}
|
|
nConvolution = nSourColor - nDestColor;
|
|
return nConvolution;
|
}
|
|
int CBlobStorage::GetAreaValue(int nXStart, int nYStart, int nWidth, int nHeight, double dDist, int nSuppress)
|
{
|
LPBYTE lpBuffer = NULL;
|
int nPitch;
|
double dRestRight;
|
double dRestLeft;
|
int nConvWidth, nConvHeight;
|
|
lpBuffer = m_Param.s_lpBuffer;
|
nConvWidth = m_Param.s_nConvWidth;
|
nConvHeight = m_Param.s_nConvHeight;
|
|
nPitch = static_cast<int>(dDist);
|
dRestRight = dDist - nPitch;
|
dRestLeft = 1.0 - dRestRight;
|
|
int nConvolution = 0, nValue;
|
double dSourColor = 0.0, dDestColor = 0.0;
|
for (int i = 0; i < nHeight; i++)
|
{
|
for (int j = 0; j < nWidth; j++)
|
{
|
nValue = lpBuffer[(nYStart + i) * m_Param.s_nFrameWidth + (nXStart + j)];
|
if (nValue > nSuppress)
|
nValue = nSuppress;
|
dSourColor += nValue;
|
|
nValue = static_cast<int>((lpBuffer[(nYStart + j) * m_Param.s_nFrameWidth + (nXStart + i) + nPitch] * dRestLeft) + (lpBuffer[(nYStart + j) * m_Param.s_nFrameWidth + (nXStart + i) + nPitch + 1] * dRestRight));
|
if (nValue > nSuppress)
|
nValue = nSuppress;
|
dDestColor += nValue;
|
}
|
}
|
nConvolution = static_cast<int>((dSourColor - dDestColor) / (nWidth * nHeight));
|
|
return nConvolution;
|
}
|
|
int CBlobStorage::GetConvolutionValueVert(int nX, int nY, double dDist, int nSuppress)
|
{
|
LPBYTE lpBuffer = NULL;
|
int nPitch;
|
double dRestRight;
|
double dRestLeft;
|
int nConvWidth, nConvHeight;
|
|
lpBuffer = m_Param.s_lpBuffer;
|
nConvWidth = m_Param.s_nConvWidth;
|
nConvHeight = m_Param.s_nConvHeight;
|
|
if (dDist < 0) // -10.4
|
{
|
dDist -= 1; // -11.4
|
nPitch = static_cast<int>(dDist); // -11
|
dRestLeft = nPitch - dDist; // 0.4
|
dRestRight = 1.0 - dRestLeft; // 0.6
|
}
|
else // 10.4
|
{
|
nPitch = static_cast<int>(dDist); // 10
|
dRestRight = dDist - nPitch; // 0.4
|
dRestLeft = 1.0 - dRestRight; // 0.6
|
}
|
|
if(nY+nPitch+1 >= m_Param.s_nFrameHeight || nY+nPitch+1 <= 0)
|
return 0;
|
|
int nConvolution = 0;
|
int nSourColor = 0, nDestColor = 0, nValue;
|
for (int i = 0; i < nConvWidth; i++)
|
{
|
for (int j = 0; j < nConvHeight; j++)
|
{
|
nValue = lpBuffer[(nY + j) * m_Param.s_nFrameWidth + (nX + i)];
|
if (nValue > nSuppress)
|
nValue = nSuppress;
|
nSourColor += nValue;
|
|
nValue = static_cast<int>((lpBuffer[(nY + j + nPitch) * m_Param.s_nFrameWidth + (nX + i)] * dRestLeft) + (lpBuffer[(nY + j + nPitch + 1) * m_Param.s_nFrameWidth + (nX + i)] * dRestRight));
|
if (nValue > nSuppress)
|
nValue = nSuppress;
|
nDestColor += nValue;
|
}
|
}
|
|
nConvolution = nSourColor - nDestColor;
|
|
return nConvolution;
|
}
|
|
int CBlobStorage::GetAreaValueVert(int nXStart, int nYStart, int nWidth, int nHeight, double dDist, int nSuppress)
|
{
|
LPBYTE lpBuffer = NULL;
|
int nPitch;
|
double dRestRight;
|
double dRestLeft;
|
int nConvWidth, nConvHeight;
|
|
lpBuffer = m_Param.s_lpBuffer;
|
nConvWidth = m_Param.s_nConvWidth;
|
nConvHeight = m_Param.s_nConvHeight;
|
|
nPitch = static_cast<int>(dDist);
|
dRestRight = dDist - nPitch;
|
dRestLeft = 1.0 - dRestRight;
|
|
if(nYStart+nPitch+1 >= m_Param.s_nFrameHeight)
|
return 0;
|
|
int nConvolution = 0, nValue;
|
double dSourColor = 0.0, dDestColor = 0.0;
|
for (int i = 0; i < nHeight; i++)
|
{
|
for (int j = 0; j < nWidth; j++)
|
{
|
nValue = lpBuffer[(nYStart + i) * m_Param.s_nFrameWidth + (nXStart + j)];
|
if (nValue > nSuppress)
|
nValue = nSuppress;
|
dSourColor += nValue;
|
|
nValue = static_cast<int>((lpBuffer[(nYStart + j + nPitch) * m_Param.s_nFrameWidth + (nXStart + i)] * dRestLeft) + (lpBuffer[(nYStart + j + nPitch + 1) * m_Param.s_nFrameWidth + (nXStart + i)] * dRestRight));
|
if (nValue > nSuppress)
|
nValue = nSuppress;
|
dDestColor += nValue;
|
}
|
}
|
nConvolution = static_cast<int>((dSourColor - dDestColor) / (nWidth * nHeight));
|
|
return nConvolution;
|
}
|
|
// »ó/ÇÏ ÇÇÄ¡¿µ¿ª¿¡¼ °áÇÔ À籸ºÐÇÑ´Ù.
|
DIT_RESULT CBlobStorage::ClassificationDefectVert(int nStart)
|
{
|
|
// ÁÂ/¿ì °Ë»ç¿µ¿ª Àç°Ë»ç.
|
int nPitch = static_cast<int>(m_Param.s_dPitchScanReal * m_Param.s_nPitchCycleScan);
|
double dPitch = m_Param.s_dPitchScanReal * m_Param.s_nPitchCycleScan;
|
int nCR, nCL, nCRValue, nCLValue;
|
int nX, nY;
|
int nStartIdx = m_nBlob - 1;
|
|
int i;
|
CDefectBlob *pBlob;
|
for (i = nStartIdx; i >= nStart; i--)
|
{
|
pBlob= m_pBlobDefect+ i;
|
if (pBlob->s_DefectPos == DEFPOS_LEFT && pBlob->s_DefectPair == DEFPAIR_UNPAIR)
|
{
|
//if (pBlob->s_sDefectPeak * (m_Param.s_nConvWidth * m_Param.s_nConvHeight) > m_Param.s_nSideThreshold)
|
//if (pBlob->s_sDefectPeak > m_Param.s_nThreshold)
|
{
|
nX = pBlob->s_nDefectX;
|
nY = pBlob->s_nDefectY % m_Param.s_nFrameHeight;
|
nCL = GetConvolutionValueVert(nX, nY, dPitch, m_Param.s_nThresholdSupress);
|
nCR = GetConvolutionValueVert(nX, static_cast<int>(nY+dPitch), dPitch, m_Param.s_nThresholdSupress);
|
nCLValue = abs(nCL);
|
nCRValue = abs(nCR);
|
|
if (nCLValue >= m_Param.s_nThreshold && nCRValue < m_Param.s_nThreshold) // À§ÂÊ °áÇÔ.
|
{
|
// ¿ÞÂÊÀ¸·Î Shift
|
// pBlob->s_nDefectY += nPitch;
|
// pBlob->s_DefectRect.top += nPitch;
|
// pBlob->s_DefectRect.bottom += nPitch;
|
if (nCL < 0)
|
pBlob->s_DefectType = DEFTYPE_WHITE;
|
else
|
pBlob->s_DefectType = DEFTYPE_BLACK;
|
pBlob->s_DefectPair = DEFPAIR_SIDE;
|
|
m_nMoveClassify++;
|
}
|
else if (nCLValue >= m_Param.s_nThreshold && nCRValue >= m_Param.s_nThreshold) // À§/¾Æ·¡ ¹à±âÂ÷°¡ °°À¸¸é ÇöÀçÀ§Ä¡ÀÇ °áÇÔÀÌ´Ù.
|
pBlob->s_DefectPair = DEFPAIR_SIDE;
|
}
|
}
|
else if (pBlob->s_DefectPos == DEFPOS_CENTER && pBlob->s_DefectPair == DEFPAIR_UNPAIR)
|
{
|
if (pBlob->s_DefectRect.Width() <= 1 || pBlob->s_DefectRect.Height() <= 1)
|
continue;
|
|
int nXStart = pBlob->s_DefectRect.left;
|
int nYStart = pBlob->s_DefectRect.top % m_Param.s_nFrameHeight;
|
int nWidth = pBlob->s_DefectRect.Width();
|
if (nWidth > nPitch)
|
nWidth = nPitch;
|
int nHeight = pBlob->s_DefectRect.Height();
|
int nThreshold = m_Param.s_nThreshold;// / (m_Param.s_nConvWidth * m_Param.s_nConvHeight);
|
|
nCR = GetAreaValueVert(nXStart, nYStart, nWidth, nHeight, dPitch, m_Param.s_nThresholdSupress);
|
nCL = GetAreaValueVert(nXStart, static_cast<int>(nYStart-dPitch), nWidth, nHeight, dPitch, m_Param.s_nThresholdSupress);
|
nCLValue = abs(nCL);
|
nCRValue = abs(nCR);
|
if (nCRValue <= nThreshold && nCLValue > nThreshold) // À§ÂÊÀÌ °áÇÔÀÌ´Ù.
|
{
|
// À§·Î Shift
|
pBlob->s_nDefectY -= nPitch;
|
pBlob->s_DefectRect.top -= nPitch;
|
pBlob->s_DefectRect.bottom -= nPitch;
|
if (nCL < 0)
|
pBlob->s_DefectType = DEFTYPE_BLACK;
|
else
|
pBlob->s_DefectType = DEFTYPE_WHITE;
|
pBlob->s_DefectPair = DEFPAIR_LARGE;
|
|
m_nMoveClassify++;
|
}
|
else if (nCRValue > nThreshold && nCLValue <= nThreshold) // ¾Æ·¡ÂÊÀÌ °áÇÔÀÌ´Ù.
|
{
|
// ¾Æ·¡ÂÊÀ¸·Î Shift
|
pBlob->s_nDefectY += nPitch;
|
pBlob->s_DefectRect.top += nPitch;
|
pBlob->s_DefectRect.bottom += nPitch;
|
if (nCR > 0)
|
pBlob->s_DefectType = DEFTYPE_BLACK;
|
else
|
pBlob->s_DefectType = DEFTYPE_WHITE;
|
pBlob->s_DefectPair = DEFPAIR_LARGE;
|
|
m_nMoveClassify++;
|
m_nMoveClassify++;
|
}
|
else if (nCRValue > nThreshold && nCLValue > nThreshold) // i¹ø °áÇÔÀ» Áö¿î´Ù.
|
pBlob->s_DefectPair = DEFPAIR_LARGE;
|
}
|
}
|
|
for (i = m_nBlob - 1; i >= nStart; i--)
|
{
|
pBlob= m_pBlobDefect+ i;
|
if (pBlob->s_DefectPair == DEFPAIR_UNPAIR)
|
pBlob->s_bRemoved = TRUE;
|
}
|
|
// °áÇÔÀ» Áö¿î´Ù.
|
int nRemovedIdx = 0;
|
for (i = nStart; i < m_nBlob; i++)
|
{
|
pBlob= m_pBlobDefect+ i;
|
if (!pBlob->s_bRemoved)
|
{
|
m_pBlobDefect[nStart+ nRemovedIdx] = m_pBlobDefect[i];
|
nRemovedIdx++;
|
}
|
}
|
m_nBlob = nStart+ nRemovedIdx;
|
|
return DIT_CONV_SUCCESS;
|
}
|
|
|
|
|
|
BOOL CBlobStorage::ClassifyVertical(int nPairedIdx, int nThreshold)
|
{
|
//////////////////////////////////////////////////////////////////////
|
// Vertical ºñ±³
|
int nVertGab = static_cast<int>(m_Param.s_dPitchScanReal * m_Param.s_nPitchCycleScan);
|
double dVRight = (m_Param.s_dPitchScanReal * m_Param.s_nPitchCycleScan) - nVertGab;
|
double dVLeft = 1 - dVRight;
|
int nVApplyPitch = nVertGab;
|
double dLevelSrc, dLevelTemp, dLevelRef;
|
int nLevelDiff;
|
|
|
if (m_Param.s_RectConv.Height() > nVApplyPitch * 2)
|
{
|
if (m_pPairDefect[nPairedIdx].s_nDefectY + nVApplyPitch + 1 >= m_Param.s_RectConv.bottom)
|
{
|
nVApplyPitch = -nVertGab - 1;
|
double dTemp = dVRight;
|
dVLeft = dVRight;
|
dVRight = dTemp;
|
}
|
|
dLevelSrc = *(m_Param.s_lpBuffer + m_pPairDefect[nPairedIdx].s_nDefectY * m_Param.s_nFrameWidth + m_pPairDefect[nPairedIdx].s_nDefectX);
|
dLevelTemp = *(m_Param.s_lpBuffer + (m_pPairDefect[nPairedIdx].s_nDefectY + nVApplyPitch) * m_Param.s_nFrameWidth + m_pPairDefect[nPairedIdx].s_nDefectX);
|
dLevelRef = dLevelTemp * dVLeft;
|
dLevelTemp = *(m_Param.s_lpBuffer + (m_pPairDefect[nPairedIdx].s_nDefectY + nVApplyPitch + 1) * m_Param.s_nFrameWidth + m_pPairDefect[nPairedIdx].s_nDefectX);
|
dLevelRef += dLevelTemp * dVRight;
|
|
// Pixel ´ÜÀ§·Î ¹®ÅΰªÀ» ³ÑÁö ¾ÊÀ» °æ¿ì »èÁ¦.
|
if (m_pPairDefect[nPairedIdx].s_DefectType == DEFTYPE_BLACK)
|
{
|
nLevelDiff = static_cast<int>(dLevelRef - dLevelSrc);
|
if (nLevelDiff < nThreshold)
|
{
|
m_pPairDefect[nPairedIdx].s_DefectType = DEFTYPE_DELETE;
|
return FALSE;
|
}
|
}
|
else if (m_pPairDefect[nPairedIdx].s_DefectType == DEFTYPE_WHITE)
|
{
|
nLevelDiff = static_cast<int>(dLevelSrc - dLevelRef);
|
if (nLevelDiff < nThreshold)
|
{
|
m_pPairDefect[nPairedIdx].s_DefectType = DEFTYPE_DELETE;
|
return FALSE;
|
}
|
}
|
return TRUE;
|
}
|
|
// °ËÁõÇÒ ¼ö ¾øÀ¸¸é °áÇÔÀ¸·Î ³ÖÁö ¸»¶ó´Â »ÇºüÀÌ ¾ÆÀú¾¾ÀÇ ¸»¾¸.
|
return FALSE;
|
}
|
|
|
BOOL CBlobStorage::ReadBlob(CBlobStorage *pBlobStrg)
|
{
|
if(pBlobStrg == NULL) return FALSE;
|
|
CDefectBlob *pBlob;
|
int nBlob= pBlobStrg->GetBlobCount();
|
for(int iBlob= 0; iBlob < nBlob; iBlob++)
|
{
|
pBlob= pBlobStrg->GetBlobDefect(iBlob);
|
|
if(AddBlob(pBlob) == FALSE)
|
return FALSE;
|
}
|
return TRUE;
|
}
|
BOOL CBlobStorage::AddBlob(CDefectBlob *pBlob)
|
{
|
if(m_nBlob < m_maxBlob)
|
{
|
*GetBlobDefect(m_nBlob)= *pBlob;
|
m_nBlob++;
|
return m_nBlob < m_maxBlob;
|
}
|
return FALSE;
|
}
|
