#include "StdAfx.h"
|
#include <math.h>
|
#include "CornerCut.h"
|
#include "EdgeProc.h"
|
|
#define CORNERIMAGE_PATEH _T("D:\\Image\\LogCorner")
|
#define USE_ADAPTIVETHRESHOLD 0
|
#define SAVE_IMAGE
|
|
const double g_dRatio = 0.2;
|
const int g_nContiCnt = 2;
|
|
CCornerCut::CCornerCut(void)
|
{
|
ZeroMemory(m_nCornerPoint,sizeof(sCoPoint)*3);
|
m_pInsImg = NULL;
|
|
m_pOuterLineH = m_pOuterLineV = NULL;
|
m_nOuterCountH = m_nOuterCountV = 0;
|
}
|
|
CCornerCut::~CCornerCut(void)
|
{
|
if(m_pInsImg != NULL)
|
delete[] m_pInsImg, m_pInsImg=NULL;
|
if(m_pOuterLineH != NULL)
|
delete[] m_pOuterLineH, m_pOuterLineH=NULL;
|
if(m_pOuterLineV != NULL)
|
delete[] m_pOuterLineV, m_pOuterLineV=NULL;
|
}
|
|
ERRCODE_CORNERCUT CCornerCut::Inspection(LPBYTE pImg,CSize szImg,CRect &rectIns,int iFrame,int nLowThres,int nHighThres,CORNERCUR_DIR nDir, CString strHPanelID,BOOL bSaveImage
|
,COwnerBuffer &pOrg,double &dResWidth,double &dResHeight)
|
{
|
|
ZeroMemory(m_nCornerPoint,sizeof(CPoint)*3);
|
dResWidth = dResHeight = 0.;
|
|
if(pImg == NULL)
|
{
|
return ERR_CO_IMAGENULL;
|
}
|
|
pOrg.SetSize(szImg.cx,szImg.cy);
|
CopyMemory(pOrg.GetDataAddress(),pImg,pOrg.GetDataSize());
|
|
AssertOnFrameRect(rectIns,szImg);
|
if(rectIns.Width()*rectIns.Height() <= 0)
|
{
|
return ERR_CO_INSRECTNULL;
|
}
|
|
if(bSaveImage == TRUE)
|
{
|
CreateDirectory(CORNERIMAGE_PATEH,NULL);
|
|
CString strFile;
|
CSISBuffer mosis1(pImg, rectIns.Width(), rectIns.Height());
|
strFile.Format(_T("%s\\%s_OrgImg_%d.bmp"),CORNERIMAGE_PATEH,strHPanelID, iFrame);
|
CBufferAttach attch1(strFile);
|
if(mosis1.IsValidBuffer() == TRUE)
|
attch1.AttachToFile(mosis1);
|
|
/*CHMBitmap BmpSave;
|
CString strFile;
|
if(rectIns.Width() > 0 && rectIns.Height() > 0)
|
{
|
BmpSave.SetBitmap(pImg, rectIns.Width(), rectIns.Height());
|
strFile.Format("%s\\%s_OrgImg_%d.bmp",CORNERIMAGE_PATEH,strHPanelID, iFrame);
|
LPBYTE pBuffer = BmpSave.GetBuffer();
|
if(pBuffer != NULL)
|
BmpSave.SaveBitmapFile(strFile);
|
}*/
|
}
|
|
CSISBuffer pBuf(pImg,szImg.cx,szImg.cy);
|
ThresholdProcLowHigh(pBuf,nLowThres,nHighThres);
|
|
//CEdgeProc EdgeProc;
|
|
//EdgeProc.ThresholdByIntegralImage(pImg,szImg.cx,szImg.cy,szImg.cx,10,pImg);
|
|
//EdgeProc.Adaptive_Binarization(pImg,szImg.cx,szImg.cy,szImg.cx,10,0.2,pImg,rectIns);
|
|
|
if(bSaveImage == TRUE)
|
{
|
CSISBuffer mosis2(pImg, rectIns.Width(), rectIns.Height());
|
CString strFile;
|
strFile.Format(_T("%s\\%s_ThresImg_%d.bmp"),CORNERIMAGE_PATEH,strHPanelID, iFrame);
|
CBufferAttach attch2(strFile);
|
if(mosis2.IsValidBuffer() == TRUE)
|
attch2.AttachToFile(mosis2);
|
|
/*CHMBitmap BmpSave2;
|
if(rectIns.Width() > 0 && rectIns.Height() > 0)
|
{
|
BmpSave2.SetBitmap(pImg, rectIns.Width(), rectIns.Height());
|
strFile.Format("%s\\%s_ThresImg_%d.bmp",CORNERIMAGE_PATEH,strHPanelID, iFrame);
|
LPBYTE pBuffer = BmpSave2.GetBuffer();
|
if(pBuffer != NULL)
|
BmpSave2.SaveBitmapFile(strFile);
|
}*/
|
}
|
|
int nVertLine,nHorLine;
|
|
if(FindVerticalLine(pImg,rectIns,nVertLine,nDir) == FALSE)
|
{
|
return ERR_CO_FINDVERT;
|
}
|
|
if(FindHorizontalLine(pImg,rectIns,nHorLine,nDir) == FALSE)
|
{
|
return ERR_CO_FINDHOR;
|
}
|
|
m_nCornerPoint[0].x = nVertLine;
|
m_nCornerPoint[0].y = nHorLine;
|
|
FindCornerPoint(pImg,rectIns,m_nCornerPoint[0],nDir);
|
|
FindOuterLine(pImg,rectIns,nDir);
|
|
if(m_nOuterCountH >= 20 && m_nOuterCountV >= 20)
|
{
|
FindFirstPoint(rectIns);
|
}
|
|
CalculateLenght(dResWidth,dResHeight);
|
|
if(m_pOuterLineH != NULL)
|
delete[] m_pOuterLineH, m_pOuterLineH=NULL;
|
if(m_pOuterLineV != NULL)
|
delete[] m_pOuterLineV, m_pOuterLineV=NULL;
|
|
|
if(pOrg.IsValidBuffer() == TRUE)
|
{
|
CPoint pointDraw[3];
|
|
pointDraw[0] = CPoint((int)m_nCornerPoint[0].x,(int)m_nCornerPoint[0].y);
|
pointDraw[1] = CPoint((int)m_nCornerPoint[1].x,(int)m_nCornerPoint[1].y);
|
pointDraw[2] = CPoint((int)m_nCornerPoint[2].x,(int)m_nCornerPoint[2].y);
|
|
bresenham_Line(&pOrg,pointDraw[0],pointDraw[1],0);
|
bresenham_Line(&pOrg,pointDraw[2],pointDraw[0],0);
|
|
SaveMarkImage(pOrg.GetDataAddress(0,0),rectIns);
|
|
// LPBYTE pBuffer = pOrg.GetDataAddress(0,0);
|
// if(pBuffer != NULL)
|
// {
|
// //SaveMarkImage(pBuffer,rectIns);
|
// }
|
}
|
|
|
return ERR_CO_SUCCESS;
|
}
|
|
void CCornerCut::SaveMarkImage(LPBYTE pBuffer,CRect &rectIns)
|
{
|
int nStartH,nStartV,nEndH,nEndV,x,y;
|
int nDiv = 5,nBright = 128;
|
|
// 0 Position
|
nStartH = (int)m_nCornerPoint[0].x-nDiv;
|
nEndH = (int)m_nCornerPoint[0].x+nDiv;
|
if(nStartH < 0) nStartH = 0;
|
if(nEndH >= rectIns.Width()) nEndH = rectIns.Width()-1;
|
y=(int)m_nCornerPoint[0].y;
|
for(x=nStartH;x<=nEndH;x++)
|
pBuffer[y*rectIns.Width()+x] = nBright;
|
|
nStartV = (int)m_nCornerPoint[0].y-nDiv;
|
nEndV = (int)m_nCornerPoint[0].y+nDiv;
|
if(nStartV < 0) nStartV = 0;
|
if(nEndV >= rectIns.Height()) nEndV = rectIns.Height()-1;
|
x=(int)m_nCornerPoint[0].x;
|
for(y=nStartV;y<=nEndV;y++)
|
pBuffer[y*rectIns.Width()+x] = nBright;
|
|
// 1 Position
|
nStartH = (int)m_nCornerPoint[1].x-nDiv;
|
nEndH = (int)m_nCornerPoint[1].x+nDiv;
|
if(nStartH < 0) nStartH = 0;
|
if(nEndH >= rectIns.Width()) nEndH = rectIns.Width()-1;
|
y=(int)m_nCornerPoint[1].y;
|
for(x=nStartH;x<=nEndH;x++)
|
pBuffer[y*rectIns.Width()+x] = nBright;
|
|
nStartV = (int)m_nCornerPoint[1].y-nDiv;
|
nEndV = (int)m_nCornerPoint[1].y+nDiv;
|
if(nStartV < 0) nStartV = 0;
|
if(nEndV >= rectIns.Height()) nEndV = rectIns.Height()-1;
|
x=(int)m_nCornerPoint[1].x;
|
for(y=nStartV;y<=nEndV;y++)
|
pBuffer[y*rectIns.Width()+x] = nBright;
|
|
// 2 Position
|
nStartH = (int)m_nCornerPoint[2].x-nDiv;
|
nEndH = (int)m_nCornerPoint[2].x+nDiv;
|
if(nStartH < 0) nStartH = 0;
|
if(nEndH >= rectIns.Width()) nEndH = rectIns.Width()-1;
|
y=(int)m_nCornerPoint[2].y;
|
for(x=nStartH;x<=nEndH;x++)
|
pBuffer[y*rectIns.Width()+x] = nBright;
|
|
nStartV = (int)m_nCornerPoint[2].y-nDiv;
|
nEndV = (int)m_nCornerPoint[2].y+nDiv;
|
if(nStartV < 0) nStartV = 0;
|
if(nEndV >= rectIns.Height()) nEndV = rectIns.Height()-1;
|
x=(int)m_nCornerPoint[2].x;
|
for(y=nStartV;y<=nEndV;y++)
|
pBuffer[y*rectIns.Width()+x] = nBright;
|
}
|
|
void CCornerCut::CalculateLenght(double &dResWidth,double &dResHeight)
|
{
|
dResWidth = sqrt(pow((m_nCornerPoint[0].x-m_nCornerPoint[1].x),2)+pow((m_nCornerPoint[0].y-m_nCornerPoint[1].y),2));
|
dResHeight = sqrt(pow((m_nCornerPoint[0].x-m_nCornerPoint[2].x),2)+pow((m_nCornerPoint[0].y-m_nCornerPoint[2].y),2));
|
|
// dResWidth = fabs(m_nCornerPoint[1].x-m_nCornerPoint[2].x)+1;
|
// dResHeight = fabs(m_nCornerPoint[1].y-m_nCornerPoint[2].y)+1;
|
}
|
|
BOOL CCornerCut::FindOuterHori(LPBYTE pImg,CRect rectIns,double nYPos,double nStartX,CORNERCUR_DIR nDir)
|
{
|
const int nMargin = 5;
|
BOOL bReverse = FALSE;
|
int nStartY,nEndY;
|
|
switch(nDir)
|
{
|
case CO_LT:
|
case CO_RT:
|
nStartY = (int)nYPos-nMargin;
|
nEndY = (int)nYPos+nMargin;
|
if(nStartY < 0) nStartY = 0;
|
if(nEndY >= rectIns.Height()) nEndY = rectIns.Height()-1;
|
break;
|
case CO_LB:
|
case CO_RB:
|
bReverse = TRUE;
|
nStartY = (int)nYPos+nMargin;
|
nEndY = (int)nYPos-nMargin;
|
if(nEndY < 0) nEndY = 0;
|
if(nStartY >= rectIns.Height()) nStartY = rectIns.Height()-1;
|
break;
|
}
|
|
if(nStartX < 0) nStartX = 0;
|
|
int iX,iY;
|
if(bReverse == FALSE)
|
{
|
switch(nDir)
|
{
|
case CO_LT:
|
case CO_LB:
|
for(iX=(int)nStartX;iX<rectIns.Width();iX++)
|
{
|
for(iY=nStartY;iY<=nEndY;iY++)
|
{
|
if(pImg[iY*rectIns.Width()+iX] == 255)
|
{
|
m_pOuterLineH[m_nOuterCountH].x = iX;
|
m_pOuterLineH[m_nOuterCountH].y = iY;
|
m_nOuterCountH++;
|
break;
|
}
|
}
|
}
|
break;
|
case CO_RT:
|
case CO_RB:
|
for(iX=0;iX<(int)nStartX;iX++)
|
{
|
for(iY=nStartY;iY<=nEndY;iY++)
|
{
|
if(pImg[iY*rectIns.Width()+iX] == 255)
|
{
|
m_pOuterLineH[m_nOuterCountH].x = iX;
|
m_pOuterLineH[m_nOuterCountH].y = iY;
|
m_nOuterCountH++;
|
break;
|
}
|
}
|
}
|
break;
|
}
|
}
|
else
|
{
|
switch(nDir)
|
{
|
case CO_LT:
|
case CO_LB:
|
for(iX=(int)nStartX;iX<rectIns.Width();iX++)
|
{
|
for(iY=nStartY;iY>=nEndY;iY--)
|
{
|
if(pImg[iY*rectIns.Width()+iX] == 255)
|
{
|
m_pOuterLineH[m_nOuterCountH].x = iX;
|
m_pOuterLineH[m_nOuterCountH].y = iY;
|
m_nOuterCountH++;
|
break;
|
}
|
}
|
}
|
break;
|
case CO_RT:
|
case CO_RB:
|
for(iX=0;iX<(int)nStartX;iX++)
|
{
|
for(iY=nStartY;iY>=nEndY;iY--)
|
{
|
if(pImg[iY*rectIns.Width()+iX] == 255)
|
{
|
m_pOuterLineH[m_nOuterCountH].x = iX;
|
m_pOuterLineH[m_nOuterCountH].y = iY;
|
m_nOuterCountH++;
|
break;
|
}
|
}
|
}
|
break;
|
}
|
}
|
|
return TRUE;
|
}
|
|
BOOL CCornerCut::FindOuterVert(LPBYTE pImg,CRect rectIns,double nYPos,double nXPos,CORNERCUR_DIR nDir)
|
{
|
const int nMargin = 5;
|
BOOL bReverse = FALSE;
|
int nStartX,nEndX;
|
|
switch(nDir)
|
{
|
case CO_LT:
|
case CO_LB:
|
nStartX = (int)nXPos-nMargin;
|
nEndX = (int)nXPos+nMargin;
|
if(nStartX < 0) nStartX = 0;
|
if(nEndX >= rectIns.Width()) nEndX = rectIns.Width()-1;
|
break;
|
case CO_RT:
|
case CO_RB:
|
bReverse = TRUE;
|
nStartX = (int)nXPos+nMargin;
|
nEndX = (int)nXPos-nMargin;
|
if(nEndX < 0) nEndX = 0;
|
if(nStartX >= rectIns.Width()) nStartX = rectIns.Width()-1;
|
break;
|
}
|
|
if(nYPos < 0) nYPos = 0;
|
|
int iX,iY;
|
if(bReverse == FALSE)
|
{
|
switch(nDir)
|
{
|
case CO_LT:
|
case CO_RT:
|
for(iY=(int)nYPos;iY<rectIns.Height();iY++)
|
{
|
for(iX=nStartX;iX<=nEndX;iX++)
|
{
|
if(pImg[iY*rectIns.Width()+iX] == 255)
|
{
|
m_pOuterLineV[m_nOuterCountV].x = iX;
|
m_pOuterLineV[m_nOuterCountV].y = iY;
|
m_nOuterCountV++;
|
break;
|
}
|
}
|
}
|
break;
|
case CO_LB:
|
case CO_RB:
|
for(iY=0;iY<(int)nYPos;iY++)
|
{
|
for(iX=nStartX;iX<=nEndX;iX++)
|
{
|
if(pImg[iY*rectIns.Width()+iX] == 255)
|
{
|
m_pOuterLineV[m_nOuterCountV].x = iX;
|
m_pOuterLineV[m_nOuterCountV].y = iY;
|
m_nOuterCountV++;
|
break;
|
}
|
}
|
}
|
break;
|
}
|
}
|
else
|
{
|
switch(nDir)
|
{
|
case CO_LT:
|
case CO_RT:
|
for(iY=(int)nYPos;iY<rectIns.Height();iY++)
|
{
|
for(iX=nStartX;iX>=nEndX;iX--)
|
{
|
if(pImg[iY*rectIns.Width()+iX] == 255)
|
{
|
m_pOuterLineV[m_nOuterCountV].x = iX;
|
m_pOuterLineV[m_nOuterCountV].y = iY;
|
m_nOuterCountV++;
|
break;
|
}
|
}
|
}
|
break;
|
case CO_LB:
|
case CO_RB:
|
for(iY=0;iY<(int)nYPos;iY++)
|
{
|
for(iX=nStartX;iX>=nEndX;iX--)
|
{
|
if(pImg[iY*rectIns.Width()+iX] == 255)
|
{
|
m_pOuterLineV[m_nOuterCountV].x = iX;
|
m_pOuterLineV[m_nOuterCountV].y = iY;
|
m_nOuterCountV++;
|
break;
|
}
|
}
|
}
|
break;
|
}
|
}
|
|
return TRUE;
|
}
|
|
BOOL CCornerCut::FindOuterLine(LPBYTE pImg,CRect rectIns,CORNERCUR_DIR nDir)
|
{
|
if(m_pOuterLineH != NULL)
|
delete[] m_pOuterLineH, m_pOuterLineH=NULL;
|
if(m_pOuterLineV != NULL)
|
delete[] m_pOuterLineV, m_pOuterLineV=NULL;
|
m_nOuterCountH = m_nOuterCountV = 0;
|
|
if(pImg == NULL || rectIns.Width()*rectIns.Height() <= 0)
|
return FALSE;
|
|
m_pOuterLineH = new sCoPoint[rectIns.Width()+1];
|
m_pOuterLineV = new sCoPoint[rectIns.Height()+1];
|
|
FindOuterHori(pImg,rectIns,m_nCornerPoint[1].y,m_nCornerPoint[1].x,nDir);
|
|
FindOuterVert(pImg,rectIns,m_nCornerPoint[2].y,m_nCornerPoint[2].x,nDir);
|
|
return TRUE;
|
}
|
|
BOOL CCornerCut::FindCornerPoint(LPBYTE pImg,CRect rectIns,sCoPoint point,CORNERCUR_DIR nDir)
|
{
|
switch(nDir)
|
{
|
case CO_LT:
|
DetectLine(pImg,rectIns,point,TRUE,FALSE,nDir,m_nCornerPoint[1]);
|
DetectLine(pImg,rectIns,point,FALSE,FALSE,nDir,m_nCornerPoint[2]);
|
break;
|
case CO_LB:
|
DetectLine(pImg,rectIns,point,TRUE,FALSE,nDir,m_nCornerPoint[1]);
|
DetectLine(pImg,rectIns,point,FALSE,TRUE,nDir,m_nCornerPoint[2]);
|
break;
|
case CO_RT:
|
DetectLine(pImg,rectIns,point,TRUE,TRUE,nDir,m_nCornerPoint[1]);
|
DetectLine(pImg,rectIns,point,FALSE,FALSE,nDir,m_nCornerPoint[2]);
|
break;
|
case CO_RB:
|
DetectLine(pImg,rectIns,point,TRUE,TRUE,nDir,m_nCornerPoint[1]);
|
DetectLine(pImg,rectIns,point,FALSE,TRUE,nDir,m_nCornerPoint[2]);
|
break;
|
}
|
|
return TRUE;
|
}
|
|
int CCornerCut::GetVertCount(LPBYTE pImg,int u,sCoPoint point,BOOL bDir,int nWidth,int nHeight,int nSetCount)
|
{
|
int nDetLine = -1;
|
int nCount = 0;
|
int v;
|
|
if(bDir == FALSE)
|
{
|
for(v=(int)point.y;v<nHeight;v++)
|
{
|
if(*(pImg+v*nWidth+u) == 255)
|
nCount++;
|
else
|
nCount = 0;
|
if(nCount >= nSetCount)
|
{
|
nDetLine = v-nCount;
|
break;
|
}
|
}
|
}
|
else
|
{
|
for(v=(int)point.y;v>=0;v--)
|
{
|
if(*(pImg+v*nWidth+u) == 255)
|
nCount++;
|
else
|
nCount = 0;
|
if(nCount >= nSetCount)
|
{
|
nDetLine = v+nCount;
|
break;
|
}
|
}
|
}
|
|
return nDetLine;
|
}
|
|
int CCornerCut::GetHorCount(LPBYTE pImg,int v,sCoPoint point,BOOL bDir,int nWidth,int nSetCount)
|
{
|
int nDetLine = -1;
|
int nCount = 0;
|
int u;
|
|
if(bDir == FALSE)
|
{
|
for(u=(int)point.x;u<nWidth;u++)
|
{
|
if(*(pImg+v*nWidth+u) == 255)
|
nCount++;
|
else
|
nCount = 0;
|
if(nCount >= nSetCount)
|
{
|
nDetLine = u-nCount;
|
break;
|
}
|
}
|
}
|
else
|
{
|
for(u=(int)point.x;u>=0;u--)
|
{
|
if(*(pImg+v*nWidth+u) == 255)
|
nCount++;
|
else
|
nCount = 0;
|
if(nCount >= nSetCount)
|
{
|
nDetLine = u+nCount;
|
break;
|
}
|
}
|
}
|
|
|
return nDetLine;
|
}
|
|
void CCornerCut::GetRegionInfo(sCoPoint point,CORNERCUR_DIR nDir,BOOL bDir,int &nStart,int &nEnd,BOOL &bReverse,int nWidth,int nHeight)
|
{
|
int nSize = g_nContiCnt*2;
|
bReverse = FALSE;
|
if(bDir == TRUE) // Horizontal
|
{
|
switch(nDir)
|
{
|
case CO_LT:
|
case CO_RT:
|
nStart = (int)point.y-nSize*2;
|
nEnd = (int)point.y+nSize;
|
break;
|
case CO_LB:
|
case CO_RB:
|
bReverse = TRUE;
|
nStart = (int)point.y-nSize;
|
nEnd = (int)point.y+nSize*2;
|
break;
|
}
|
if(nStart < 0)
|
nStart = 0;
|
if(nEnd >= nHeight)
|
nEnd = nHeight-1;
|
}
|
else
|
{
|
switch(nDir)
|
{
|
case CO_LT:
|
case CO_LB:
|
nStart = (int)point.x-nSize*2;
|
nEnd = (int)point.x+nSize;
|
break;
|
case CO_RT:
|
case CO_RB:
|
bReverse = TRUE;
|
nStart = (int)point.x-nSize;
|
nEnd = (int)point.x+nSize*2;
|
break;
|
}
|
if(nStart < 0)
|
nStart = 0;
|
if(nEnd >= nWidth)
|
nEnd = nWidth-1;
|
}
|
}
|
|
int CCornerCut::DetectLine(LPBYTE pImg,CRect rectIns,sCoPoint point,BOOL bDir,BOOL bReverse,CORNERCUR_DIR nDir,sCoPoint &pointResult)
|
{
|
int nWidth = rectIns.Width();
|
int nHeight = rectIns.Height();
|
int u,v;
|
int nCount;
|
const int nSetCount = 2;
|
const int nSetDet = 8;
|
int nStart,nEnd,nDetPos,iLoop;
|
BOOL bConvert;
|
CPoint pointDet,pointFirst;
|
CArray<CPoint,CPoint> nPos;
|
|
|
nCount = 0;
|
GetRegionInfo(point,nDir,bDir,nStart,nEnd,bConvert,nWidth,nHeight);
|
|
if(bDir == TRUE) // Horizontal
|
{
|
if(nStart > nEnd) swapN(nStart,nEnd);
|
if(bConvert == FALSE)
|
{
|
for(v=nEnd;v>=nStart;v--)
|
{
|
nDetPos = GetHorCount(pImg,v,point,bReverse,nWidth,nSetCount);
|
nPos.Add(CPoint(nDetPos,v));
|
}
|
}
|
else
|
{
|
for(v=nStart;v<nEnd;v++)
|
{
|
nDetPos = GetHorCount(pImg,v,point,bReverse,nWidth,nSetCount);
|
nPos.Add(CPoint(nDetPos,v));
|
}
|
}
|
|
for(iLoop=0;iLoop<nPos.GetCount();iLoop++)
|
{
|
pointDet = nPos.GetAt(iLoop);
|
if(iLoop == 0)
|
{
|
pointFirst = pointDet;
|
continue;
|
}
|
if(abs(pointDet.x-pointFirst.x) >= nSetDet)
|
{
|
pointResult.x = pointFirst.x;
|
pointResult.y = pointFirst.y;
|
break;
|
}
|
pointFirst = pointDet;
|
}
|
}
|
else
|
{
|
if(nStart > nEnd) swapN(nStart,nEnd);
|
if(bConvert == FALSE)
|
{
|
for(u=nEnd;u>=nStart;u--)
|
{
|
nDetPos = GetVertCount(pImg,u,point,bReverse,nWidth,nHeight,nSetCount);
|
nPos.Add(CPoint(u,nDetPos));
|
}
|
}
|
else
|
{
|
for(u=nStart;u<nEnd;u++)
|
{
|
nDetPos = GetVertCount(pImg,u,point,bReverse,nWidth,nHeight,nSetCount);
|
nPos.Add(CPoint(u,nDetPos));
|
}
|
}
|
|
for(iLoop=0;iLoop<nPos.GetCount();iLoop++)
|
{
|
pointDet = nPos.GetAt(iLoop);
|
if(iLoop == 0)
|
{
|
pointFirst = pointDet;
|
continue;
|
}
|
if(abs(pointDet.y-pointFirst.y) >= nSetDet)
|
{
|
pointResult.x = pointFirst.x;
|
pointResult.y = pointFirst.y;
|
break;
|
}
|
pointFirst = pointDet;
|
}
|
}
|
|
return 0;
|
}
|
|
BOOL CCornerCut::FindHorizontalLine(LPBYTE pImg,CRect rectIns,int &nHorLine,CORNERCUR_DIR nDir)
|
{
|
if(rectIns.Height() <= 0)
|
return FALSE;
|
|
nHorLine = -1;
|
|
int *pPoint;
|
int u,v;
|
int nMax,nLevel;
|
int nWidth = rectIns.Width();
|
int nHeight = rectIns.Height();
|
int nCount;
|
|
//////////////////////////////////////////////////////////////////////////
|
// vertical
|
pPoint = new int[nHeight];
|
ZeroMemory(pPoint,sizeof(int)*nHeight);
|
|
nMax = INT_MIN;
|
for(v=0;v<nHeight;v++)
|
{
|
for(u=0;u<nWidth;u++)
|
{
|
if(*(pImg+v*nWidth+u) == 255)
|
pPoint[v]++;
|
}
|
if(nMax < pPoint[v]) nMax = pPoint[v];
|
}
|
nLevel = (int)((double)nMax * g_dRatio);
|
|
nCount = 0;
|
|
switch(nDir)
|
{
|
case CO_LT:
|
case CO_RT:
|
for(v=0;v<nHeight;v++)
|
{
|
if(pPoint[v] >= nLevel)
|
nCount++;
|
else
|
nCount = 0;
|
|
if(nCount >= g_nContiCnt)
|
{
|
nHorLine = v-nCount;
|
break;
|
}
|
}
|
break;
|
case CO_LB:
|
case CO_RB:
|
for(v=nHeight-1;v>=0;v--)
|
{
|
if(pPoint[v] >= nLevel)
|
nCount++;
|
else
|
nCount = 0;
|
|
if(nCount >= g_nContiCnt)
|
{
|
nHorLine = v+nCount;
|
break;
|
}
|
}
|
break;
|
}
|
|
delete[] pPoint, pPoint=NULL;
|
|
return TRUE;
|
}
|
|
BOOL CCornerCut::FindVerticalLine(LPBYTE pImg,CRect rectIns,int &nVertLine,CORNERCUR_DIR nDir)
|
{
|
if(rectIns.Width() <= 0)
|
return FALSE;
|
|
nVertLine = -1;
|
|
int *pPoint;
|
int u,v;
|
int nMax,nLevel;
|
int nWidth = rectIns.Width();
|
int nHeight = rectIns.Height();
|
int nCount;
|
|
//////////////////////////////////////////////////////////////////////////
|
// vertical
|
pPoint = new int[nWidth];
|
ZeroMemory(pPoint,sizeof(int)*nWidth);
|
|
nMax = INT_MIN;
|
for(u=0;u<nWidth;u++)
|
{
|
for(v=0;v<nHeight;v++)
|
{
|
if(*(pImg+v*nWidth+u) == 255)
|
pPoint[u]++;
|
}
|
if(nMax < pPoint[u]) nMax = pPoint[u];
|
}
|
nLevel = (int)((double)nMax * g_dRatio);
|
|
nCount = 0;
|
|
switch(nDir)
|
{
|
case CO_LT:
|
case CO_LB:
|
for(u=0;u<nWidth;u++)
|
{
|
if(pPoint[u] >= nLevel)
|
nCount++;
|
else
|
nCount = 0;
|
|
if(nCount >= g_nContiCnt)
|
{
|
nVertLine = u-nCount;
|
break;
|
}
|
}
|
break;
|
case CO_RT:
|
case CO_RB:
|
for(u=nWidth-1;u>=0;u--)
|
{
|
if(pPoint[u] >= nLevel)
|
nCount++;
|
else
|
nCount = 0;
|
|
if(nCount >= g_nContiCnt)
|
{
|
nVertLine = u+nCount;
|
break;
|
}
|
}
|
break;
|
}
|
|
delete[] pPoint, pPoint=NULL;
|
|
return TRUE;
|
}
|
|
BOOL CCornerCut::CopyEdgeImg(LPBYTE pImg,CSize szImg,CRect &rectIns)
|
{
|
if(m_pInsImg != NULL)
|
delete[] m_pInsImg, m_pInsImg = NULL;
|
m_pInsImg = new BYTE[rectIns.Width()*(rectIns.Height()+1)];
|
ZeroMemory(m_pInsImg,sizeof(BYTE)*rectIns.Width()*(rectIns.Height()+1));
|
|
int v;
|
int dv = 0;
|
|
for(v=rectIns.top;v<rectIns.bottom;v++,dv++)
|
{
|
CopyMemory(m_pInsImg+dv*rectIns.Width(),pImg+v*szImg.cx+rectIns.left,rectIns.Width());
|
}
|
|
return TRUE;
|
}
|
|
void CCornerCut::AssertOnFrameRect(CRect &rect,CSize szImg)
|
{
|
if(rect.left < 0) rect.left = 0;
|
if(rect.left > szImg.cx) rect.left = szImg.cx-1;
|
if(rect.right < 0) rect.right = 0;
|
if(rect.right > szImg.cx) rect.right = szImg.cx-1;
|
if(rect.left > rect.right) swapN(rect.left,rect.right);
|
if(rect.top < 0) rect.top = 0;
|
if(rect.top > szImg.cy) rect.top = szImg.cy-1;
|
if(rect.bottom < 0) rect.bottom = 0;
|
if(rect.bottom > szImg.cy) rect.bottom = szImg.cy-1;
|
if(rect.top > rect.bottom) swapN(rect.top,rect.bottom);
|
}
|
|
float CCornerCut::AdaptiveThreshold(BYTE* pImageData, int nWidth, int nHeight, int nStep, int nThresValue)
|
{
|
if (pImageData==NULL) return 0;
|
|
float fThresValue =(float) nThresValue;
|
float fNewThresValue = 0;
|
|
for (int i=0; i<1000; i++)
|
{
|
fNewThresValue = GetThresholdValue(pImageData, nWidth, nHeight, nStep, (int)fThresValue);
|
|
if (fNewThresValue==fThresValue) break;
|
|
fThresValue = fNewThresValue;
|
}
|
|
return fNewThresValue;
|
}
|
|
float CCornerCut::GetThresholdValue(BYTE* pImageData, int nWidth, int nHeight, int nStep, int nThresValue)
|
{
|
if (pImageData==NULL) return 0;
|
|
ULONG fore = 0;
|
int fore_cnt = 0;
|
ULONG back = 0;
|
int back_cnt = 0;
|
|
int nIndex;
|
for (int i=0; i<nHeight; i++)
|
{
|
for (int j=0; j<nWidth; j++)
|
{
|
nIndex = (i*nStep)+j;
|
|
if (pImageData[nIndex]==0) continue;
|
|
if (pImageData[nIndex] > nThresValue)
|
{
|
fore += pImageData[nIndex];
|
fore_cnt++;
|
}
|
else
|
{
|
back += pImageData[nIndex];
|
back_cnt++;
|
}
|
}
|
}
|
|
float fore_avg = 0.0f;
|
if (fore_cnt!=0) fore_avg = float(fore) / float(fore_cnt);
|
|
float back_avg = 0.0f;
|
if (back_cnt!=0) back_avg = float(back) / float(back_cnt);
|
|
if (fore_cnt==0 || back_cnt==0)
|
{
|
if (nThresValue>=128)
|
return float(nThresValue)/2.0f;
|
else
|
return float(nThresValue)*2.0f;
|
}
|
|
return (fore_avg+back_avg)/2.0f;
|
}
|
|
void CCornerCut::ThresholdProcLowHigh(CSISBuffer &pImg,int nLowThres,int nHighThres)
|
{
|
LPBYTE pBuf = pImg.GetDataAddress();
|
for (int i=0; i<pImg.GetDataSize(); i++,pBuf++)
|
{
|
if(*pBuf <= nLowThres || *pBuf >= nHighThres)
|
*pBuf = 255;
|
else
|
*pBuf = 0;
|
}
|
}
|
|
void CCornerCut::ThresholdProcessing(LPBYTE pImg,CSize szImg,int nThres,int nDir)
|
{
|
|
float fNewThresValue = float(nThres);
|
|
// threshold and invert
|
int nIndex;
|
int nFinThres = (int)(fNewThresValue);
|
for (int i=0; i<szImg.cy; i++)
|
{
|
for (int j=0; j<szImg.cx; j++)
|
{
|
nIndex = (i*szImg.cx)+j;
|
if(nDir == 1)
|
{
|
if (pImg[nIndex] > nFinThres)
|
{
|
pImg[nIndex] = 255;
|
}
|
else
|
{
|
pImg[nIndex] = 0;
|
}
|
}
|
else
|
{
|
if (pImg[nIndex] < nFinThres)
|
{
|
pImg[nIndex] = 255;
|
}
|
else
|
{
|
pImg[nIndex] = 0;
|
}
|
}
|
}
|
}
|
}
|
|
// ·Î¹öÆ®ÆгÊÀÇ ±³Â÷Á¡ ±¸Çϱâ¶ó´Âµ¥..
|
BOOL CCornerCut::LineInterSection(CPoint p1,CPoint p2,CPoint p3,CPoint p4,double &dInterX,double &dInterY)
|
{
|
double x1 = p1.x;
|
double y1 = p1.y;
|
double x4 = p4.x;
|
double y4 = p4.y;
|
|
dInterX = dInterY = 0.;
|
|
double dx1 = p2.x - x1;
|
double dx2 = p3.x - x4;
|
if (!(dx1 || dx2)) return FALSE;
|
|
double m1 = (p2.y - y1) / dx1;
|
double m2 = (p3.y - y4) / dx2;
|
|
if (!dx1)
|
{
|
// infinity
|
dInterX = x1;
|
dInterY = m2 * (x1 - x4) + y4;
|
return FALSE;
|
}
|
else if (!dx2)
|
{
|
// infinity
|
dInterX = x4;
|
dInterY = m1 * (x4 - x1) + y1;
|
return FALSE;
|
}
|
|
dInterX = (-m2 * x4 + y4 + m1 * x1 - y1) / (m1 - m2);
|
dInterY = m1 * (dInterX - x1) + y1;
|
|
return TRUE;
|
}
|
|
BOOL CCornerCut::FindFirstPoint(CRect &rectIns)
|
{
|
CPoint HPoint[2],VPoint[2];
|
int iLoop;
|
int nSetCount = 10;
|
int nSumF,nSumS;
|
double dslope,dAvgF,dAvgS;
|
|
nSumF = nSumS = 0;
|
for(iLoop=0;iLoop<nSetCount;iLoop++)
|
nSumF += (int)m_pOuterLineH[iLoop].y;
|
|
for(iLoop=m_nOuterCountH-nSetCount;iLoop<m_nOuterCountH;iLoop++)
|
nSumS += (int)m_pOuterLineH[iLoop].y;
|
|
dAvgF = (double)nSumF/(double)nSetCount;
|
dAvgS = (double)nSumS/(double)nSetCount;
|
dslope = (dAvgS-dAvgF)/(double)rectIns.Width();
|
|
HPoint[0].x = 0;
|
HPoint[0].y = (int)dAvgF;
|
HPoint[1].x = rectIns.right;
|
HPoint[1].y = (int)dAvgS;
|
|
|
nSumF = nSumS = 0;
|
for(iLoop=0;iLoop<nSetCount;iLoop++)
|
nSumF += (int)m_pOuterLineV[iLoop].x;
|
|
for(iLoop=m_nOuterCountV-nSetCount;iLoop<m_nOuterCountV;iLoop++)
|
nSumS += (int)m_pOuterLineV[iLoop].x;
|
|
dAvgF = (double)nSumF/(double)nSetCount;
|
dAvgS = (double)nSumS/(double)nSetCount;
|
dslope = (dAvgS-dAvgF)/(double)rectIns.Height();
|
|
VPoint[0].x = (int)dAvgF;
|
VPoint[0].y = 0;
|
VPoint[1].x = (int)dAvgS;
|
VPoint[1].y = rectIns.bottom;
|
|
double interX=0,interY=0;
|
if(LineInterSection(HPoint[0],HPoint[1],VPoint[0],VPoint[1],interX,interY) == TRUE)
|
{
|
m_nCornerPoint[0].x = interX;
|
m_nCornerPoint[0].y = interY;
|
}
|
|
/*
|
sCoLine lineH,lineV;
|
double costH = ransac_line_fitting (m_pOuterLineH, m_nOuterCountH, lineH, 10);
|
double costV = ransac_line_fitting (m_pOuterLineV, m_nOuterCountV, lineV, 10);
|
|
if (100. < costH && 100. < costV)
|
{
|
HPoint[0].x = 0;
|
HPoint[0].y = (int)(lineH.sy-(double)rectIns.Height()*lineH.my);
|
HPoint[1].x = rectIns.right;
|
HPoint[1].y = (int)(lineH.sy+(double)rectIns.Height()*lineH.my);
|
|
VPoint[0].x = (int)(lineV.sx-(double)rectIns.Width()*lineV.mx);
|
VPoint[0].y = 0;
|
VPoint[1].x = (int)(lineV.sx+(double)rectIns.Width()*lineV.mx);
|
VPoint[1].y = rectIns.bottom;
|
}*/
|
|
return TRUE;
|
}
|
|
double CCornerCut::ransac_line_fitting(sCoPoint *data, int no_data, sCoLine &model, double distance_threshold)
|
{
|
const int no_samples = 2;
|
|
if (no_data < no_samples) {
|
return 0.;
|
}
|
|
sCoPoint *samples = new sCoPoint[no_samples];
|
|
int no_inliers = 0;
|
sCoPoint *inliers = new sCoPoint[no_data];
|
|
sCoLine estimated_model;
|
double max_cost = 0.;
|
|
int max_iteration = (int)(1 + log(1. - 0.99)/log(1. - pow(0.5, no_samples)));
|
|
for (int i = 0; i<max_iteration; i++) {
|
// 1. hypothesis
|
|
// ¿øº» µ¥ÀÌÅÍ¿¡¼ ÀÓÀÇ·Î N°³ÀÇ ¼ÀÇà µ¥ÀÌÅ͸¦ °í¸¥´Ù.
|
get_samples (samples, no_samples, data, no_data);
|
|
// ÀÌ µ¥ÀÌÅ͸¦ Á¤»óÀûÀÎ µ¥ÀÌÅÍ·Î º¸°í ¸ðµ¨ ÆĶó¸ÞÅ͸¦ ¿¹ÃøÇÑ´Ù.
|
compute_model_parameter (samples, no_samples, estimated_model);
|
|
// 2. Verification
|
|
// ¿øº» µ¥ÀÌÅÍ°¡ ¿¹ÃøµÈ ¸ðµ¨¿¡ Àß ¸Â´ÂÁö °Ë»çÇÑ´Ù.
|
double cost = model_verification (inliers, &no_inliers, estimated_model, data, no_data, distance_threshold);
|
|
// ¸¸ÀÏ ¿¹ÃøµÈ ¸ðµ¨ÀÌ Àß ¸Â´Â´Ù¸é, ÀÌ ¸ðµ¨¿¡ ´ëÇÑ À¯È¿ÇÑ µ¥ÀÌÅÍ·Î »õ·Î¿î ¸ðµ¨À» ±¸ÇÑ´Ù.
|
if (max_cost < cost) {
|
max_cost = cost;
|
|
compute_model_parameter (inliers, no_inliers, model);
|
}
|
}
|
|
delete [] samples;
|
delete [] inliers;
|
|
return max_cost;
|
}
|
|
bool CCornerCut::find_in_samples (sCoPoint *samples, int no_samples, sCoPoint *data)
|
{
|
for (int i=0; i<no_samples; ++i) {
|
if (samples[i].x == data->x && samples[i].y == data->y) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
void CCornerCut::get_samples (sCoPoint *samples, int no_samples, sCoPoint *data, int no_data)
|
{
|
// µ¥ÀÌÅÍ¿¡¼ Áߺ¹µÇÁö ¾Ê°Ô N°³ÀÇ ¹«ÀÛÀ§ ¼ÀÇÃÀ» äÃëÇÑ´Ù.
|
for (int i=0; i<no_samples; ) {
|
int j = rand()%no_data;
|
|
if (!find_in_samples(samples, i, &data[j])) {
|
samples[i] = data[j];
|
++i;
|
}
|
};
|
}
|
|
int CCornerCut::compute_model_parameter(sCoPoint samples[], int no_samples, sCoLine &model)
|
{
|
// PCA ¹æ½ÄÀ¸·Î Á÷¼± ¸ðµ¨ÀÇ ÆĶó¸ÞÅ͸¦ ¿¹ÃøÇÑ´Ù.
|
|
double sx = 0, sy = 0;
|
double sxx = 0, syy = 0;
|
double sxy = 0, sw = 0;
|
|
for(int i = 0; i<no_samples;++i)
|
{
|
double &x = samples[i].x;
|
double &y = samples[i].y;
|
|
sx += x;
|
sy += y;
|
sxx += x*x;
|
sxy += x*y;
|
syy += y*y;
|
sw += 1;
|
}
|
|
//variance;
|
double vxx = (sxx - sx*sx/sw)/sw;
|
double vxy = (sxy - sx*sy/sw)/sw;
|
double vyy = (syy - sy*sy/sw)/sw;
|
|
//principal axis
|
double theta = atan2(2*vxy, vxx - vyy)/2;
|
|
model.mx = cos(theta);
|
model.my = sin(theta);
|
|
//center of mass(xc, yc)
|
model.sx = sx/sw;
|
model.sy = sy/sw;
|
|
//Á÷¼±ÀÇ ¹æÁ¤½Ä: sin(theta)*(x - sx) = cos(theta)*(y - sy);
|
return 1;
|
}
|
|
double CCornerCut::compute_distance(sCoLine &line, sCoPoint &x)
|
{
|
// ÇÑ Á¡(x)·ÎºÎÅÍ Á÷¼±(line)¿¡ ³»¸° ¼ö¼±ÀÇ ±æÀÌ(distance)¸¦ °è»êÇÑ´Ù.
|
|
return fabs((x.x - line.sx)*line.my - (x.y - line.sy)*line.mx)/sqrt(line.mx*line.mx + line.my*line.my);
|
}
|
|
double CCornerCut::model_verification (sCoPoint *inliers, int *no_inliers, sCoLine &estimated_model, sCoPoint *data, int no_data, double distance_threshold)
|
{
|
*no_inliers = 0;
|
|
double cost = 0.;
|
|
for(int i=0; i<no_data; i++){
|
// Á÷¼±¿¡ ³»¸° ¼ö¼±ÀÇ ±æÀ̸¦ °è»êÇÑ´Ù.
|
double distance = compute_distance(estimated_model, data[i]);
|
|
// ¿¹ÃøµÈ ¸ðµ¨¿¡¼ À¯È¿ÇÑ µ¥ÀÌÅÍÀÎ °æ¿ì, À¯È¿ÇÑ µ¥ÀÌÅÍ ÁýÇÕ¿¡ ´õÇÑ´Ù.
|
if (distance < distance_threshold) {
|
cost += 1.;
|
|
inliers[*no_inliers] = data[i];
|
++(*no_inliers);
|
}
|
}
|
|
return cost;
|
}
|
|
// Bresenham's line algorithm
|
void CCornerCut::bresenham_Line(COwnerBuffer *pRes,CPoint posStart,CPoint posEnd,BYTE color)
|
{
|
if(posStart.x <= 0 || posStart.y <= 0 || posEnd.x <= 0 || posEnd.y <= 0)
|
return;
|
|
const bool steep = (abs(posEnd.y - posStart.y) > abs(posEnd.x - posStart.x));
|
|
if(steep)
|
{
|
swapLong(posStart.x, posStart.y);
|
swapLong(posEnd.x, posEnd.y);
|
}
|
|
if(posStart.x > posEnd.x)
|
{
|
swapLong(posStart.x, posEnd.x);
|
swapLong(posStart.y, posEnd.y);
|
}
|
|
const int dx = posEnd.x - posStart.x;
|
const int dy = abs(posEnd.y - posStart.y);
|
|
float error = (float)dx / 2.0f;
|
const int ystep = (posStart.y < posEnd.y) ? 1 : -1;
|
int y = (int)posStart.y;
|
|
const int maxX = (int)posEnd.x;
|
|
for(int x=(int)posStart.x; x<maxX; x++)
|
{
|
if(steep)
|
{
|
pRes->SetPixel(y,x, color);
|
}
|
else
|
{
|
pRes->SetPixel(x,y, color);
|
}
|
|
error -= dy;
|
if(error < 0)
|
{
|
y += ystep;
|
error += dx;
|
}
|
}
|
}
|
