www.pudn.com > roadextr.rar > strline.cpp
/* ------------------------------------------------------------------------------
Automatic extraction of edges and straight line segments
from gray image.
2000,May
----------------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "valdef.h"
#include "strline.h"
#include "SolveEquation.h"
//#include "nrml.h"
//#include "rdextr.h"
//#include "LineTemplateMatch.h"
#include
#include
/* ---------------------------------------------------------------------------------------------------
Adaptive Least Square Template Matching
-------------------------------------------------------------------------------------------------------
*/
//BOOL A_LSTM_EdgeLineRectify(unsigned char *pucImg,int nRow,int nCol,double dfLengthLimt,
// dfPOINT *pdfptIn,dfPOINT *pdfptOut,double dfDltLimt)
//{
// int *pnTemp,rr,cc,nRange,c,m,r,dwTimes,maxPr;
// int i,nTempH,nTempW,nEdgeW,j,jj;
// double gy,maxd,thta,h0,h1,sint,cost,pdfD[4],pdfPara[10],d,*pdfcc,*pdflc,*pdfaa,maxpp,pp;
// double xx0,yy0,xx,yy,pdfVx[1],pdfVy[1],pdfH0[1],pdfH1[1],dfP,pdfXX[2],pdfYY[2],vv;
// unsigned char pucTemp_0[51],pucTemp_1[51],pucTemp_2[51],pucTemp_3[51],pucNewTmp[51];
// unsigned char *pucStrLine;
//
// nRange = 17; /// 15
// nEdgeW = 8;
// nTempH = 2*nEdgeW + 1;
// nTempW = 3;
// //// genertae default templates I(x) = 1/(1+exp(-a*x));
// for(i=0;i=nRow) rr = nRow-1;
// if(cc<0) cc =0; if(cc>=nCol) cc = nCol-1;
//
// *(pucStrLine+(nRange+r)*nTempW+m)=*(pucImg+rr*nCol+cc);
// }
// }
// for(j=0;j<4;j++)//// find maximized template
// {
// for(r=0;rfabs(maxpp))
// { maxpp = pp;
// maxPr = r;
// jj = j;
// }
//
// }
// }
// if(fabs(maxpp) < 0.8 )
// continue;
// /////// generate new template
// if(jj==0)
// { if(maxpp<0)
// ReversTemp(pucTemp_0,nTempH,nTempW);
// ReturnH0H1(pucStrLine+maxPr*nTempW,pucTemp_0,nTempH*nTempW,pdfH0,pdfH1);
// ReGenerateTemp(pucNewTmp,pucTemp_0,nTempH*nTempW,*pdfH0,*pdfH1);
// }
// if(jj==1)
// { if(maxpp<0)
// ReversTemp(pucTemp_1,nTempH,nTempW);
// ReturnH0H1(pucStrLine+maxPr*nTempW,pucTemp_1,nTempH*nTempW,pdfH0,pdfH1);
// ReGenerateTemp(pucNewTmp,pucTemp_1,nTempH*nTempW,*pdfH0,*pdfH1);
// }
// if(jj==2)
// { if(maxpp<0)
// ReversTemp(pucTemp_2,nTempH,nTempW);
// ReturnH0H1(pucStrLine+maxPr*nTempW,pucTemp_2,nTempH*nTempW,pdfH0,pdfH1);
// ReGenerateTemp(pucNewTmp,pucTemp_2,nTempH*nTempW,*pdfH0,*pdfH1);
// }
// if(jj==3)
// { if(maxpp<0)
// ReversTemp(pucTemp_3,nTempH,nTempW);
// ReturnH0H1(pucStrLine+maxPr*nTempW,pucTemp_3,nTempH*nTempW,pdfH0,pdfH1);
// ReGenerateTemp(pucNewTmp,pucTemp_3,nTempH*nTempW,*pdfH0,*pdfH1);
// }
// for(r=-nEdgeW;r<=nEdgeW;r++)
// { for(m=0;m20) ////
// break;
// dwTimes++;
// }
// ///// output
// for(i=0;i<2;i++)
// { pdfptOut[i].dfX = pdfPara[2*i];
// pdfptOut[i].dfY = pdfPara[2*i+1];
// }
//
// delete pdfcc;
// delete pdflc;
// delete pdfaa;
// return TRUE;
//}
//
//void ReversTemp(BYTE *pucTemp,int nTempH,int nTempW)
//{
// BYTE *pucTemp2;
// pucTemp2 = new BYTE[nTempH*nTempW];
// for(int n=0;n=nCol)
// nStX = nCol-nW;
// if(dfDetRange+dfptInput.dfY>=nRow)
// nStY = (int)nRow-nH;
// if(dfptInput.dfX-dfDetRange<=0)
// nStX=0;
// if(dfptInput.dfY-dfDetRange<=0)
// nStY=0;
// x0 = dfptInput.dfX-nStX;
// y0 = dfptInput.dfY-nStY;
//
// pucI = (unsigned char *)malloc((nW+10)*nH*sizeof(char));
//
// GetImgBlock2(pucImg,nCol,pucI,nH,nW,nStY,nStX);
///*
// int nWid = 9;
// float maxIntr,intr;
// int nXX,nYY;
// maxIntr = -100000000;
//
// for(r=nWid/2;rmaxIntr)
// { maxIntr = intr;
// nXX = c; nYY = r;
// }
// }
// pCornerPt[0].dfptCorner.dfX=nStX+nXX;
// pCornerPt[0].dfptCorner.dfY=nStY+nYY;
// delete pucI;
// return 1;
//
//*/
// pLineSeg = (StraightLineSeg *)malloc(500*sizeof(StraightLineSeg));
//
// nLineSegC = DetectStrLineSeg_Gray(pucI,nH,nW,0.1,30,30,pLineSeg,13,13,1.2);
///*
// for(m=0;m1)
// cosa = 1.0;
// a = acos(cosa);
// */
// // if(fabs(fabs(t1-t2)-PI/2)x;
// y = pCornerPt[nCC].dfptCorner.dfY = pdfptPOut->y;
// d = sqrt((x0-x)*(x0-x)+(y0-y)*(y0-y));
// if(d>10)
// continue;
// d = 1.0/d; ////所求角点到输入点的距离的倒数为权
// pCornerPt[nCC].dfWei = d;
// dd[0] = sqrt((xx1-x)*(xx1-x)+(yy1-y)*(yy1-y));
// dd[1] = sqrt((x-xx4)*(x-xx4)+(y-yy4)*(y-yy4));
// dd[2] = sqrt((xx2-x)*(xx2-x)+(yy2-y)*(yy2-y));
// dd[3] = sqrt((xx3-x)*(xx3-x)+(yy3-y)*(yy3-y));
//
// if(dd[0]d)
// { n = m;
// d = pCornerPt[m].dfWei;
// }
// }
// /////改变
// ////交换
// pt1.dfX = pCornerPt[n].dfptCorner.dfX; pt1.dfY = pCornerPt[n].dfptCorner.dfY;
// pt2.dfX = pCornerPt[n].dfptInterSect1.dfX; pt2.dfY = pCornerPt[n].dfptInterSect1.dfY;
// pt3.dfX = pCornerPt[n].dfptInterSect2.dfX; pt2.dfY = pCornerPt[n].dfptInterSect2.dfY;
// pCornerPt[n].dfptCorner.dfX = pCornerPt[0].dfptCorner.dfX;
// pCornerPt[n].dfptCorner.dfY = pCornerPt[0].dfptCorner.dfY;
// pCornerPt[n].dfptInterSect1.dfX = pCornerPt[0].dfptInterSect1.dfX;
// pCornerPt[n].dfptInterSect1.dfY = pCornerPt[0].dfptInterSect1.dfY;
// pCornerPt[n].dfptInterSect2.dfX = pCornerPt[0].dfptInterSect2.dfX;
// pCornerPt[n].dfptInterSect2.dfY = pCornerPt[0].dfptInterSect2.dfY;
// pCornerPt[0].dfptCorner.dfX = pt1.dfX; pCornerPt[0].dfptCorner.dfY = pt1.dfY;
// pCornerPt[0].dfptInterSect1.dfX = pt2.dfX; pCornerPt[0].dfptInterSect1.dfY = pt2.dfY;
// pCornerPt[0].dfptInterSect2.dfX = pt2.dfX; pCornerPt[0].dfptInterSect2.dfY = pt2.dfY;
//
//
// for(m=0;mx;
// y = pdfptPOut->y;
//
// dd[0] = sqrt((xx1-x)*(xx1-x)+(yy1-y)*(yy1-y)); // st-m
// dd[1] = sqrt((x-xx4)*(x-xx4)+(y-yy4)*(y-yy4)); // end-n
// dd[2] = sqrt((xx2-x)*(xx2-x)+(yy2-y)*(yy2-y)); // end-m
// dd[3] = sqrt((xx3-x)*(xx3-x)+(yy3-y)*(yy3-y)); // st-n
//
// if( min(dd[0],dd[2])>TooDistant||min(dd[1],dd[3])>TooDistant // 角点离交出该交点的直线端点的距离过大
// ||fabs(t1-t2)>BigAngle||fabs(t1-t2)=dd[1]&&pnnr[n]!=1))
// { pfptCrossL[nL].x = x; pfptCrossL[nL].y = y; nl[nL] = n;
// nlLRFlag[nL] = dd[3]dd[2]&&pnnr[m]!=1)
// { if((dd[3]=dd[1]&&pnnr[n]!=1))
// { pfptCrossR[nR].x = x; pfptCrossR[nR].y = y; nr[nR] = n;
// nrLRFlag[nR] = dd[3]0) // 第一条线的某个端点方向只有一个距离该端点最近的角点
// {
// for(i=0;i0)
// if(nR>0)//// 第一条线的某个端点方向只有一个距离该端点最近的角点
// {
// for(i=0;i0)
// }//for(m=0;m50?20:0.4*d1;
// sL = 10;
// for(n=m+1;ndfDisDlta) ///// 两线段的距离过大
// continue;
// dt = fabs(t1-t2);
// if(dt>dfThtaDlta&&dtdfThtaDlta&&fabs(t1-tm)d2)
// { d2 = dd[j];
// k=j;
// }
// }
// switch(k)
// { case 0 : x1 = xx1; y1 = yy1; x2 = xx3; y2 = yy3; break;
// case 1 : x1 = xx1; y1 = yy1; x2 = xx4; y2 = yy4; break;
// case 2 : x1 = xx2; y1 = yy2; x2 = xx3; y2 = yy3; break;
// case 3 : x1 = xx2; y1 = yy2; x2 = xx4; y2 = yy4; break;
// }
// dd[0] = min(dd[0],dd[1]); dd[0] = min(dd[0],dd[2]);
// dd[0] = min(dd[0],dd[3]);
// if(dd[0]>sL) ////超出感知范围
// continue;
// ///// 符合条件:两线段合并
// pLineSeg2[nCC].nptSt.dfX = x1; pLineSeg2[nCC].nptEnd.dfX = x2;
// pLineSeg2[nCC].nptSt.dfY = y1; pLineSeg2[nCC].nptEnd.dfY = y2;
// nCC++;
// pLineSeg[m].nFlag = DELETED; ///合并后的两线段标记为删除
// pLineSeg[n].nFlag = DELETED;
// break;
// }
// if(pLineSeg[m].nFlag!=DELETED)////如果未合并,记录孤立的该条线段
// { pLineSeg2[nCC].nptSt.dfX = xx1;
// pLineSeg2[nCC].nptSt.dfY = yy1;
// pLineSeg2[nCC].nptEnd.dfX = xx2;
// pLineSeg2[nCC].nptEnd.dfY = yy2;
// nCC++;
// }
//
// }
// ///// 删除一些短线
//
// nN=0;
// for(j=0;j8*(i+1)*/d1>15)
// { pLineSeg[nN].nptSt.dfX = pLineSeg2[j].nptSt.dfX;
// pLineSeg[nN].nptSt.dfY = pLineSeg2[j].nptSt.dfY;
// pLineSeg[nN].nptEnd.dfX = pLineSeg2[j].nptEnd.dfX;
// pLineSeg[nN].nptEnd.dfY = pLineSeg2[j].nptEnd.dfY;
// pLineSeg[nN].nFlag = UNDELETED;
// nN++;
// }
// }
// nSegCount = nN;
//
// }
// free(pLineSeg2);
//
// return nSegCount;
//}
//
///*
// get the gradients and their directions of extracted straight-segment pixels automatically
//INPUT:
// unsigned char *pucImg,int nRow,int nCol ----- image
// StraightLineSeg *pLineSeg ---------------------- straight line segment structure
//OUTPUT:
// pLineSeg[n].pdfGrad ---------------- the pointer of gradients
// pLineSeg[n].pdfGradDir ---------------- the pointer of gradient directions
//*/
//BOOL GetGradientofStrLineSeg(unsigned char *pucImg,int nRow,int nCol,
// StraightLineSeg *pLineSeg,
// int nSegCount)
//{ int i,j,m,n,r,c,y,nC;
// double gx,gy,g,dir;
//
// for(n=0;n2)
// {
// minx = miny = 1000000;
// maxx = maxy = -1;
// for(n=0;nmaxx)
// maxx=x;
// if(y>maxy)
// maxy = y;
// }
// h = maxy-miny;
// w = maxx-minx;
// sr = miny;
// sc = minx;
// for(n=0;n0&&*(pucImg+r*nCol+c-1)!=BROARD_PT)
// *(pucImg+r*nCol+c) = BROARD_PT;
// }
// }
// else
// { k = dy/dx;
// b = y1-k*x1;
// t = atan(k);
// if(dy==0)
// { r = y1;
// for(j=0;fabs(j)<(int)fabs(dx);j+=dc)
// { c = j+x1;
// *(pucImg+r*nCol+c) = BROARD_PT;
// }
// }
// else
// { for(j=0;fabs(j)<(int)fabs(dy);j+=dr)
// { c =(int)(((j+y1)-b)/k);
// r = j+y1;
// *(pucImg+r*nCol+c) = BROARD_PT;
// }
// }
// }
// }
// ///// 行扫描算法
// for(i=0;i=pfGrad[(I1+1)*3+J1+1]&&pfGrad[4]>=pfGrad[(I2+1)*3+J2+1])
// { ///输出边缘点
// if((*(pucI2+r*nCol+c)!=0)
// && (pfGrad[4] > 2 ) ) ///// pucGradTh[nSumGray]
// {
// *(pucI2+r*nCol+c) = *(pucI+r*nCol+c);
// *(pucI2+(r+I1)*nCol+c+J1) = *(pucI2+(r+I2)*nCol+c+J2)= 0;
// }
// else
// *(pucI2+r*nCol+c) = 0;
// }
// else
// *(pucI2+r*nCol+c) = 0;
// }
// }
// for(r=0;rfabs((double)nGy)?fabs((double)nGx):fabs((double)nGy);
// *(pucI1+r*nCol+c) = (unsigned char)(int)G;
// *(pucI2+r*nCol+c) = (signed char)(int)(2*127*fDir/PI);
// }
// }
//
//// memcpy(pucI1,pucImg,nCol*nRow*sizeof(char));
//
//// Sobel2(pucI1,nRow,nCol,0); /// Sobel 算子得到梯度大小
//
// for(r=2;r=pfGrad[(I1+1)*3+J1+1]&&pfGrad[4]>=pfGrad[(I2+1)*3+J2+1])
// { ///输出边缘点
// if(pfGrad[4]>MAX_GRAD)
// {// *(pucI+r*nCol+c) = *(pucI1+r*nCol+c);
// *(pucI+(r+I1)*nCol+c+J1) = *(pucI+(r+I2)*nCol+c+J2)= 0;
// }
// else
// *(pucI+r*nCol+c) = 0;
// }
// else
// *(pucI+r*nCol+c) = 0;
// }
// }
// for(r=0;r=nRow-1||cc<1||cc>=nCol-1)
break;
pucN8[7]=*(pucImg+(rr-1)*nCol+cc+1); pucN8[6]=*(pucImg+(rr-1)*nCol+cc);
pucN8[5]=*(pucImg+(rr-1)*nCol+cc-1); pucN8[4]=*(pucImg+rr*nCol+cc-1);
pucN8[3]=*(pucImg+(rr+1)*nCol+cc-1); pucN8[2]=*(pucImg+(rr+1)*nCol+cc);
pucN8[1]=*(pucImg+(rr+1)*nCol+cc+1); pucN8[0]=*(pucImg+rr*nCol+cc+1);
ppntNPix[7].nX=cc+1; ppntNPix[7].nY=rr-1; ppntNPix[6].nX=cc; ppntNPix[6].nY=rr-1;
ppntNPix[5].nX=cc-1; ppntNPix[5].nY=rr-1; ppntNPix[4].nX=cc-1; ppntNPix[4].nY=rr;
ppntNPix[3].nX=cc-1; ppntNPix[3].nY=rr+1; ppntNPix[2].nX=cc; ppntNPix[2].nY=rr+1;
ppntNPix[1].nX=cc+1; ppntNPix[1].nY=rr+1; ppntNPix[0].nX=cc+1; ppntNPix[0].nY=rr;
nEnd2Fg=0;
nFg2=0;
for(k=0;k<8;k++)
{ /*if(lsSeg.nPtC>1)
for(kk=2;kk1&&(ppntNPix[k].nX)==lsSeg.pnptPxy[lsSeg.nPtC-2].nX
&&(ppntNPix[k].nY)==lsSeg.pnptPxy[lsSeg.nPtC-2].nY)
/* nEnd2Fg=1;
}
if(nEnd2Fg==1)*/
continue;
if(pucN8[k]==0)
{ nFg2=1;
lsSeg.pnptPxy[n].nX=ppntNPix[k].nX;
lsSeg.pnptPxy[n].nY=ppntNPix[k].nY;
n++;
lsSeg.nPtC=n;
}
if(nFg2==1)
break;
}
if(lsSeg.nPtC>nST)
break;
if(lsSeg.nPtC<=nST)
{ if(nFg2==0/*&&lsSeg.nPtC<=nST*/)
{ for(m=0;m=nRow-1||cc<1||cc>=nCol-1)
break;
if(n>=MAX_CURVE_POINT_COUNT)
break;
pucN8[7]=*(pucImg+(rr-1)*nCol+cc+1); pucN8[6]=*(pucImg+(rr-1)*nCol+cc);
pucN8[5]=*(pucImg+(rr-1)*nCol+cc-1); pucN8[4]=*(pucImg+rr*nCol+cc-1);
pucN8[3]=*(pucImg+(rr+1)*nCol+cc-1); pucN8[2]=*(pucImg+(rr+1)*nCol+cc);
pucN8[1]=*(pucImg+(rr+1)*nCol+cc+1); pucN8[0]=*(pucImg+rr*nCol+cc+1);
ppntNPix[7].nX=cc+1; ppntNPix[7].nY=rr-1; ppntNPix[6].nX=cc; ppntNPix[6].nY=rr-1;
ppntNPix[5].nX=cc-1; ppntNPix[5].nY=rr-1; ppntNPix[4].nX=cc-1; ppntNPix[4].nY=rr;
ppntNPix[3].nX=cc-1; ppntNPix[3].nY=rr+1; ppntNPix[2].nX=cc; ppntNPix[2].nY=rr+1;
ppntNPix[1].nX=cc+1; ppntNPix[1].nY=rr+1; ppntNPix[0].nX=cc+1; ppntNPix[0].nY=rr;
nEnd2Fg=0;
nFg2=0;
for(k=0;k<8;k++)
{ if(lsSeg.nPtC>1&&(ppntNPix[k].nX)==lsSeg.pnptPxy[lsSeg.nPtC-2].nX
&&(ppntNPix[k].nY)==lsSeg.pnptPxy[lsSeg.nPtC-2].nY)///若为已经记录的点
continue;
if(pucN8[k]!=255)////记录一点
{ nFg2=1;
lsSeg.pnptPxy[n].nX=ppntNPix[k].nX;
lsSeg.pnptPxy[n].nY=ppntNPix[k].nY;
n++;
lsSeg.nPtC=n;
}
if(nFg2==1)
break;
}
// if(lsSeg.nPtC>nST)
// break;
if(nFg2==0)////没有记录相邻点(is the end point!)
{ ///restore the points to Curve
// pCurve[nCurveC].pnptPxy = (nPOINT *)malloc((lsSeg.nPtC)*sizeof(nPOINT));
pCurve[nCurveC].pnptPxy = new nPOINT[lsSeg.nPtC];
pCurve[nCurveC].nPtC = lsSeg.nPtC;
for(m=0;m=nRow-1||cc<1||cc>=nCol-1)
break;
if(n>=MAX_CURVE_POINT_COUNT)
break;
pucN8[7]=*(pucImg+(rr-1)*nCol+cc+1); pucN8[6]=*(pucImg+(rr-1)*nCol+cc);
pucN8[5]=*(pucImg+(rr-1)*nCol+cc-1); pucN8[4]=*(pucImg+rr*nCol+cc-1);
pucN8[3]=*(pucImg+(rr+1)*nCol+cc-1); pucN8[2]=*(pucImg+(rr+1)*nCol+cc);
pucN8[1]=*(pucImg+(rr+1)*nCol+cc+1); pucN8[0]=*(pucImg+rr*nCol+cc+1);
ppntNPix[7].nX=cc+1; ppntNPix[7].nY=rr-1; ppntNPix[6].nX=cc; ppntNPix[6].nY=rr-1;
ppntNPix[5].nX=cc-1; ppntNPix[5].nY=rr-1; ppntNPix[4].nX=cc-1; ppntNPix[4].nY=rr;
ppntNPix[3].nX=cc-1; ppntNPix[3].nY=rr+1; ppntNPix[2].nX=cc; ppntNPix[2].nY=rr+1;
ppntNPix[1].nX=cc+1; ppntNPix[1].nY=rr+1; ppntNPix[0].nX=cc+1; ppntNPix[0].nY=rr;
nEnd2Fg=0;
nFg2=0;
for(k=0;k<8;k++)
{ if((lsSeg.nPtC>1&&(ppntNPix[k].nX)==lsSeg.pnptPxy[lsSeg.nPtC-2].nX
&&(ppntNPix[k].nY)==lsSeg.pnptPxy[lsSeg.nPtC-2].nY)||
(lsSeg.nPtC>2&&(ppntNPix[k].nX)==lsSeg.pnptPxy[lsSeg.nPtC-3].nX
&&(ppntNPix[k].nY)==lsSeg.pnptPxy[lsSeg.nPtC-3].nY))///若为已经记录的点
continue;
if(pucN8[k]!=255)////记录一点
{ nFg2=1;
lsSeg.pnptPxy[n].nX=ppntNPix[k].nX;
lsSeg.pnptPxy[n].nY=ppntNPix[k].nY;
n++;
lsSeg.nPtC=n;
}
if(nFg2==1)
break;
}
// if(lsSeg.nPtC>nST)
// break;
///如果回到起点，则跟踪结束
if(nFg2==0||(lsSeg.pnptPxy[n-1].nX==x0&&
lsSeg.pnptPxy[n-1].nY==y0))////没有记录相邻点(is the end point!)||回到起点
{ ///restore the points to Curve
// pCurve[nCurveC].pnptPxy = (nPOINT *)malloc((lsSeg.nPtC)*sizeof(nPOINT));
pCurve[nCurveC].pnptPxy = new nPOINT[lsSeg.nPtC];
pCurve[nCurveC].nPtC = lsSeg.nPtC;
for(m=0;m=nRow-1||cc<1||cc>=nCol-1)
// break;
// if(n>=MAX_CURVE_POINT_COUNT)
// break;
// pucN8[7]=*(pucImg+(rr-1)*nCol+cc+1); pucN8[6]=*(pucImg+(rr-1)*nCol+cc);
// pucN8[5]=*(pucImg+(rr-1)*nCol+cc-1); pucN8[4]=*(pucImg+rr*nCol+cc-1);
// pucN8[3]=*(pucImg+(rr+1)*nCol+cc-1); pucN8[2]=*(pucImg+(rr+1)*nCol+cc);
// pucN8[1]=*(pucImg+(rr+1)*nCol+cc+1); pucN8[0]=*(pucImg+rr*nCol+cc+1);
//
// ppntNPix[7].nX=cc+1; ppntNPix[7].nY=rr-1; ppntNPix[6].nX=cc; ppntNPix[6].nY=rr-1;
// ppntNPix[5].nX=cc-1; ppntNPix[5].nY=rr-1; ppntNPix[4].nX=cc-1; ppntNPix[4].nY=rr;
// ppntNPix[3].nX=cc-1; ppntNPix[3].nY=rr+1; ppntNPix[2].nX=cc; ppntNPix[2].nY=rr+1;
// ppntNPix[1].nX=cc+1; ppntNPix[1].nY=rr+1; ppntNPix[0].nX=cc+1; ppntNPix[0].nY=rr;
// nEnd2Fg=0;
// nFg2=0;
// for(k=0;k<8;k++)
// { if(lsSeg.nPtC>1&&(ppntNPix[k].nX)==lsSeg.pnptPxy[lsSeg.nPtC-2].nX
// &&(ppntNPix[k].nY)==lsSeg.pnptPxy[lsSeg.nPtC-2].nY)///若为已经记录的点
// continue;
//
// if(pucN8[k]!=255)////记录一点
// { nFg2=1;
// lsSeg.pnptPxy[n].nX=ppntNPix[k].nX;
// lsSeg.pnptPxy[n].nY=ppntNPix[k].nY;
//
// n++;
// lsSeg.nPtC=n;
// }
// if(nFg2==1)
// break;
// }
// // if(lsSeg.nPtC>nST)
// // break;
//
// if(nFg2==0 /* && lsSeg.nPtC > (int)fLmt */)////没有记录相邻点(is the end point!)
// { ///restore the points to Curve
// // pCurve[nCurveC].pnptPxy = (nPOINT *)malloc((lsSeg.nPtC)*sizeof(nPOINT));
// if(lsSeg.nPtC > (int)fLmt)
// {
// pCurve[nCurveC].pnptPxy = new nPOINT[lsSeg.nPtC];
// pCurve[nCurveC].nPtC = lsSeg.nPtC;
//
// for(m=0;m=nRow-1||cc<1||cc>=nCol-1)
// break;
// if(n>=MAX_CURVE_POINT_COUNT)
// break;
// pucN8[7]=*(pucImg+(rr-1)*nCol+cc+1); pucN8[6]=*(pucImg+(rr-1)*nCol+cc);
// pucN8[5]=*(pucImg+(rr-1)*nCol+cc-1); pucN8[4]=*(pucImg+rr*nCol+cc-1);
// pucN8[3]=*(pucImg+(rr+1)*nCol+cc-1); pucN8[2]=*(pucImg+(rr+1)*nCol+cc);
// pucN8[1]=*(pucImg+(rr+1)*nCol+cc+1); pucN8[0]=*(pucImg+rr*nCol+cc+1);
//
// ppntNPix[7].nX=cc+1; ppntNPix[7].nY=rr-1; ppntNPix[6].nX=cc; ppntNPix[6].nY=rr-1;
// ppntNPix[5].nX=cc-1; ppntNPix[5].nY=rr-1; ppntNPix[4].nX=cc-1; ppntNPix[4].nY=rr;
// ppntNPix[3].nX=cc-1; ppntNPix[3].nY=rr+1; ppntNPix[2].nX=cc; ppntNPix[2].nY=rr+1;
// ppntNPix[1].nX=cc+1; ppntNPix[1].nY=rr+1; ppntNPix[0].nX=cc+1; ppntNPix[0].nY=rr;
// nEnd2Fg=0;
// nFg2=0;
// for(k=0;k<8;k++)
// { if((lsSeg.nPtC>1&&(ppntNPix[k].nX)==lsSeg.pnptPxy[lsSeg.nPtC-2].nX
// &&(ppntNPix[k].nY)==lsSeg.pnptPxy[lsSeg.nPtC-2].nY)||
// (lsSeg.nPtC>2&&(ppntNPix[k].nX)==lsSeg.pnptPxy[lsSeg.nPtC-3].nX
// &&(ppntNPix[k].nY)==lsSeg.pnptPxy[lsSeg.nPtC-3].nY))///若为已经记录的点
// continue;
//
// if(pucN8[k]!=255)////记录一点
// { nFg2=1;
// lsSeg.pnptPxy[n].nX=ppntNPix[k].nX;
// lsSeg.pnptPxy[n].nY=ppntNPix[k].nY;
//
// n++;
// lsSeg.nPtC=n;
// }
// if(nFg2==1)
// break;
// }
// // if(lsSeg.nPtC>nST)
// // break;
// ///如果回到起点，则跟踪结束
// if( nFg2==0
// ||(lsSeg.pnptPxy[n-1].nX==x0&& lsSeg.pnptPxy[n-1].nY==y0) ) ////没有记录相邻点(is the end point!)||回到起点
// { ///restore the points to Curve
// // pCurve[nCurveC].pnptPxy = (nPOINT *)malloc((lsSeg.nPtC)*sizeof(nPOINT));
// if( lsSeg.nPtC > (int)fLmt)
// { pCurve[nCurveC].pnptPxy = new nPOINT[lsSeg.nPtC];
// pCurve[nCurveC].nPtC = lsSeg.nPtC;
//
// for(m=0;m=nRow-2||c<2||c>=nCol-2)
*(pucImg+r*nCol+c) = 255;
}
}
DeleteShortBanch(pucImg,nRow,nCol,nST);
// DelCornerPtBinLineImg(pucImg,nRow,nCol);
nStrSegC = 0;
pCurve = (LineSeg *)malloc(MAX_CURVE_SEG_COUNT*sizeof(LineSeg));
pdfX = (double *)malloc(MAX_CURVE_POINT_COUNT*sizeof(double));/// middel result
pdfY = (double *)malloc(MAX_CURVE_POINT_COUNT*sizeof(double));/// middel result
pdfX2 = (double *)malloc(MAX_CURVE_POINT_COUNT*sizeof(double));/// added
pdfY2 = (double *)malloc(MAX_CURVE_POINT_COUNT*sizeof(double));/// added
pdfXX = (double *)malloc(MAX_CURVE_POINT_COUNT*sizeof(double));/// added
pdfYY = (double *)malloc(MAX_CURVE_POINT_COUNT*sizeof(double));/// added
if(!pdfX||!pdfY||!pdfX2||!pdfY2)
return -1;
////
nCurveC = TraceSingleWidthCurve(pucImg,nRow,nCol,pCurve);
for(n=0;n=nLengthMin)
{
nCC=pnNo[i+1]-pnNo[i]+1;
/////Attention: release the memory!!
pLineSeg[nStrSegC].pdfptP = (dfPOINT *)malloc(nCC*sizeof(dfPOINT));
for(m=0;m10.0)///if the 接近90度
// { c=s=cos(PI/4); t = 1.0;
// ////将坐标系旋转45度
// for(n=0;n= dfThresh)
{ pcNo[index] = 1;/// Add it to the index
if(index-nStNo>1)///前半部分递归
CompressALine02(pdfX,pdfY,
index-nStNo+1,dfThresh,nStNo,index,pcNo);
if(nEndNo-index>1)///后半部分递归
CompressALine02(pdfX,pdfY,
nEndNo-index+1,dfThresh,index,nEndNo,pcNo);
}
return nRetPtC;
}
/*
密集点列的压缩： 分裂--拟合法(sprit-fitting)
*/
int CmprsLine02(double *pdfX,double *pdfY, ///------- input points
int nPtCount,
double dfThresh /// ---- error limit in vertical direction of str line
)
{ int nRetPtC,i;
char *pcNo;
double *pdfXM,*pdfYM,pdfMaxD[3];
pcNo= new char[nPtCount];
pdfXM = new double[nPtCount];/// middel result
pdfYM = new double[nPtCount];
if(pdfXM==NULL||pdfYM==NULL||pcNo==NULL)
return -1;
for(i=0;idfMaxD)
{ dfMaxD = vm;
n=i;
}
}
*pdfMaxD = dfMaxD;
return n;
}
//BOOL HilditchThin2(BYTE *pucImg,int nImgRow,int nImgCol)
//{
// BYTE *pucI;
// int r,c,s,xx,yy,x,k,nrn,n[10];
//
//
// pucI = (BYTE *)malloc((long)nImgRow*nImgCol*sizeof(BYTE));
// if(!pucI)
// return FALSE;
//
// /* binarylize */
// for(r=0;rx = ( dx0*dx2*(pt[2].y-pt[0].y) + dx2*dy0*pt[0].x - dx0*dy2*pt[2].x ) /
// ( dx2*dy0 - dx0*dy2 );
//
// interPt->y = ( dy0*dy2*(pt[0].x-pt[2].x) + dx2*dy0*pt[2].y - dx0*dy2*pt[0].y ) /
// ( dx2*dy0 - dx0*dy2 );
//
// return TRUE;
//}
//
//BOOL CrossPtOf2StraightLine_2(dfPOINT* pt, dfPOINT* interPt)
//{
//// fPoint interPt;
// double dx0, dx2, dy0, dy2;
//
// dx0 = pt[1].dfX-pt[0].dfX;
// dy0 = pt[1].dfY-pt[0].dfY;
// dx2 = pt[3].dfX-pt[2].dfX;
// dy2 = pt[3].dfY-pt[2].dfY;
//
// if(dx2*dy0 == dx0*dy2)//平行
// {
// return FALSE;
// }
//
// interPt->dfX = ( dx0*dx2*(pt[2].dfY-pt[0].dfY) + dx2*dy0*pt[0].dfX - dx0*dy2*pt[2].dfX ) /
// ( dx2*dy0 - dx0*dy2 );
//
// interPt->dfY = ( dy0*dy2*(pt[0].dfX-pt[2].dfX) + dx2*dy0*pt[2].dfY - dx0*dy2*pt[0].dfY ) /
// ( dx2*dy0 - dx0*dy2 );
//
// return TRUE;
//}
//
//
//
///* 二维坐标变换:
// dfX0,dfY0 -------- 在原坐标系下的新原点坐标
// dfThta ----------- 新坐标系的旋转角
// dfXin,dfYin ----- 输入新坐标系下的一点的X，Y
// *pdfXout,*pdfYout --- 输出该点在老坐标系下的坐标
//*/
//BOOL RetCordFromNewtoOld(double dfX0,double dfY0,
// double dfThta,double dfXin,
// double dfYin,double *pdfXout,
// double *pdfYout)
//{ *pdfXout = dfX0 + dfXin*cos(dfThta) - dfYin*sin(dfThta);
// *pdfYout = dfY0 + dfYin*cos(dfThta) + dfXin*sin(dfThta);
//
// return TRUE;
//}
///*
//
//*/
//BOOL RectifyStraightEdgeSeg(unsigned char *pucImg,
// int nRow,int nCol,double dfMaxBias,
// dfPOINT *pdfptIn,dfPOINT *pdfptOut,
// double dfDltLimt)
//{ double d,Dltai,Dlta,maxDlt,dfMaxY,xc,yr,dir,
// pdfK[3],pdfB[3],x0,y0,x1,y1,dfThta,yrr,xx,yy;
// double *pdfX,*pdfY,*pdfX2,*pdfY2,pdfXout[3],pdfYout[3];
// int i,ii,r,c,n,G,GMax,nN,nC,nGx,nGy,nC2,nCLimt,*pnNo;
// unsigned char *pucFg;
//
//// if(fabs(dfMaxBias)>PI/4)
//// return FALSE;
// if(pdfptIn[0].dfX<=pdfptIn[1].dfX)
// {
// x0 = pdfptIn[0].dfX; y0 = pdfptIn[0].dfY;
// x1 = pdfptIn[1].dfX; y1 = pdfptIn[1].dfY;
// }
// else
// {
// x0 = pdfptIn[1].dfX; y0 = pdfptIn[1].dfY;
// x1 = pdfptIn[0].dfX; y1 = pdfptIn[0].dfY;
// }
//
// d = sqrt((x0-x1)*(x0-x1)+(y0-y1)*(y0-y1));
// nCLimt =(int)(d*0.75);
// nN = (int)(d+2);
// dfMaxY = fabs(dfMaxBias);
// if(d<=30.0)
// return FALSE;
// if(dfMaxY<1.0)
// return FALSE;
// if(d<10)
// return FALSE;
//
// pdfX = (double *)malloc(nN*sizeof(double));
// pdfY = (double *)malloc(nN*sizeof(double));
// pdfX2 = (double *)malloc(nN*sizeof(double));
// pdfY2 = (double *)malloc(nN*sizeof(double));
// pucFg = (unsigned char *)malloc(nN*sizeof(char));
// pnNo = (int *)malloc(nN*sizeof(int));
// for(n=0;n=nRow-1||c<=0||c>=nCol-1)
// G = 0;
// else
// { nGx = ((int)(*(pucImg+(r)*nCol+c+1))
// -*(pucImg+(r)*nCol+c-1))/2;
// nGy = ((int)(*(pucImg+(r+1)*nCol+c))
// -*(pucImg+(r-1)*nCol+c))/2;
// G = (int)sqrt(nGx*nGx+nGy*nGy);
// dir = (nGx==0)?PI/2:atan((double)nGy/nGx);
// }
// if(/*fabs((dir+PI/2)-dfThta)>PI/10.0||*/G==0)
// continue;
// else
// { if(yr==-dfMaxY||G>GMax)
// { GMax = G;
// yrr = yr;
// }
// }
// }
// *(pdfX+nC) = xc;
// *(pdfY+nC) = yrr;
// nC++;
// }
// //// 叠代拟合
// for(;;)
// { nC2 = 0;
// for(i=0;iDlta)
// *(pucFg+(*(pnNo+i))) = 0;
// }
//*/
// *(pucFg+(*(pnNo+ii))) = 0; //// 下次拟合驱除最大方差点
//
// }
// //// 输出纠正后的直线段
// xx = 0.0; ////起点
// yy = pdfB[0];
//
// RetCordFromNewtoOld(x0,y0,dfThta,xx,yy,pdfXout,pdfYout); ////换回老坐标
//
// pdfptOut[0].dfX = pdfXout[0];
// pdfptOut[0].dfY = pdfYout[0]; /////
//
// xx = d;
// yy = (pdfK[0])*(xx)+pdfB[0];
//
// RetCordFromNewtoOld(x0,y0,dfThta,xx,yy,pdfXout,pdfYout);
//
// pdfptOut[1].dfX = pdfXout[0];
// pdfptOut[1].dfY = pdfYout[0];
//
//
// free(pdfX);free(pdfY);
// free(pdfX2);free(pdfY2);
// free(pucFg); free(pnNo);
//
// return TRUE;
//
//}
///*
// 最小二乘直线模板匹配
//*/
//BOOL RectifyStraightEdgeSeg2(unsigned char *pucImg,
// int nRow,int nCol,double dfLengthLimt,
// dfPOINT *pdfptIn, ///// 输入两点的坐标
// dfPOINT *pdfptOut, //// 输出两点的坐标
// double dfDltLimt)
//{ int i,j,n,m,No[3],r,c,rr,cc,maxPr,nInPtC,nN,nRange,nTempW,nTempH;
// unsigned long dwTimes;
// double pdfD[100],pdfDX[100],pdfDY[100],pdfPara[100],pdfH0[3],pdfH1[3];////Dxi,Dyi 的改正数
// double *pdfcc,*pdflc,*pdfaa,dfP,pdfVx[3],pdfVy[3],maxpp,pp,pdfXX[3],pdfYY[3];
// double gy,dij,xi,yi,xj,yj,maxd,thta,h0,h1,sint,cost,xx,yy,d,xx0,yy0,maxLastd;
// unsigned char *pucStrLineTemp,*pucStrLine,ucG,pucStrLineTempNew[100];
//
//
// nInPtC = 2;
// for(i=0;i<2;i++)
// { pdfD[2*i] = 0.0;
// pdfD[2*i+1] = 0.0;
// pdfPara[2*i] = pdfptIn[i].dfX;
// pdfPara[2*i+1] = pdfptIn[i].dfY;
// }
// No[1] = 0; No[2] =1;
// d=((pdfPara[2*(No[1])]-pdfPara[2*(No[2])])*(pdfPara[2*(No[1])]-pdfPara[2*(No[2])]));
// d+=((pdfPara[2*(No[1])+1]-pdfPara[2*(No[2])+1])*(pdfPara[2*(No[1])+1]-pdfPara[2*(No[2])+1]));
// d = sqrt(d);
// if(d=nRow) rr = nRow-1;
// if(cc<0) cc =0;
// if(cc>=nCol) cc = nCol-1;
// *(pucStrLine+(nRange+r)*nTempW+m)=*(pucImg+rr*nCol+cc);
// }
// }
// //// 找相关最大值
// for(r=0;rfabs(maxpp))
// { maxpp = pp;
// maxPr = r;
// }
// }
// //// 计算新模板(计算模板系数h0,h1)
// ReturnH0H1(pucStrLine+maxPr*nTempW,pucStrLineTemp,nTempH*nTempW,pdfH0,pdfH1);
//
// ReGenerateTemp(pucStrLineTempNew,pucStrLineTemp,nTempH*nTempW,*pdfH0,*pdfH1);
//
// for(r=-3;r<=3;r++)
// { for(m=0;m10) ////如果改正数的最大值小于限差,迭代终止
// break;
// dwTimes++;
// }
// ///// 结果输出
// for(i=0;i=nCol||(r0+r)<0||r0+r>=nRow)
// *(pucI+r*DET_SCALE+c) = 0;
// else
// *(pucI+r*DET_SCALE+c) = *(pucImg+(r0+r)*nCol+c0+c);
// }
// }
// ///// edge detection
// EdgeDetByVision(pucI,DET_SCALE,DET_SCALE,0.1,30,30);
//
// HilditchThin2(pucI,DET_SCALE,DET_SCALE);
//
// SimpleThin2(pucI,DET_SCALE,DET_SCALE);
//
// ///// select the "best" output point
// double v,d,mind=100000.0;
// int er,ec,C=0;
// for(r=0;r DET_SCALE ||mind > SNAP_RANGE)
// {
// er=ec= DET_SCALE/2;
// }
// ///// repostion the point(sub-pixel accuracy)
//
// ///// output point
// pdfptOut[1].dfY = er+r0;
// pdfptOut[1].dfX = ec+c0;
//
// delete pucI;
//
// return 1;
//}
double DisPtToLine(double dfX,double dfY,
double dfPt1X,double dfPt1Y,
double dfPt2X,double dfPt2Y)
{
float dmax;
float a,b,c,D,d;
float x1,x2,y1,y2,work;
x1 = dfPt1X;x2 = dfPt2X;y1 = dfPt1Y;y2 = dfPt2Y;
if(x1 == x2)
{
b = 0;
a = 1;
c = -x1;
}
else
{
b = -1.0;
a = (y1 - y2) / (x1 - x2);
c = y1 - a * x1;
}
work = (float)sqrt(a * a + b* b);
d = (float)(abs(a * dfX + b * dfY + c)
/ work);
return (double)d;
}
/*
*/
//double Coorelation(unsigned char *pucImgBlkData,
// unsigned char *pucTemp1D,
// unsigned long dwDataSize)
//{ int i;
// unsigned long sl,sr,sl2,sr2,slr;
// double bb,p;
// unsigned char *pucP,*pucPT;
//
// sl=sr=0L;
// sl2=sr2=slr=0L;
// pucP=pucImgBlkData;
// pucPT = pucTemp1D;
// for(i=0;i<(int)dwDataSize;i++)
// { sl += *pucImgBlkData;
// sl2 += (DWORD) *pucImgBlkData * *pucImgBlkData;
// // if((*pucTemplateData)!=0)
// { sr+=*pucTemp1D;
// sr2+=(DWORD) *pucTemp1D* *pucTemp1D;
// slr+=(DWORD) *pucTemp1D* *pucImgBlkData;
// }
// pucImgBlkData++; pucTemp1D++;
// }
// pucImgBlkData = pucP;
// pucTemp1D=pucPT;
// p=slr-(double)sl*sr/dwDataSize;
// bb=(sl2-(double)sl*sl/dwDataSize)*(sr2-(double)sr*sr/dwDataSize);
// if(bb<=0)
// return 0;
// bb=sqrt(bb);
// p/=bb;
//
// return p;
//}
//
//BOOL ReturnH0H1(unsigned char *pucImgBlkData,
// unsigned char *pucTemp1D,
// unsigned long dwDataSize,
// double *pdfH0,double *pdfH1)
//{ int i;
// unsigned long sl,sr,sl2,sr2,slr;
// double bb,p;
// unsigned char *pucP,*pucPT;
//
// sl=sr=0L;/// l :image; r: template
// sl2=sr2=slr=0L;
// pucP=pucImgBlkData;
// pucPT = pucTemp1D;
// for(i=0;i<(int)dwDataSize;i++)
// { sl += *pucImgBlkData;
// sl2 += (DWORD) *pucImgBlkData * *pucImgBlkData;
// // if((*pucTemplateData)!=0)
// { sr+=*pucTemp1D;
// sr2+=(DWORD) *pucTemp1D* *pucTemp1D;
// slr+=(DWORD) *pucTemp1D* *pucImgBlkData;
// }
// pucImgBlkData++; pucTemp1D++;
// }
// *pdfH0 = ((double)slr*sr-sr2*sl)/((double)sr*sr-dwDataSize*sr2);
// *pdfH1 = ((double)sl*sr-dwDataSize*slr)/((double)sr*sr-dwDataSize*sr2);
//
// return TRUE;
//}
//
//double RetSigmaof2ImgBlk(unsigned char *pucImgBlkData,
// unsigned char *pucTemp1D,
// unsigned long dwDataSize)
//{ int i;
// unsigned long sl,sr,sl2,sr2,slr;
// double bb,p;
// unsigned char *pucP,*pucPT;
//
// sl=sr=0L;/// l :image; r: template
// pucP=pucImgBlkData;
// pucPT = pucTemp1D;
// for(i=0;i<(int)dwDataSize;i++)
// { sl = sl+((int)(*pucP) - (int)(*pucPT)) * ((int)(*pucP) - (int)(*pucPT));
// pucP++; pucPT++;
// }
// p = (double)sl;
// p/=dwDataSize;
// p = sqrt(p);
// return p;
//}
//
//BOOL ReGenerateTemp(unsigned char *pucNewTemp,
// unsigned char *pucTemp1D,
// unsigned long dwDataSize,
// double dfH0,double dfH1)
//{ int n;
//
// for(n=0;ndwImgCol) continue;
// dwRowBia=(DWORD)wIy+wD1;
// for(wD2=0;wD2dwImgRow) continue;
// wSum+=
// *(pucImgData+dwRowBia*dwColLen+dwColBia+wD2);
// }
// }
// *pucCmprs=(BYTE)(wSum/wAvSize);
// pucCmprs++;
// }
// }
// return (dwImgRow/wK)*(dwImgCol/wK);
//}
//
//
//BOOL RidgeDetBy1OrderZeroCrossing(unsigned char *pucImg,int nRow,int nCol,float fA,
// float fK1,float fK2)
//{ int t,r,c,rr,cc,i,nGx,nGy,n,I1,I2,J1,J2,nSumGray;
// float fW,fWSum,fSum,fDir,fDirO,fDirD,
// pfGrad[10],pfDir[10],pfDirD[10],
// fG1,fG2,v,mv,G,pfGradTh[256];
// unsigned char *pucI,*pucI2,pucGradTh[256];
//
// pucI = (unsigned char *)malloc(nRow*nCol*sizeof(unsigned char));
// pucI2 = (unsigned char *)malloc(nRow*nCol*sizeof(unsigned char));
//
// if(!pucI||!pucI2)
// return FALSE;
//
//// MedianFilter(pucImg,nRow,nCol,3);
//
// memcpy(pucI2,pucImg,nCol*nRow*sizeof(char));
//
// for(i=0;i<256;i++)
// {/* if(i==0)
// { pucGradTh[i] = 100;
// pfGradTh[i] = 100;
// }
// else
// */
// { pucGradTh[i] =(unsigned char)(int)
// (0.1*((exp(1.0/i)*fK1 + exp(1.0/(256-i))*fK2)));
// }
// }
//
// for(r=1;rfabs((double)nGy)?fabs((double)nGx):fabs((double)nGy);
//
// *(pucI+r*nCol+c) = (unsigned char)(int)G;
// }
// }
// int V0,V1,V;
// for(r=2;r0 )
// {
// ///输出边缘点
// if((*(pucI2+r*nCol+c)!=0) )//&& (pfGrad[4]<5))
// {
// *(pucI2+r*nCol+c) = *(pucI+r*nCol+c);
// *(pucI2+(r+I1)*nCol+c+J1) = *(pucI2+(r+I2)*nCol+c+J2)= 0;
// }
// else
// *(pucI2+r*nCol+c) = 0;
// }
// else
// *(pucI2+r*nCol+c) = 0;
// }
// }
// for(r=0;rnRow?nCol:nRow;
// pfSigLine = new float[LC];
//
// //// Row Direction detction
// for(r=nTemplateWid/2;rdfDist = sqrt((strLine->nptSt.dfX - strLine->nptEnd.dfX)*
(strLine->nptSt.dfX - strLine->nptEnd.dfX) +
(strLine->nptSt.dfY - strLine->nptEnd.dfY)*
(strLine->nptSt.dfY - strLine->nptEnd.dfY));
strLine->fRo = DisPtToLine(0.0,0.0,strLine->nptSt.dfX,strLine->nptSt.dfY,
strLine->nptEnd.dfX,strLine->nptEnd.dfY); //// Ro - Thta representation
strLine->dfThta = fabs(strLine->nptSt.dfX - strLine->nptEnd.dfX) < 1.0? PI/2.0 :
atan((strLine->nptSt.dfY - strLine->nptEnd.dfY)/(strLine->nptSt.dfX - strLine->nptEnd.dfX));
/// TRACE("thta = %f\n",(float)(strLine->dfThta));
strLine->dfThta = 180.0*(strLine->dfThta/PI); //// degree unit for angle !!!!
}
/*
*/
//int Semiauto_Corner_Fast_Hough(unsigned char *pucImg,int nRow,int nCol,
// dfPOINT dfptInput,int dfDetRange,
// CornerPt *pCornerPt,int nW)
//{
// int i,j,X0,Y0,m,n,nCandC;
// double x,y,gg,t1,t2,t3,dx,dy;
// BYTE *pImgW;
// dfPOINT *pptCands;
//
// X0 = (int)dfptInput.dfX-dfDetRange/2;
// Y0 = (int)dfptInput.dfY-dfDetRange/2;
//// X0=Y0=0;
// pImgW = new BYTE[dfDetRange*dfDetRange];
// pptCands = new dfPOINT[dfDetRange*dfDetRange];
//
// t1 = 30; ///////
// t2 = 25; /////// 25
// t3 = 18.0; ///// 18
//
// /////get search image window
// for(i=0;i<(int)dfDetRange;i++)
// for(j=0;j<(int)dfDetRange;j++)
// {
// if((int)(Y0+i)<0 ||(int)(Y0+i)>=nRow ||(int)(X0+j)<0 ||(int)(X0+j)>=nCol )
// *(pImgW + i*dfDetRange + j) = 128;
// else
// *(pImgW + i*dfDetRange + j) = *(pucImg+(int)(Y0+i)*nCol+(int)(X0+j));
// }
//
// SelfadpSmoothing2(pImgW,dfDetRange,dfDetRange,5,3); ///// 5,3
//
// BYTE *pScore;
// pScore = new BYTE[dfDetRange*dfDetRange];
// for(m=0;m 100)
// t1 = 70;
// else
// t1 = 35;
// if(gg < 30 ) //// t1
// continue;
//
// t2 = 50;
// x = (double)(-nW/2+n);
// y = (double)(-nW/2+m);
// t = atan2(y,x);
// t = 180.0*t/PI;
// t = t<0 ? 360+t : t;
// tt = t+90>=360?t+90-360:t+90;
// tt = tt>=180?tt-180:tt;
// gt = atan2(dy,dx);
// gt = 180.0*gt/PI;
// gt = gt<0?180+gt:gt;
// gt = gt>=180?gt-180:gt;
// if(fabs(tt-gt)>=t3)
// continue;
//
// pfThta[(int)(0.5 + t/thtaIntv)] = pfThta[(int)(0.5 + t/thtaIntv)] + 1.0;
// }
// }
// nC =0;
// for(m=0;m=2) //// 2
// {
// N[nC] = m;
// nC++;
// }
// }
// dt = (N[1]-N[0])*thtaIntv >=180.0 ? 360 - (N[1]-N[0])*thtaIntv : (N[1]-N[0])*thtaIntv;
// if((nC==2 && dt<=120 && dt>=60))
// {
// {
//
// score = 0.3 * (1.0 - t1/g0) + 0.3 * (pfThta[N[0]] + pfThta[N[1]])/(float)nW
// + 0.4 * (1.0 - fabs(dt-90.0)/90.0);
// score = score>=1.0?1.0:score;
//
// if(score*255.0 > 80 )//// && dg >0
// {
// *(pScore + i*dfDetRange + j) = (BYTE)(int)(score*255.0 - 0.4 *dg);
// pptCands[nCandC].dfX = (double)(j+X0)+0.5;
// pptCands[nCandC].dfY = (double)(i+Y0)+0.5;
// nCandC++;
// }
// }
// }
// }
// }
// delete pImgW;
// delete pScore;
// double dis,min_dis;
// if(nCandC>0)
// {
// for(m=0;m160&&rr!=0&&cc!=0)
// // fW = 0.0;
// fWSum+=fW;
// fSum+=((int)(*(pucImg+(r+rr)*nCol+c+cc))*fW);
// }
// }
// *(pucI+r*nCol+c) = (char)(int)(fSum/fWSum);
// }
// }
// memcpy(pucImg,pucI,nCol*nRow*sizeof(char));
// }
//
// free(pucI);
// return TRUE;
//}