zigzag.c

图像置乱代码

/*---------------------------------------------------------------------------
*    zigzag transformation
* ---------------------------------------------------------------------------*/
#include <tina/all_tina.h>
#include "bmp.h"

#define MAXPATHLEN 64
static char directory_name[MAXPATHLEN];
static char file_name[MAXPATHLEN];
static char pathname[MAXPATHLEN];
static void *pdir=0, *pfile=0;

static int SCRAM_n = 1;
static int ROW = 8;
static int COL = 8;
static Tv *tv = NULL;
static Tv *tv1=NULL;

/*---------------------------------------------------------------------------
     To generate the scrambling mapping-matrix of zigzag transformation.
 ---------------------------------------------------------------------------*/
void zigzag_matrix(int** r, int** c, int height, int width)
{
	int i,j,k;
	int s = 0;
	printf("\nzigzag transform\n");
	int *dest;
	int m = height*width;
	dest = int_vector(m);
	int col = width;
	int row = height;
/*----------------------------------------------*/
	dest[0] = s;
	for(i = 1; i < col; i = i + 2)
	{
		k = i;
		for(j = 0; j < row && k >=0; j ++)
		{
			dest[j*col+k] = ++s;
			k --;
		}
		if(j == row)
			break;
		if(k < 0)
			k ++;
		for(;j >=0 && k < col; j --)
		{
			dest[j*col+k] = ++s;
			k ++;
		}
		if(k == col)
			break;
	}
	if(j == row)
	{
		k = k + 2;
		for(i = k; i < col; i = i + 2)
		{
			k = i;
			j --;
			for(;j >= 0 && k < col; j --)
			{
				dest[j*col+k] = ++s;
				k ++;
			}
			if(k == col)
			{
				k --;
				j = j + 2;
			}
			else
			{
				j ++;
			}
			for(;j < row && k > 0; j ++)
			{
				dest[j*col+k] = ++s;
				k --;
			}
		}
	}
	if(k == col)
	{
		j = j + 2;
		for(;j < row;j = j +2)
		{
			i = j;
			k --;
			for(;i <row && k >= 0; i ++ )
			{
				dest[i*col+k] = ++s;
				k --;
			}
			if(i == row)
			{
				i --;
				k = k + 2;
			}
			else
			{
				k ++;
			}
			for(; i >= 0 && k < col; i --)
			{
				dest[i*col+k] = ++s;
				k ++;
			}
		}
	}
/*----------------------------------------------*/
	for(i = 0; i < m; i++)
        {
            	r[i/col][i%col] = dest[i] / col;
		c[i/col][i%col] = dest[i] % col;

	}
	free_int_vector(dest);
}
 /*---------------------------------------------------------------------------
  To generate the inverse scrambling mapping-matrix of zigzag transformation.
 ---------------------------------------------------------------------------*/
void r_zigzag_matrix(int** src_r,int** src_c, int height, int width)
{
	int i,j,r,c;
	int **trans_r, **trans_c;
	trans_r = int_matrix(height, width);
	trans_c = int_matrix(height, width);
	zigzag_matrix(trans_r, trans_c, height, width);
	printf("\nR_zigzag transform\n");
	for(i = 0; i < height; i++)
	{
		for(j = 0; j < width; j++)
		{
			r = trans_r[i][j];
			c = trans_c[i][j];
			src_r[r][c] = i;
			src_c[r][c] = j;
		}
	}
	free_int_matrix(trans_r, height);
	free_int_matrix(trans_c, height);
}

static 	Imrect *read_image(void)
{
	Imrect *srcIm;
/*----------------Read the image---------------------------*/
  	(void) strip_spaces(file_name);
  	(void) strip_spaces(directory_name);
  	(void) string_append(pathname, directory_name, "/", file_name, NULL);
	srcIm = ReadGIF(pathname, 1);
/*------------------------------------------------*/
	return(srcIm);
}


 /*---------------------------------------------------------------------------
     zigzag transformation
 ---------------------------------------------------------------------------*/
void zigzag_Trans(int nTrans)
{
	Imrect *srcIm,*destIm,*tmpIm;
	int width, height;
	Imregion *roi;
	int i,j,k;
	int type;
	BYTE pix;
/*
	if (stack_check_types(IMRECT, NULL) == false)
	{
		error("zigzag : wrong types on stack", warning);
		return;
	}
	srcIm = (Imrect *) stack_pop(&type);
*/
	srcIm = read_image();
	//srcIm = DrawRGB_proc();
	width = srcIm->width;
    	height = srcIm->height;
	if (width != height)
	{
		error("zigzag:width != height", warning);
		return;
	}

	roi = srcIm->region;
	if (roi == NULL) return ;

/*------------------------------------------------*/
	int **trans_r, **trans_c;
	trans_r = int_matrix(height, width);
	trans_c = int_matrix(height, width);
	zigzag_matrix(trans_r, trans_c, height, width);
/*------------------------------------------------*/
	printf("\n\n=== zigzag Transform begin: ===\n");

	destIm = im_alloc( height, width, roi, int_v );

	int r,c;
	for( k = 0; k < SCRAM_n; k++)
	{	
		for (i = 0; i < height  ; i++)
		{
			for (j = 0; j< width ; j++)
			{				
				IM_PIX_GET(srcIm, i, j, pix);
				IM_PIX_SET(destIm, trans_r[i][j], trans_c[i][j], pix);
			}
		}
 		tmpIm = srcIm;
		srcIm = destIm;
		destIm = tmpIm;
	}
/*----------------------Save the image as .gif--------------------------*/
	char filename[64];
	char string[25];
	gcvt(k,5,string);
	printf("string=%s\n",string);
	strcpy(filename,"result/zigzag/zigzag_");
	strcat(filename, string);
	strcat(filename,".gif");
	//gif_write_file(srcIm,filename);
	gif_write_file_color(srcIm,filename);
	//strcat(filename,".bmp");
	//ImrectToBMP8(srcIm,filename);
//}
/*------------------------------------------------*/
	tv_imrect2(tv1, srcIm);

	im_free(destIm);
	free_int_matrix(trans_r, height);
	free_int_matrix(trans_c, height);
	printf("=== zigzag transform complete! ===\n");
}
/*---------------------------------------------------------------------------
    inverse zigzag transformation
 ---------------------------------------------------------------------------*/
void R_zigzag_Trans(int nTrans)
{
	Imrect *srcIm,*destIm,*tmpIm;
	int width, height;
	Imregion *roi;
	int i,j,k;
	int type;
	BYTE pix;
/*
	if (stack_check_types(IMRECT, NULL) == false)
	{
		error("zigzag : wrong types on stack", warning);
		return;
	}
	srcIm = (Imrect *) stack_pop(&type);
*/
	srcIm = read_image();
	width = srcIm->width;
    	height = srcIm->height;
	if (width != height)
	{
		error("R_zigzag:width != height", warning);
		return;
	}

	roi = srcIm->region;
	if (roi == NULL) return ;

/*------------------------------------------------*/
	int **trans_r, **trans_c;
	trans_r = int_matrix(height, width);
	trans_c = int_matrix(height, width);
	r_zigzag_matrix(trans_r, trans_c, height, width);
/*------------------------------------------------*/
	printf("\n\n=== R_zigzag Transform begin: ===\n");

	destIm = im_alloc( height, width, roi, int_v );

	int r,c;
	for( k = 0; k < SCRAM_n; k++)
	{	
		for (i = 0; i < height  ; i++)
		{
			for (j = 0; j< width ; j++)
			{				
				IM_PIX_GET(srcIm, i, j, pix);
				IM_PIX_SET(destIm, trans_r[i][j], trans_c[i][j], pix);
			}
		}
 		tmpIm = srcIm;
		srcIm = destIm;
		destIm = tmpIm;
	}
/*----------------------Save the image as .gif--------------------------*/
	char filename[64];
	char string[25];
	gcvt(k,5,string);
	printf("string=%s\n",string);
	char *filename0 ="result/zigzag/";
	strcpy(filename,filename0);
	strcat(filename,file_name);
	strcat(filename,"+R_zigzag_");
	strcat(filename, string);
	strcat(filename,".gif");
	gif_write_file(srcIm,filename);
/*------------------------------------------------*/
	tv_imrect2(tv1, srcIm);

	im_free(destIm);
	free_int_matrix(trans_r, height);
	free_int_matrix(trans_c, height);
	printf("=== R_zigzag transform complete! ===\n");
}

static void show_zigzag(void)
{
	int **trans_r, **trans_c;
	int height = ROW; 
	int width = COL;
	int i,j;
	trans_r = int_matrix(height, width);
	trans_c = int_matrix(height, width);
	zigzag_matrix(trans_r, trans_c, height, width);
if(width%2 == 1)
{
	for(i = 0;i < width;i ++)
	{
		if(i == (int)width/2)
			printf("line");
		else
		{
			printf("----");
		}
	}
	printf("\n");
}
else
{
	for(i = 0;i < width;i ++)
	{
		if(i == (int)width/2-1)
			printf("line");
		else
		{
			printf("----");
		}
	}
	printf("\n");
}
/*-----------------------------------------------------------*/
	for(i = 0; i < height; i++)
	{
		for(j = 0; j < width; j++)
		{
			printf("%3d ",trans_r[i][j]*width+trans_c[i][j]);
		}
		printf("\n");
	}
/*-----------------------------------------------------------*/
	for(i = 0;i < width;i ++)
		printf("----");
	printf("\n");
if(width%2 == 1)
{
	for(i = 0;i < width;i ++)
	{
		if(i == (int)width/2)
			printf("location");
		else
		{
			printf("--------");
		}
	}
	printf("\n");
}
else
{
	for(i = 0;i < width;i ++)
	{
		if(i == (int)width/2-1)
			printf("location");
		else
		{
			printf("--------");
		}
	}
	printf("\n");
}
/*-----------------------------------------------------------*/
	for(i = 0; i < height; i++)
	{
		for(j = 0; j < width; j++)
		{
			printf("(%2d %2d) ",trans_r[i][j],trans_c[i][j]);
		}
		printf("\n");
	}
/*-----------------------------------------------------------*/
	for(i = 0;i < width;i ++)
		printf("--------");
	printf("\n");
	free_int_matrix(trans_r, height);
	free_int_matrix(trans_c, height);
}
static void tv_choice_proc(choice)
int     choice;
{
    switch (choice)
    	{
    	case 0: tv_set_next(tv);
		break;
    	case 1: tv_set_next(tv1);
		break;
    	default:error("tv_choice_proc: unknown choice\n", warning);
		break;
    	}
}

static void scan_proc(void)
{
    scan_files(directory_name,file_name);
    tw_sglobal_reset(pdir);
    tw_sglobal_reset(pfile);
}



void            zigzag_tool(int x, int y)
{
	static void *tool = NULL;

	static void tv_choice_proc();
	if (tool)
	{
		tw_show_tool(tool);
		return;
	}
	tool = (void *)tw_tool("zigzag Scrambling tool", x, y);
    	/* Initialise pathname from environment variable (or #define) */
    	(void) environ_pathname_get(directory_name, file_name,
				"TINA_IMAGE_DEFAULT",
				"/home/wzz/newimscramdegree/result/zigzag/gRGB.gif");

	tv = tv_create("zigzag original");
     	tv1 = tv_create("zigzag scrambled");

        tw_choice("Tv choice", tv_choice_proc, 0, "original","scrambled", NULL);
	tw_newrow();
	tw_newrow();

	/*---------------------------*/
  	pdir = (void *) tw_sglobal("Directory:", directory_name, 32);
    	tw_button("scan", scan_proc, NULL);
  	tw_newrow();
  	pfile = (void*) tw_sglobal("File:", file_name, 32);
  	tw_newrow();
	/*---------------------------*/
	tw_iglobal("Scrambling times = ", &SCRAM_n, 5);
	tw_newrow();
	tw_button("zigzag", zigzag_Trans,NULL);
	tw_button("R_zigzag", R_zigzag_Trans,NULL);
	tw_newrow();
 	tw_label("--------------------------------------------");
	tw_newrow();
	tw_iglobal("row= ", &ROW, 5);
	tw_iglobal("col= ", &COL, 5);
	tw_button("show zigzag", show_zigzag,NULL);
	tw_newrow();
	tw_end_tool();
}