watermethod.cpp

站长！这是DCT域的图像数字水印嵌入及提取程序！请查收！暂归入加密解密类别！

	   blockfreq[l]=blkfreq[l];
	   embedimageblocktime[l]=embedimageblktime[l];
	   embedimageblockfreq[l]=embedimageblkfreq[l];
   }
   for(l=0;l<2;l++)
   	   extwmblocktime[l]=extwmblktime[l];
	int temp1,temp2;
	for(m=0; m<64*64; m++)
	{
		temp1=*(imageblockvarseqkey+m);
		temp2=*(wmblockmarknumseqkey+m);
		//Initialize one sub block of the original image in time domain
		for(l=0;l<blockheight;l++)
		{
			for(k=0;k<blockwidth;k++)
			{
				blktime[k][l]=SourceVector[temp1][k+l*blockwidth];
			}
		}
		//DCT is use for the original image sub block
		DCT(blocktime,blockfreq,blockwidth,blockheight);
		//Initialize one sub block of the watermareked image in time domain
		for(l=0;l<blockheight;l++)
		{
			for(k=0;k<blockwidth;k++)	
			{
				embedimageblktime[k][l]=TerminalVector[temp1][k+l*blockwidth];
			}
		}
		//DCT is use for the watermarked image sub block
		DCT(embedimageblocktime,embedimageblockfreq,blockwidth,blockheight);
		//Extract watermark from a suspicious image
		extractwatermark(blockfreq,embedimageblockfreq,extwmblocktime);
		//Transmit the the extracted watermark data to memory
		for(l=0; l<2;l++)
		{
			for(k=0; k<2; k++)
			{
				pp01[temp2][k+l*2]=extwmblocktime[k][l];
			}
		}
	}
		GlobalFree(hMem);
    return 0;
}

void ZigZagD(double *input[],double *output,int height,long int number)
{
	int N,i,sum,j;
	j=0;
	N=8;
	for(sum=0;sum<=N-1;sum++)
	{
		if(sum%2!=0)
			for(i=sum;i>=0;i--)
			{
				output[j]=input[i][sum-i];
                j++;
			}
			else
			for(i=0;i<=sum;i++)
			{
				output[j]=input[i][sum-i];
                j++;
			}
	}
	for(sum=N;sum<=2*N-1;sum++)
	{
		if(sum%2!=0)
			for(i=N-1;i>=sum-(N-1);i--)
			{
				output[j]=input[i][sum-i];
			    j++;
			}
		else
			for(i=sum-(N-1);i<=N-1;i++)
			{
				output[j]=input[i][sum-i];
                j++;
	
			}

	}
}
void ReZigZagD(double *output[],double *input,int height,long int number)
{
	int N,i,sum,j;
	j=0;
	N=8;
	for(sum=0;sum<=N-1;sum++)
	{
		if(sum%2!=0)
			for(i=sum;i>=0;i--)
			{
				output[i][sum-i]=input[j];
				j++;
			}
		else
			for(i=0;i<=sum;i++)
			{
				output[i][sum-i]=input[j];
				j++;
			}
	}
	for(sum=N;sum<=2*N-1;sum++)
	{
		if(sum%2!=0)
			for(i=N-1;i>=sum-(N-1);i--)
			{
				output[i][sum-i]=input[j];
				j++;
			}
		else
			for(i=sum-(N-1);i<=N-1;i++)
			{
				output[i][sum-i]=input[j];
				j++;
			}
	}
}
void ZigZagC(unsigned char *input[],unsigned char *output,int height,long int number)
{
	int N,i,sum,j;
	j=0;
	N=8;
	for(sum=0;sum<=N-1;sum++)
	{
		if(sum%2!=0)
			for(i=sum;i>=0;i--)
			{
				output[j]=input[i][sum-i];
                j++;
			}
			else
			for(i=0;i<=sum;i++)
			{
				output[j]=input[i][sum-i];
                j++;
			}
	}
	for(sum=N;sum<=2*N-1;sum++)
	{
		if(sum%2!=0)
			for(i=N-1;i>=sum-(N-1);i--)
			{
				output[j]=input[i][sum-i];
			    j++;
			}
		else
			for(i=sum-(N-1);i<=N-1;i++)
			{
				output[j]=input[i][sum-i];
                j++;
	
			}

	}
}   						   
void samplingembed(double *input1[],double *input2[],double *input3[],double *input4[],unsigned char *input[],double *output1[],
			  double *output2[],double *output3[],double *output4[],int w,int h)
{
	int l,k;
	double mean;
	double alpha;
	alpha=0.1;
    for(l=0;l<8;l++)
	{	
		for(k=0;k<8;k++)
		{
			output1[l][k]=input1[l][k];
			output2[l][k]=input2[l][k];
		}
	}
    mean=(input1[2][1]+input2[2][1])/2;
   if (fabs((input1[2][1]-input2[2][1])/mean)<6*alpha)
    output1[2][1]=mean*(1+alpha*input[0][0]);
    output2[2][1]=mean*(1-alpha*input[0][0]);
	mean=(input1[3][0]+input2[3][0])/2;
   if (fabs((input1[3][0]-input2[3][0])/mean)<6*alpha)
	output1[3][0]=mean*(1+alpha*input[0][1]);
	output2[3][0]=mean*(1-alpha*input[0][1]);
	mean=(input1[4][0]+input2[4][0])/2;
   if (fabs((input1[4][0]-input2[4][0])/mean)<6*alpha)
	output1[4][0]=mean*(1+alpha*input[1][0]);
	output2[4][0]=mean*(1-alpha*input[1][0]);
	mean=(input1[3][1]+input2[3][1])/2;
   if (fabs((input1[3][1]-input2[3][1])/mean)<6*alpha)
	output1[3][1]=mean*(1+alpha*input[2][0]);
	output2[3][1]=mean*(1-alpha*input[2][0]);
	mean=(input1[2][2]+input2[2][2])/2;
   if (fabs((input1[2][2]-input2[2][2])/mean)<6*alpha)
	output1[2][2]=mean*(1+alpha*input[1][1]);
	output2[2][2]=mean*(1-alpha*input[1][1]);
	mean=(input1[1][3]+input2[1][3])/2;
   if (fabs((input1[1][3]-input2[1][3])/mean)<6*alpha)
	output1[1][3]=mean*(1+alpha*input[0][2]);
	output2[1][3]=mean*(1-alpha*input[0][2]);
	mean=(input1[0][4]+input2[0][4])/2;
   if (fabs((input1[0][4]-input2[0][4])/mean)<6*alpha)
	output1[0][4]=mean*(1+alpha*input[0][3]);
	output2[0][4]=mean*(1-alpha*input[0][3]);
	mean=(input1[0][5]+input2[0][5])/2;
   if (fabs((input1[0][5]-input2[0][5])/mean)<6*alpha)
	output1[0][5]=mean*(1+alpha*input[1][2]);
	output2[0][5]=mean*(1-alpha*input[1][2]);
	mean=(input1[1][4]+input2[1][4])/2;
   if (fabs((input1[1][4]-input2[1][4])/mean)<6*alpha)
	output1[1][4]=mean*(1+alpha*input[2][1]);
	output2[1][4]=mean*(1-alpha*input[2][1]);
	mean=(input1[2][3]+input2[2][3])/2;
   if (fabs((input1[2][3]-input2[2][3])/mean)<6*alpha)
	output1[2][3]=mean*(1+alpha*input[3][0]);
	output2[2][3]=mean*(1-alpha*input[3][0]);
	mean=(input1[3][2]+input2[3][2])/2;
   if (fabs((input1[3][2]-input2[3][2])/mean)<6*alpha)
	output1[3][2]=mean*(1+alpha*input[3][1]);
	output2[3][2]=mean*(1-alpha*input[3][1]);
	mean=(input1[4][1]+input2[4][1])/2;
   if (fabs((input1[4][1]-input2[4][1])/mean)<6*alpha)
	output1[4][1]=mean*(1+alpha*input[2][2]);
	output2[4][1]=mean*(1-alpha*input[2][2]);
	mean=(input1[5][0]+input2[5][0])/2;
   if (fabs((input1[5][0]-input2[5][0])/mean)<6*alpha)
	output1[5][0]=mean*(1+alpha*input[1][3]);
	output2[5][0]=mean*(1-alpha*input[1][3]);
	mean=(input1[6][0]+input2[6][0])/2;
   if (fabs((input1[6][0]-input2[6][0])/mean)<6*alpha)
	output1[6][0]=mean*(1+alpha*input[2][3]);
	output2[6][0]=mean*(1-alpha*input[2][3]);
	mean=(input1[5][1]+input2[5][1])/2;
   if (fabs((input1[5][1]-input2[5][1])/mean)<6*alpha)
	output1[5][1]=mean*(1+alpha*input[3][2]);
	output2[5][1]=mean*(1-alpha*input[3][2]);
	mean=(input1[4][2]+input2[4][2])/2;
   if (fabs((input1[4][2]-input2[4][2])/mean)<6*alpha)
	output1[4][2]=mean*(1+alpha*input[3][3]);
	output2[4][2]=mean*(1-alpha*input[3][3]);
    for(l=0;l<w;l++)
	{
		for(k=0;k<h;k++)
		{
			output3[l][k]=input3[l][k];
			output4[l][k]=input4[l][k];
		}
	}
	
/*    mean=(input3[2][1]+input4[2][1])/2;
    output3[2][1]=mean*(1+alpha*input[0][0]);
    output4[2][1]=mean*(1-alpha*input[0][0]);
	mean=(input3[3][0]+input4[3][0])/2;
	output3[3][0]=mean*(1+alpha*input[0][1]);
	output4[3][0]=mean*(1-alpha*input[0][1]);
	mean=(input3[4][0]+input4[4][0])/2;
	output3[4][0]=mean*(1+alpha*input[1][0]);
	output4[4][0]=mean*(1-alpha*input[1][0]);
	mean=(input3[3][1]+input4[3][1])/2;
	output3[3][1]=mean*(1+alpha*input[2][0]);
	output4[3][1]=mean*(1-alpha*input[2][0]);
	mean=(input3[2][2]+input4[2][2])/2;
    output3[2][2]=mean*(1+alpha*input[1][1]);
	output4[2][2]=mean*(1-alpha*input[1][1]);
	mean=(input3[1][3]+input4[1][3])/2;
	output3[1][3]=mean*(1+alpha*input[0][2]);
	output4[1][3]=mean*(1-alpha*input[0][2]);
	mean=(input3[0][4]+input4[0][4])/2;
	output3[0][4]=mean*(1+alpha*input[0][3]);
	output4[0][4]=mean*(1-alpha*input[0][3]);
	mean=(input3[0][5]+input4[0][5])/2;
	output3[0][5]=mean*(1+alpha*input[1][2]);
	output4[0][5]=mean*(1-alpha*input[1][2]);
	mean=(input3[3][0]+input4[3][0])/2;
	output3[1][4]=mean*(1+alpha*input[2][1]);
	output4[1][4]=mean*(1-alpha*input[2][1]);
	mean=(input3[2][3]+input4[2][3])/2;
	output3[2][3]=mean*(1+alpha*input[3][0]);
	output4[2][3]=mean*(1-alpha*input[3][0]);
	mean=(input3[3][2]+input4[3][2])/2;
	output3[3][2]=mean*(1+alpha*input[3][1]);
	output4[3][2]=mean*(1-alpha*input[3][1]);
	mean=(input3[4][1]+input4[4][1])/2;
	output3[4][1]=mean*(1+alpha*input[2][2]);
	output4[4][1]=mean*(1-alpha*input[2][2]);
	mean=(input3[5][0]+input4[5][0])/2;
	output3[5][0]=mean*(1+alpha*input[1][3]);
	output4[5][0]=mean*(1-alpha*input[1][3]);
	mean=(input3[6][0]+input4[6][0])/2;
	output3[6][0]=mean*(1+alpha*input[2][3]);
	output4[6][0]=mean*(1-alpha*input[2][3]);
	mean=(input3[5][1]+input4[5][1])/2;
	output3[5][1]=mean*(1+alpha*input[3][2]);
	output4[5][1]=mean*(1-alpha*input[3][2]);
	mean=(input3[4][2]+input4[4][2])/2;
	output3[4][2]=mean*(1+alpha*input[3][3]);
	output4[4][2]=mean*(1-alpha*input[3][3]);
	*/
  }

void samplingextract(double *input1[],double *input2[],double *input3[],double *input4[],unsigned char *output[],short int blockwidth,short int blockheight)
{
	double mean;
	double alpha;
	double ttt;
	alpha=0.1;

   mean=(input1[2][1]+input2[2][1])/2;
	if ((input1[2][1]-input2[2][1])/mean>6*alpha||(input1[2][1]-input2[2][1])/mean<-6*alpha)
		output[0][0]=0;
	else
	{
		ttt=(input1[2][1]-input2[2][1])/(input1[2][1]+input2[2][1])/alpha;
		if(ttt>=0.5)
		output[0][0]=1;
		else
		output[0][0]=0;
	}
    
	mean=(input1[3][0]+input2[3][0])/2;
	if ((input1[3][0]-input2[3][0])/mean>6*alpha||(input1[3][0]-input2[3][0])/mean<-6*alpha)
		output[0][1]=0;
	else
	{
		ttt=(input1[3][0]-input2[3][0])/(input1[3][0]+input2[3][0])/alpha;
		if(ttt>=0.5)
		if(fabs(ttt)>=0.5)
		output[0][1]=1;
		else
		output[0][1]=0;
	}
    
	mean=(input1[4][0]+input2[4][0])/2;
	if ((input1[4][0]-input2[4][0])/mean>6*alpha||(input1[4][0]-input2[4][0]/mean)<-6*alpha)
		output[1][0]=0;
	else
	{
		ttt=(input1[4][0]-input2[4][0])/(input1[4][0]+input2[4][0])/alpha;
		if(ttt>=0.5)
		output[1][0]=1;
		else
		output[1][0]=0;
	}
    
	mean=(input1[3][1]+input2[3][1])/2;
	if ((input1[3][1]-input2[3][1])/mean>6*alpha||(input1[3][1]-input2[3][1])/mean<-6*alpha)
		output[2][0]=0;
	else
	{
		ttt=(input1[3][1]-input2[3][1])/(input1[3][1]+input2[3][1])/alpha;
		if(ttt>=0.5)
		output[2][0]=1;
		else
		output[2][0]=0;
	}
    
	mean=(input1[2][2]+input2[2][2])/2;
	if ((input1[2][2]-input2[2][2])/mean>6*alpha||(input1[2][2]-input2[2][2])/mean<-6*alpha)
		output[1][1]=0;
	else
	{
		ttt=(input1[2][2]-input2[2][2])/(input1[2][2]+input2[2][2])/alpha;
		if(ttt>=0.5)
		output[1][1]=1;
		else
		output[1][1]=0;
	}
    
	mean=(input1[1][3]+input2[1][3])/2;
	if ((input1[1][3]-input2[1][3])/mean>6*alpha||(input1[1][3]-input2[1][3])/mean<-6*alpha)
		output[0][2]=0;
	else
	{
		ttt=(input1[1][3]-input2[1][3])/(input1[1][3]+input2[1][3])/alpha;
		if(ttt>=0.5)
		output[0][2]=1;
		else
		output[0][2]=0;
	}
   
	mean=(input1[0][4]+input2[0][4])/2;
	if ((input1[0][4]-input2[0][4])/mean>6*alpha||(input1[0][4]-input2[0][4])/mean<-6*alpha)
		output[0][3]=0;
	else
	{
		ttt=(input1[0][4]-input2[0][4])/(input1[0][4]+input2[0][4])/alpha;
		if(ttt>=0.5)
		output[0][3]=1;
		else
		output[0][3]=0;
	}
	
	mean=(input1[0][5]+input2[0][5])/2;
	if ((input1[0][5]-input2[0][5])/mean>6*alpha||(input1[0][5]-input2[0][5])/mean<-6*alpha)
		output[1][2]=0;
	else
	{
        ttt=(input1[0][5]-input2[0][5])/(input1[0][5]+input2[0][5])/alpha;
		if(ttt>=0.5)
		output[1][2]=1;
		else
		output[1][2]=0;
	}

	mean=(input1[1][4]+input2[1][4])/2;
	if ((input1[1][4]-input2[1][4])/mean>6*alpha||(input1[1][4]-input2[1][4])/mean<-6*alpha)
		output[2][1]=0;
	else
	{
		ttt=(input1[1][4]-input2[1][4])/(input1[1][4]+input2[1][4])/alpha;
		if(ttt>=0.5)
		output[2][1]=1;
		else
		output[2][1]=0;
	}
	
	mean=(input1[2][3]+input2[2][3])/2;
	if( (input1[2][3]-input2[2][3])/mean>6*alpha||(input1[2][3]-input2[2][3])/mean<-6*alpha)
		output[3][0]=0;
	else
	{
		ttt=(input1[2][3]-input2[2][3])/(input1[2][3]+input2[2][3])/alpha;
		if(ttt>=0.5)
		output[3][0]=1;
		else
		output[3][0]=0;
	}
	
	mean=(input1[3][2]+input2[3][2])/2;
	if ((input1[3][2]-input2[3][2])/mean>6*alpha||(input1[3][2]-input2[3][2])/mean<-6*alpha)
		output[3][1]=0;
	else
	{
		ttt=(input1[3][2]-input2[3][2])/(input1[3][2]+input2[3][2])/alpha;
      if(ttt>=0.5)
		output[3][1]=1;
		else
		output[3][1]=0;
	}
	
	mean=(input1[4][1]+input2[4][1])/2;
	if ((input1[4][1]-input2[4][1])/mean>6*alpha||(input1[4][1]-input2[4][1])/mean>-6*alpha)
		output[2][2]=0;
	else
	{
		ttt=(input1[4][1]-input2[4][1])/(input1[4][1]+input2[4][1])/alpha;
		if(ttt>=0.5)
		output[2][2]=1;
		else
		output[2][2]=0;
	}
	
	mean=(input1[5][0]+input2[5][0])/2;
	if ((input1[5][0]-input2[5][0])/mean>6*alpha||(input1[5][0]-input2[5][0])/mean<-6*alpha)
		output[1][3]=0;
	else
	{
		ttt=(input1[5][0]-input2[5][0])/(input1[5][0]+input2[5][0])/alpha;
		if(ttt>=0.5)