www.pudn.com > roadextr.rar > WMlib.cpp
#include "stdafx.h"
#include "valdef.h"
#include
#include
#include
#include
#include "WMlib.h"
#include "imgp2.h"
#include "imgp.h"
#include "bline.h"
#include "strline.h"
//#include "FFT0.h"
#include "canny.h"
/* ////////////////////////////////////////////////////////////
get a N*N iamge window from RR Row (block row No) and
CC Col (block col No.) of a large image
///////////////////////////////////////////////////////////////
*/
//void GetImgWinNN(BYTE *pucI,int nRow,int nCol,
// BYTE *pucD,int N,int RR,int CC)
//{
// int m,n;
// for(m=0;m=nRow||
// CC*N+n<0 || CC*N+n >=nCol)
// *(pucD+ m*N+n) = 128;
// else
// *(pucD+ m*N+n) = *(pucI+(RR*N+m)*nCol+CC*N+n);
// }
// }
//}
///* ////////////////////////////////////////////////////////
// put a N*N image window to RR Row (block row No) and
// CC Col (block col No.) of a large image
/////////////////////////////////////////////////////////////
//*/
//void PutImgWinNN(BYTE *pucI,int nRow,int nCol,
// BYTE *pucD,int N,int RR,int CC)
//{
// int m,n;
// for(m=0;m=nRow||
// CC*N+n<0 || CC*N+n >=nCol)
// continue;
// *(pucI+(RR*N+m)*nCol+CC*N+n) = *(pucD+ m*N+n);
// }
// }
//}
//
//void GetImgWinNN_2(BYTE *pucI,int nRow,int nCol,
// BYTE *pucD,int N,int RR,int CC)
//{
// int m,n;
// for(m=0;m=nRow||
// CC+n<0 || CC+n >=nCol)
// *(pucD+ m*N+n) = 128;
// else
// *(pucD+ m*N+n) = *(pucI+(RR+m)*nCol+CC+n);
// }
// }
//}
///* ////////////////////////////////////////////////////////
// put a N*N image window to RR start row and
// CC Col start column of a large image
/////////////////////////////////////////////////////////////
//*/
//void PutImgWinNN_2(BYTE *pucI,int nRow,int nCol,
// BYTE *pucD,int N,int RR,int CC)
//{
// int m,n;
// for(m=0;m=nRow||
// CC+n<0 || CC+n >=nCol)
// continue;
// *(pucI+(RR+m)*nCol+CC+n) = *(pucD+ m*N+n);
// }
// }
//}
//
///* ////////////////////////////////////////
// DCT : Directly using the equation
//input:
// pucI, nN -----
//output:
// pfDCT -----
// Date: 24-Feb 2002
/////////////////////////////////////////////
//*/
//void DCT(BYTE *pucI,float *pfDCT,int nN)
//{
// int u,v,x,y;
// float sum,fu,fv,*pfu,*pfv,s;
// pfu = new float[nN];
// pfv = new float[nN];
//
// for(u=0;u=nKeySize) ? r%nKeySize : r;
// bytK = *(pbytKey+k);
// bytR = bytD ^ bytK;
//
// if(bytR > bytDataSize-1)
// bytR = bytR % bytDataSize;
// *(pbytOutput+r) = bytR;
// ////// judge is there repeated R
// bRep = false;
// for(m=0;m0 && ((int)bytR - *(pbytOutput+r-1) < 55 &&
// (int)bytR-*(pbytOutput+r-1) > -55) )
// bRep = true;
// }
// if(!bRep)
// break;
// }
// if(bRep)
// *(pbytOutput+r) = BYTE(r);
// }
// for(r=0;r 255 || nCol > 255 )
// return false;
//
// BYTE pbytRow[256],pbytCol[256],*pbytKey2;
// int r,c,rr,cc;
//
// pbytKey2 = new BYTE[nKeySize];
// PRSGenAlgo_0((BYTE)nRow,pbytKey,nKeySize,pbytRow); ///// random generating row
//
// for(r=0;r pfDCT[5+(2*n+1)] ) ||
// (pucBits[n]==1 && pfDCT[5+(2*n)] < pfDCT[5+(2*n+1)] ) ) ///// exchange 1, 2 coeff of FFT
// {
// vv = pfDCT[5+(2*n+1)];
// pfDCT[5+(2*n+1)] = pfDCT[5+(2*n)];
// pfDCT[5+(2*n)] = vv;
// }
//*/
///* if( pucBits[n]==0 && *(pI+n*INFO_EMBD_UNIT) > *(pI+n*INFO_EMBD_UNIT+1) ||
// pucBits[n]==1 && *(pI+n*INFO_EMBD_UNIT) < *(pI+n*INFO_EMBD_UNIT+1))
// {
// vb = *(pI+n*INFO_EMBD_UNIT+1);
// *(pI+n*INFO_EMBD_UNIT+1) = *(pI+n*INFO_EMBD_UNIT);
// *(pI+n*INFO_EMBD_UNIT) = vb;
// }
//*/
///*
// Gray1D_DCT(pI+n*8,8,pfDCT); ///////// do DCT
// for(i=0;i<8;i++) ///// Quantilization
// pnDCT_Q[i] = (int)(pfDCT[i] / nQt[i]);
// for(i=0;i<4;i++)
// {
// switch (pucBits[n*4+i])
// {
// case 0:
// pnDCT_Q[i+1] = pfDCT[i+1]* nQt[i+1];
// break;
// case 1:
// pfDCT[i+1] = pfDCT[i+1] * nQt[i+1] + nQt[i+1]/2;
// break;
// }
// }
// for(i=5;i<8;i++) ///// Quantilization
// pnDCT_Q[i] = (int)(pfDCT[i] * nQt[i]);
//*/
// Gray1D_DCT(pI+n*INFO_EMBD_UNIT,INFO_EMBD_UNIT,pfDCT); ///////// do DCT
// pfDCT[1]/=4; pfDCT[2]/=4;
// if( (pucBits[n]==0 && pfDCT[1] > pfDCT[2] ) ||
// (pucBits[n]==1 && pfDCT[1] < pfDCT[2] ) ) ///// exchange 1, 2 coeff of FFT
// {
// vv = pfDCT[2];
// pfDCT[2] = pfDCT[1];
// pfDCT[1] = vv;
// }
// if(pfDCT[1] >= pfDCT[2] && pfDCT[1] - pfDCT[2] < 4)
// { pfDCT[1]+=2.0; pfDCT[2]-=2.0;
// }
// if(pfDCT[1] <= pfDCT[2] && pfDCT[2] - pfDCT[1] < 4)
// { pfDCT[2]+=2.0; pfDCT[1]-=2.0;
// }
// pfDCT[1]*=4; pfDCT[2]*=4;
//
///*
// for(i=0;i<8;i++) ///// Quantilization!!!!
// pnDCT_Q[i] = (int)(pfDCT[i]) / nQt[i];
//
// ////// embedding 1 Bit
// u = pnDCT_Q[1] + 255;
// if(pucLUT[u] != pucBits[n])
// pnDCT_Q[1]+=3;
//
// for(i=0;i<8;i++) ///// Anti - Quantilization!!!!
// pfDCT[i] = pnDCT_Q[i] * nQt[i];
//*/
// Reverse_1D_DCT_Gray(pI+n*INFO_EMBD_UNIT,INFO_EMBD_UNIT,pfDCT); ////// inverse DCT
//
// }
//// Reverse_1D_DCT_Gray(pI,INFO_EMBD_UNIT*nBitsC,pfDCT); ////// inverse DCT
//}
///* //////////////////////////////
//
///////////////////////////////////////
//*/
//void ExtractBit_1D_FT(BYTE *pucBits,int nBitsC,
// float *pfR,float *pfI,BYTE *pI)
//{
// int n,i,pnDCT_Q[8],u,uu;
// float pfFT_M[8],pfDCT[512];
// static int nQt[] = {1,6,6,6,6,1,1,1};
// BYTE pucLUT[512]; ///// look-up-table
//
// ///////// Genertae The Look-Up-Table
// for(i=0;i<512;i++)
// pucLUT[i] = i%2==0?0:1;
//
//// Gray1D_DCT(pI,nBitsC*INFO_EMBD_UNIT,pfDCT); ///////// do DCT
// for(n=0;nmaxp)
// maxp = p;
// }
// TRACE("bc = %d, p = %f\n",nBitsSelC,maxp);
///*
// for(nn=0;nndfMaxCoeff)
// {
// dfMaxCoeff = pp;
// for(nn=0;nn10 && nnn< 32 && maxp < 0.9)||
// (nnn>=32 && nnn < 64 && maxp < 0.8 )||
// (nnn>=64 && nnn < 128 && maxp < 0.7 )||
// (nnn>=128 && nnn< 256 && maxp < 0.55 ))
// maxp = 0.0;
// if(nnn<=10)
// return 0;
// return maxp;
///*
// ////// reverse detect the WM
// for(mm=lsSeg.nPtC-1;mm>=nBitsC*INFO_EMBD_UNIT;mm--)
// {
// for(m=0;mdfMaxCoeff)
// {
// dfMaxCoeff = pp;
// for(nn=0;nn2*G)
// if(*(pucI+nY*nCol+nX) & 1 == 1)
// return 1;
// else
// return 0;
//}
//
///* //////////////////////////////////////////////////////////////////////////////////////
// Extract bits and return Max correlation between Wateramrk bits and detected bits
// pucOrI,nRow,nCol ----- original image
// pucBinI -------------- binary image containing single-pixel-width lines
// pucWMBits ---- Known water mark bits
//output:
// pucDetBits,nBitsC ----- Detected bits (hold a MAX correlation with origianl watermark signal)
//return:
// max correlation coefficient
//Date: 28-Feb 2002
////////////////////////////////////////////////////////////////////////////////////////////
//*/
//double ExtrBitsInLines_SpDomain(BYTE *pucOrI,int nRow,int nCol,
// BYTE *pucBinI,BYTE *pucWMBits,
// BYTE *pucDetBits,int nBitsC)
//{
// int r,c,rr,cc,k,kk,m,n,nEndFg,
// nEnd2Fg,nFg2,nC,nCurveC,x0,y0,mm,nn,MaxLen;
// unsigned char *pucI,*pucI2,pucN8[8];
// LineSeg lsSeg;
// nPOINT ppntNPix[8];
// double dfMaxCoeff,pp;
// BYTE *pucBits,*pucBitsWMLen;
// MaxLen = 0;
//
// pucBitsWMLen = new BYTE[nBitsC];
// dfMaxCoeff = -100.0;
// lsSeg.pnptPxy = (nPOINT *)malloc(MAX_CURVE_POINT_COUNT*sizeof(nPOINT)); //// 10000 points
//
// lsSeg.nPtC=0;
// n=0;
// nCurveC = 0;
// for(r=1;r=nRow-1||cc<1||cc>=nCol-1)
// break;
// if(n>=MAX_CURVE_POINT_COUNT)
// break;
// pucN8[7]=*(pucBinI+(rr-1)*nCol+cc+1); pucN8[6]=*(pucBinI+(rr-1)*nCol+cc);
// pucN8[5]=*(pucBinI+(rr-1)*nCol+cc-1); pucN8[4]=*(pucBinI+rr*nCol+cc-1);
// pucN8[3]=*(pucBinI+(rr+1)*nCol+cc-1); pucN8[2]=*(pucBinI+(rr+1)*nCol+cc);
// pucN8[1]=*(pucBinI+(rr+1)*nCol+cc+1); pucN8[0]=*(pucBinI+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)/// if it's recorded point
// continue;
//
// if(pucN8[k]!=255)//// record one point (i,j)
// { 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(nFg2==0)////(is the end point!)
// { if(lsSeg.nPtC > MaxLen)
// MaxLen = lsSeg.nPtC;
// for(m=0;m= nBitsC*INFO_EMBD_UNIT)
// { ////// Extract Bits From A Curve Line
//
// pp = ExtractBitsFromACurveLine(pucOrI,nRow,nCol,lsSeg,pucBitsWMLen,
// pucDetBits,pucWMBits,nBitsC,dfMaxCoeff);
//
// if(pp>dfMaxCoeff) dfMaxCoeff = pp;
// }
// //////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// nCurveC++;
// nEndFg=1;
// }
// else if(nFg2==1)///else there is another neibor point!
// { rr=lsSeg.pnptPxy[n-1].nY;//// get next judge point
// cc=lsSeg.pnptPxy[n-1].nX;
// }
// if(nEndFg==1)
// break;
// }
// }
// }
//
// ///// then follow the closed lined (cycled line)
// lsSeg.nPtC=0;
// n=0;
// for(r=1;r=nRow-1||cc<1||cc>=nCol-1)
// break;
// if(n>=MAX_CURVE_POINT_COUNT)
// break;
// pucN8[7]=*(pucBinI+(rr-1)*nCol+cc+1); pucN8[6]=*(pucBinI+(rr-1)*nCol+cc);
// pucN8[5]=*(pucBinI+(rr-1)*nCol+cc-1); pucN8[4]=*(pucBinI+rr*nCol+cc-1);
// pucN8[3]=*(pucBinI+(rr+1)*nCol+cc-1); pucN8[2]=*(pucBinI+(rr+1)*nCol+cc);
// pucN8[1]=*(pucBinI+(rr+1)*nCol+cc+1); pucN8[0]=*(pucBinI+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)/// if it's recorded point
// continue;
//
// if(pucN8[k]!=255)////record a point
// { 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(nFg2==0||(lsSeg.pnptPxy[n-1].nX==x0&&
// lsSeg.pnptPxy[n-1].nY==y0))////(is the end point!)||back to start point
// { /////////////// Extract Bits From A Curve Line
// if(lsSeg.nPtC > MaxLen)
// MaxLen = lsSeg.nPtC;
// pp = ExtractBitsFromACurveLine(pucOrI,nRow,nCol,lsSeg,pucBitsWMLen,
// pucDetBits,pucWMBits,nBitsC,dfMaxCoeff);
// if(pp>dfMaxCoeff) dfMaxCoeff = pp;
// ////// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// nCurveC++;
// nEndFg=1;
// }
// else if(nFg2==1)///else there is another neibor point!
// { rr=lsSeg.pnptPxy[n-1].nY;//// get next judge point
// cc=lsSeg.pnptPxy[n-1].nX;
// }
// if(nEndFg==1)
// break;
// }
// }
// }
// free(lsSeg.pnptPxy);
//
// TRACE("Max Len = %d\n",MaxLen);
// TRACE("nCurveC = %d\n",nCurveC);
//
// return dfMaxCoeff;
//}
//
///* 1D discreate Fourier Tranformation(magnitude)
//
//*/
//void Gray1D_DFT(BYTE *pI,int nDataL,float *pfR,float *pfI)
//{
// double sum;
// float u,x,r,i,*pfRi,*pfIi;
// pfRi = new float[nDataL];
// pfIi = new float[nDataL];
// for(int n=0;n pfFT_M[2] ) ||
// (pucBits[n]==1 && pfFT_M[1] < pfFT_M[2] ) ) ///// exchange 1, 2 coeff of FFT
// { vv = pfFT_M[2];
// pfFT_M[2] = pfFT_M[1];
// pfFT_M[1] = vv;
// }
// if(pucBits[n]==0)
// { vv = pfFT_M[2];
// pfFT_M[2] = pfFT_M[1];
// pfFT_M[1] = vv;
// }
//*/
//
///*
// if(fabs(pfFT_M[1] - pfFT_M[2])<15.0) ///// if the two coeffs is very close
// {
// if(pucBits[n]==0)
// pfFT_M[1] = pfFT_M[2];
// // pfFT_M[2] = pfFT_M[1] + 15.0;
// else
// pfFT_M[1] = pfFT_M[2] + 25.0;
// }
//*/
//
// /*
// int mm,m,nn,x0,y0,x1,y1;
// double pp;
// BYTE *pucBits;
// pucBits = new BYTE[lsSeg.nPtC];
//
// for(mm=0;mmdfMaxCoeff)
// {
// dfMaxCoeff = pp;
// for(nn=0;nnnBitsC;mm--)
// {
// for(nn=0;nndfMaxCoeff)
// {
// dfMaxCoeff = pp;
// for(nn=0;nn