lcolor.c

数字水印技术处理程序集合

			min = G[i];
		if (B[i] > max)
			max = B[i];
		else if (B[i] < min)
			min = B[i];

		(*V)[i] = max;

		if (max == 0)
			s = 0;
		else
			s = (image) RoundInt((double)(255 * (float)(max - min) / (float)max));
		(*S)[i] = s;

		if (s == 0)
			(*H)[i] = (image) (255*h/6);
		else {
			r = (float)(max-R[i]) / (float)(max-min);
			g = (float)(max-G[i]) / (float)(max-min);
			b = (float)(max-B[i]) / (float)(max-min);
			if (R[i] == max)
				if (G[i] == min)
					h = 5+b;
				else
					h = 1-g;
			else if (G[i] == max)
				if (B[i] == min)
					h = 1+r;
				else
					h = 3-b;
			else
				if (R[i] == min)
					h = 3+g;
				else
					h= 5-r;
			(*H)[i] = (image)RoundInt((double)(255*h/6));
		}
	}
}


void ConvertHSV2RGB(image *H, image *S, image *V, image **R, image **G, image **B, int width, int height){
	int i, g;
	float f, h, s;
	image m, n, k;

	(*R)=(image *)malloc(sizeof(image)*width*height);
	(*G)=(image *)malloc(sizeof(image)*width*height);
	(*B)=(image *)malloc(sizeof(image)*width*height);

	for (i=0;i<width*height;i++){
		s = (float)(S[i]) / 255;
		h = (float)(H[i]) / 255 * 6 ;
		g = (int)floor(h);
		if (g==6)
			g=5;
		f = h - g;

		m = (image) RoundInt( (double)( (float)(V[i]) * (1-s)) );
		n = (image) RoundInt( (double)( (float)(V[i]) * (1-s*f)) );
		k = (image) RoundInt( (double)( (float)(V[i]) * (1-s*(1-f))) );

		switch (g){
			case 0:
				(*R)[i] = V[i];
				(*G)[i] = k;
				(*B)[i] = m;
				break;
			case 1:
				(*R)[i] = n;
				(*G)[i] = V[i];
				(*B)[i] = m;
				break;
			case 2:
				(*R)[i] = m;
				(*G)[i] = V[i];
				(*B)[i] = k;
				break;
			case 3:
				(*R)[i] = m;
				(*G)[i] = n;
				(*B)[i] = V[i];
				break;
			case 4:
				(*R)[i] = k;
				(*G)[i] = m;
				(*B)[i] = V[i];
				break;
			case 5:
				(*R)[i] = V[i];
				(*G)[i] = m;
				(*B)[i] = n;
				break;
		}
	}
}


/*---------------------------------------------------------------------------
// RGB <=> XYZ transform
*/

void ConvertRGB2XYZ(image *R, image *G, image *B, image **X, image **Y, image **Z, int width, int height){
	int i;

	(*X) = (image *) malloc(sizeof(image)*width*height);
	(*Y) = (image *) malloc(sizeof(image)*width*height);
	(*Z) = (image *) malloc(sizeof(image)*width*height);

	for (i=0;i<width*height;i++){
		(*X)[i] = (image) RoundInt( (double)(RGB_TO_XYZ_MATRIX[0][0] * R[i])
								  + (double)(RGB_TO_XYZ_MATRIX[0][1] * G[i])
								  + (double)(RGB_TO_XYZ_MATRIX[0][2] * B[i]) );

		(*Y)[i] = (image) RoundInt( (double)(RGB_TO_XYZ_MATRIX[1][0] * R[i])
								  + (double)(RGB_TO_XYZ_MATRIX[1][1] * G[i])
								  + (double)(RGB_TO_XYZ_MATRIX[1][2] * B[i]) );

		(*Z)[i] = (image) RoundInt( (double)(RGB_TO_XYZ_MATRIX[2][0] * R[i])
								  + (double)(RGB_TO_XYZ_MATRIX[2][1] * G[i])
								  + (double)(RGB_TO_XYZ_MATRIX[2][2] * B[i]) );
	}
}


void ConvertXYZ2RGB(image *X, image *Y, image *Z, image **R, image **G, image **B, int width, int height){
	int i;

	(*R) = (image *) malloc(sizeof(image)*width*height);
	(*G) = (image *) malloc(sizeof(image)*width*height);
	(*B) = (image *) malloc(sizeof(image)*width*height);

	for (i=0;i<width*height;i++){
		(*R)[i] = (image) RoundInt( (double)(XYZ_TO_RGB_MATRIX[0][0] * X[i])
								  + (double)(XYZ_TO_RGB_MATRIX[0][1] * Y[i])
								  + (double)(XYZ_TO_RGB_MATRIX[0][2] * Z[i]) );

		(*G)[i] = (image) RoundInt( (double)(XYZ_TO_RGB_MATRIX[1][0] * X[i])
								  + (double)(XYZ_TO_RGB_MATRIX[1][1] * Y[i])
								  + (double)(XYZ_TO_RGB_MATRIX[1][2] * Z[i]) );

		(*B)[i] = (image) RoundInt( (double)(XYZ_TO_RGB_MATRIX[2][0] * X[i])
								  + (double)(XYZ_TO_RGB_MATRIX[2][1] * Y[i])
								  + (double)(XYZ_TO_RGB_MATRIX[2][2] * Z[i]) );
	}
}


/*---------------------------------------------------------------------------
// XYZ <=> Lab transform
*/

void ConvertXYZ2Lab(image *X, image *Y, image *Z, image **L, image **a, image **b, int width, int height){
	int i;
	double Xn, Yn, Zn;
  double tx, ty, tz;
  double ftx, fty, ftz;
	double L_tmp, a_tmp, b_tmp;
	short k = 10;
	
	
	/*image max_L = 0;
	image max_a = 0;
	image max_b = 0;*/

	(*L) = (image *) malloc(sizeof(image)*width*height);
	(*a) = (image *) malloc(sizeof(image)*width*height);
	(*b) = (image *) malloc(sizeof(image)*width*height);


	Xn = ( RGB_TO_XYZ_MATRIX[0][0] + RGB_TO_XYZ_MATRIX[0][1] + RGB_TO_XYZ_MATRIX[0][2] ) * 255;
	Yn = ( RGB_TO_XYZ_MATRIX[1][0] + RGB_TO_XYZ_MATRIX[1][1] + RGB_TO_XYZ_MATRIX[1][2] ) * 255;
	Zn = ( RGB_TO_XYZ_MATRIX[2][0] + RGB_TO_XYZ_MATRIX[2][1] + RGB_TO_XYZ_MATRIX[2][2] ) * 255;

	for (i=0;i<width*height;i++)
  {
		tx = (double)(X[i]) / Xn;
		ty = (double)(Y[i]) / Yn;
		tz = (double)(Z[i]) / Zn;

		if (tx > 0.008856)
			ftx = pow(tx, 0.3333333);
		else
			ftx = 7.7787*tx + 16/116;

		if (ty > 0.008856){
			fty = pow(ty, 0.3333333);
			L_tmp = 116*pow(ty, 0.3333333) - 16;
		}
		else {
			fty = 7.7787*ty + 16/116;
			L_tmp = 903.3*ty;
		}

		if (tz > 0.008856)
			ftz = pow(tz, 0.3333333);
		else
			ftz = 7.7787*tz + 16/116;

		a_tmp = 500*(ftx-fty);
		b_tmp = 200*(fty-ftz);

		(*L)[i] = (image) RoundInt(L_tmp*k);
		(*a)[i] = (image) RoundInt(a_tmp*k);
		(*b)[i] = (image) RoundInt(b_tmp*k);
	}
}

void ConvertLab2XYZ(image *L, image *a, image *b, image **X, image **Y, image **Z, int width, int height){
	int i;
	double Xn, Yn, Zn;
	double tx, tz;
	double ftx, ftz;
	double L_tmp, a_tmp, b_tmp;
	double X_tmp, Y_tmp, Z_tmp;
	short k = 10;

	(*X) = (image *) malloc(sizeof(image)*width*height);
	(*Y) = (image *) malloc(sizeof(image)*width*height);
	(*Z) = (image *) malloc(sizeof(image)*width*height);


	Xn = ( RGB_TO_XYZ_MATRIX[0][0] + RGB_TO_XYZ_MATRIX[0][1] + RGB_TO_XYZ_MATRIX[0][2] ) * 255;
	Yn = ( RGB_TO_XYZ_MATRIX[1][0] + RGB_TO_XYZ_MATRIX[1][1] + RGB_TO_XYZ_MATRIX[1][2] ) * 255;
	Zn = ( RGB_TO_XYZ_MATRIX[2][0] + RGB_TO_XYZ_MATRIX[2][1] + RGB_TO_XYZ_MATRIX[2][2] ) * 255;

	for (i=0;i<width*height;i++){
		L_tmp = (double)(L[i]) / k;
		a_tmp = (double)(a[i]) / k;
		b_tmp = (double)(b[i]) / k;

		tx = a_tmp/500 + (L_tmp+16)/116;
		tz = (L_tmp+16)/116 - b_tmp/200;

		if (tx > 0.207)
			ftx = pow(tx, 3);
		else
			ftx = (116*tx-16) / 903.3;

		if (tz > 0.207)
			ftz = pow(tz, 3);
		else
			ftz = (116*tz-16) / 903.3;

		X_tmp = Xn*ftx;
		if (L_tmp > 8)
			Y_tmp = Yn*pow((L_tmp+16)/116, 3);
		else
			Y_tmp = Yn*L_tmp / 903.3;
		Z_tmp = Zn*ftz;

		(*X)[i] = (image) RoundInt(X_tmp);
		(*Y)[i] = (image) RoundInt(Y_tmp);
		(*Z)[i] = (image) RoundInt(Z_tmp);
	}
}

/*---------------------------------------------------------------------------
// RGB <=> Lab transform
*/

void ConvertRGB2Lab(image *R, image *G, image *B, image **L, image **a, image **b, int width, int height){
	image *X, *Y, *Z;

	ConvertRGB2XYZ(R, G, B, &X, &Y, &Z, width,height);
	ConvertXYZ2Lab(X, Y, Z, L, a, b, width, height);
	free(X); free(Y); free(Z);
}

void ConvertLab2RGB(image *L, image *a, image *b, image **R, image **G, image **B, int width, int height){
	image *X, *Y, *Z;

	ConvertLab2XYZ(L, a, b, &X, &Y, &Z, width, height);
	ConvertXYZ2RGB(X, Y, Z, R, G, B, width, height);
	free(X); free(Y); free(Z);
}