musicplay.cpp

Visual C++数字图像识别技术典型案例 光盘源码

				{
					if (num > threshold) 
					{
						fill_value = 255;
						
						if ((!((check_x[0][0] < ch_x[0]) 
							&& (ch_x[1] < check_x[0][1]) 
							&& (check_y[0][0] > ch_y[0]) 
							&& (ch_y[1] > check_y[0][1])))
							&& (!((check_x[1][0] < ch_x[0]) 
							&& (ch_x[1] < check_x[1][1]) 
							&& (check_y[1][0] > ch_y[0]) 
							&& (ch_y[1] > check_y[1][1])))
							&& (!((check_x[2][0] < ch_x[0]) 
							&& (ch_x[1] < check_x[2][1]) 
							&& (check_y[2][0] > ch_y[0]) 
							&& (ch_y[1] > check_y[2][1])))) 
						{
							if (N[0] < num) 
							{
								for (i = 2; i > 0; i--) 
								{
									N[i] = N[i-1];
									check_x[i][0] = check_x[i-1][0];
									check_x[i][1] = check_x[i-1][1];
									check_y[i][0] = check_y[i-1][0];
									check_y[i][1] = check_y[i-1][1];
								}
								N[0] = num;
								
								check_x[0][0] = ch_x[0];
								check_x[0][1] = ch_x[1];
								check_y[0][0] = ch_y[0];
								check_y[0][1] = ch_y[1];
							}
							else if (N[1] < num) 
							{
								N[2] = N[1];
								check_x[2][0] = check_x[1][0];
								check_x[2][1] = check_x[1][1];
								check_y[2][0] = check_y[1][0];
								check_y[2][1] = check_y[1][1];
								
								N[1] = num;
								check_x[1][0] = ch_x[0];
								check_x[1][1] = ch_x[1];	
								check_y[1][0] = ch_y[0];
								check_y[1][1] = ch_y[1];
							}
							else if (N[2] < num) 
							{
								N[2] = num;	
								check_x[2][0] = ch_x[0];
								check_x[2][1] = ch_x[1];
								check_y[2][0] = ch_y[0];
								check_y[2][1] = ch_y[1];
							}
						}
					}
					else 
					{
						fill_value = GRAY;
					}
					
					xs = x;
					ys = y;
	    			image1[ys][xs] = 0;
					image2[ys][xs] = (unsigned char)fill_value;
					if (num > 1) 
					{
						for (i = 0; i < num-1; i++)
						{
							xs = xs + Freeman[chain_code[i]][0];
	    					ys = ys + Freeman[chain_code[i]][1];
	    					image1[ys][xs] = 0;
	    					image2[ys][xs] = (unsigned char)fill_value;
						}
					}
				}
			}
		}
	}
		
	kao_y[0] = check_y[0][0];
	flag1 = 0;
	for (i = 1; i < 3; i++)
	{
		if (kao_y[0] < check_y[i][0])
		{
			kao_y[0] = check_y[i][0];
			flag1 = i;
		}
	}
	if (flag1 == 0)
	{
		right_x[0] = check_x[1][0];
		s = 1;
	}
	else
	{
		right_x[0] = check_x[0][0];
		s = 0;
	}

	flag2 = s;
	for (i = s; i < 3; i++) 
	{
		if (i != flag1) 
		{
			if (right_x[0] > check_x[i][0])
			{
				right_x[0] = check_x[i][0];
				flag2 = i;
			}
		}
	}

	for (i = 0; i < 3; i++)
	{
		if (i == flag1)
		{
			kao_x[0] = check_x[i][0];
			kao_x[1] = check_x[i][1];
			kao_y[1] = check_y[i][1];
  		}
		else if (i == flag2)
		{
			right_x[1] = check_x[i][1];
			right_y[0] = check_y[i][0];
			right_y[1] = check_y[i][1];
		}
		else 
		{
			left_x[0] = check_x[i][0];
			left_x[1] = check_x[i][1];
			left_y[0] = check_y[i][0];
			left_y[1] = check_y[i][1];
		}
	}
	
	/*
	printf("脸   x = [%d, %d], y = [%d, %d]\n", 
		kao_x[0], kao_x[1], kao_y[0], kao_y[1]);
	printf("右手 x = [%d, %d], y = [%d, %d]\n", 
		right_x[0], right_x[1], right_y[0], right_y[1]);
	printf("左手 x = [%d, %d], y = [%d, %d]\n", 
		left_x[0], left_x[1], left_y[0], left_y[1]);
	*/
	
	mid = (kao_x[0] + kao_x[1]) / 2;
	wid_x = (60 * Z) / 83;
	dot_x = 42240 / wid_x;
	
	hani_x = dot_x / 12;
	MI = mid;
  
	LE = MI + hani_x;
	DO = LE + hani_x;
	FA = MI - hani_x;
	SO = FA - hani_x;
	RA = SO - hani_x;
	SI = RA - hani_x;
	DO1[0] = SI - hani_x;
	DO1[1] = DO1[0] - hani_x;
  
	left[5] = (kao_y[0] + kao_y[1]) / 2;
  
	wid_y = (60 * Z) / 95;
  
	dot_y = 14400 / wid_y;
  
	hani_y = dot_y / 5;
  
	left[4] = left[5] - hani_y;
	left[3] = left[4] - hani_y;
	left[2] = left[3] - hani_y;
	left[1] = left[2] - hani_y;
	left[0] = left[1] - hani_y;
  
	if (left_y[1] != y_size) 
	{
  		if (left_y[1] <= left[0]) 
		{
			printf("音量 0\n");
			volume = 0;
			leftVol = rightVol = volume;
		}
		else if ((left_y[1] <= left[1]) && (left_y[1] > left[0])) 
		{
  			printf("音量 1\n");
			volume = 10000;
			leftVol = rightVol = volume;
		}
		else if ((left_y[1] <= left[2]) && (left_y[1] > left[1]))
		{
			printf("音量 2\n");
			volume = 20000;
			leftVol = rightVol = volume;
		}
		else if ((left_y[1] <= left[3]) && (left_y[1] > left[2]))
		{
  			printf("音量 3\n");
			volume = 30000;
			leftVol = rightVol = volume;
		}
		else if ((left_y[1] <= left[4]) && (left_y[1] > left[3])) 
		{
    		printf("音量 4\n");
			volume = 40000;
			leftVol = rightVol = volume;
		}
		else if ((left_y[1] <= left[5]) && (left_y[1] > left[4])) 
		{
     		printf("音量 5\n");
			volume = 50000;
			leftVol = rightVol = volume;
		}
		else if (left_y[1] > left[5]) 
		{
  			printf("音量 6\n");
			volume = 60000;
			leftVol = rightVol = volume;
		}
		rc = waveOutSetVolume(hWaveOut,(DWORD)MAKELONG(leftVol,rightVol));
		if (rc!=MMSYSERR_NOERROR)
   			printf("音量设置错误\n");
	}
     
	if ((right_x[1] <= DO) && (right_x[1] > LE) && (onkai != 1)) 
	{
  		printf("音 DO\n");
		waveOutReset(hWaveOut);
		oscillatPlay(3, 261.6);
		onkai = 1;
	}
	else if ((right_x[1] <= LE) && (right_x[1] > MI) && (onkai != 2))
	{
  		printf("音 LE\n");
		waveOutReset(hWaveOut);
		oscillatPlay(3, 293.6);
		onkai = 2;
	}
	else if ((right_x[1] <= MI) && (right_x[1] > FA) && (onkai != 3))
	{
  		printf("音 MI\n");
		waveOutReset(hWaveOut);
		oscillatPlay(3, 329.6);
		onkai = 3;
	}
	else if ((right_x[1] <= FA) && (right_x[1] > SO) && (onkai != 4))
	{
  		printf("音 FA\n");
		waveOutReset(hWaveOut);
		oscillatPlay(3, 349.2);
		onkai = 4;
	}
	else if ((right_x[1] <= SO) && (right_x[1] > RA) && (onkai != 5))
	{
  		printf("音 SO\n");
		waveOutReset(hWaveOut);
		oscillatPlay(3, 392.0);
		onkai = 5;
	}
	else if ((right_x[1] <= RA) && (right_x[1] > SI) && (onkai != 6))
	{
  		printf("音 RA\n");
		waveOutReset(hWaveOut);
		oscillatPlay(3, 440.0);
		onkai = 6;
	}
	else if ((right_x[1] <= SI) && (right_x[1] > DO1[0]) && (onkai != 7))
	{
  		printf("音 SI\n");
		waveOutReset(hWaveOut);
		oscillatPlay(3, 493.8);
		onkai = 7;
	}
	else if ((right_x[1] <= DO1[0]) && (right_x[1] > DO1[1]) && (onkai != 8))
	{
  		printf("音 DO（高音）\n");
		waveOutReset(hWaveOut);
		oscillatPlay(3, 523.2);
		onkai = 8;
	}
	else if ((right_x[1] > DO) || (right_x[1] <= DO1[1]))
	{
		waveOutReset(hWaveOut);
		onkai = 0;
	}
  
	/* 后处理 */
	for (y = 0; y < y_size; y++) 
	{
		for (x = 0; x < x_size; x++) 
		{
			if (image2[y][x] == GRAY) 
			{
				image2[y][x] = 0;
				for (i = 0; i < 8; i++) 
				{
					xs = x + Freeman[i][0];
					ys = y + Freeman[i][1];
					if ((xs >= 0) && (xs <= x_size) && (ys >= 0) 
						&& (ys <= y_size) && (image2[ys][xs] == 255)) 
					{
						image2[y][x] = 255;
					}
				}
			}
		}
	}

	for (y = 0; y < y_size; y++) 
	{
		for (x = 0; x < x_size; x++) 
		{
			for (i = 0; i < 3; i++) 
			{
				pRGB1[count++] = image2[y][x];
			}
		}
	}
	
	return 0;
}


/******************************************************************************
 * 去除画像中的背景
******************************************************************************/
void haikei(BYTE *pRGB, BYTE *pRGB0, BYTE *pRGB1) 
{
	int x, y, k, hani_H=30, hani_S=30, i, hani_R=30;
	int hani_G=30, hani_B=30, hani_H1=60, hani_S1=60;
	unsigned char R, G, B, R1, G1, B1;
	long count=0;
	double H, S, V, H2, S2, V2;
	
	for (y = 0; y < y_size; y++) 
	{
		for (x = 0; x < x_size; x++) 
		{
			B = pRGB[(x + y*x_size)*3];
			G = pRGB[(x + y*x_size)*3+1];
			R = pRGB[(x + y*x_size)*3+2];
			B1 = pRGB0[(x + y*x_size)*3];
			G1 = pRGB0[(x + y*x_size)*3+1];
			R1 = pRGB0[(x + y*x_size)*3+2];
			
			HSV(&H, &S, &V, B, G, R);
			HSV(&H2, &S2, &V2, B1, G1, R1);
			
			if ((abs(H-H2) > hani_H) && (abs(S-S2) > hani_S) 
				&& (abs(R-R1) > hani_R) && (abs(G-G1) > hani_G) 
				&& (abs(B-B1) > hani_B)) 
			{
				image3[y][x] = 255;
			}
			else 
			{
				image3[y][x] = 0;
			}
			
			if ((abs(H-H2) < hani_H1) && (abs(S-S2) < hani_S1)) 
			{
				for (k = 0; k < 3; k++) 
				{
					pRGB1[count++] = 0;
				}
			}
			else 
			{
				for (k = 0; k < 3; k++) 
				{
					pRGB1[count++] = pRGB0[(x + y*x_size)*3 + k];
				}
			}
		}
	}
	
	remove_areas2();
}


/******************************************************************************
 * 去除噪声
******************************************************************************/
int remove_areas2(void)
{
	int threshold=10;
	int num, x, y, xs, ys, i;
	int fill_value;
	unsigned char image2[y_size][x_size];
	long count=0;
	double H=76, f=487, m=144, l;
	
	check = y_size;
	for (y = 0; y < y_size; y++) 
	{
		for (x = 0; x < x_size; x++) 
		{
			image2[y][x] = 0;
		}
	}
	
	for (y = 0; y < y_size; y++) 
	{
		for (x = 0; x < x_size; x++) 
		{
			if (image3[y][x] == 255) 
			{
				num = obtain_contour(x, y, image3);
				if (num != -1) 
				{
					if (num > threshold) 
					{
						fill_value = 255;
						
						if (check > ch_y[1]) 
						{
							check = ch_y[1];
						}
					}
					else
					{
						fill_value = GRAY;
					}
		
					xs = x;
					ys = y;
	    			image3[ys][xs] = 0;
					image2[ys][xs] = (unsigned char)fill_value;
					
					if (num > 1) 
					{
						for (i = 0; i < num-1; i++) 
						{
							xs = xs + Freeman[chain_code[i]][0];
	    					ys = ys + Freeman[chain_code[i]][1];
	    					image3[ys][xs] = 0;
	    					image2[ys][xs] = (unsigned char)fill_value;
						}
					}
				}
			}
		}
	}
	
	check = y_size - check;

	l = fabs(m-check);
	if (l == 0) 
	{
		l = 0.01;
	}
	Z = (f *  H) / l;
	printf("Z = %f\n", Z);
		
	/* 后处理 */
	for (y = 0; y < y_size; y++) 
	{
		for (x = 0; x < x_size; x++) 
		{
			if (image2[y][x] == GRAY) 
			{
				image2[y][x] = 0;
				for (i = 0; i < 8; i++) 
				{
					xs = x + Freeman[i][0];
					ys = y + Freeman[i][1];
					if ((xs >= 0) && (xs <= x_size) && (ys >= 0) 
						&& (ys <= y_size) && (image2[ys][xs] == 255)) 
					{
						image2[y][x] = 255;
					}
				}
			}
		}
	}

	for (y = 0; y < y_size; y++) 
	{
		for (x = 0; x < x_size; x++) 
		{
			for (i = 0; i < 3; i++) 
			{
				line[count++] = image2[y][x];
			}
		}
	}
	
	return 0;
}


/******************************************************************************
 * RGB转换到HSV
******************************************************************************/
void HSV(double *H, double *S, double *V, double B, double G, double R)
{
	double v, Vflag, vflag;
	
	*V = R;
	Vflag = 1;
	if (G > *V) 
	{
		*V = G;
		Vflag = 2;
	}
	if (B > *V) 
	{
		*V = B;
		Vflag = 3;
	}
	
	if (*V == 0) 
	{
		*S = 0;
		*H = 0;
	}
	else 
	{
		v = R;
		vflag = 1;
		if (G < v) 
		{
			v = G;
			vflag = 2;
		}
		if (B < v) 
		{
			v = B;
			vflag = 3;
		}
		
		*S = ((*V - v) / *V) * 255;
		
		if ((Vflag == 1) && (vflag == 2)) 
		{
			*H = (5 + ((*V - B) / (*V - v))) * 60;
		}
		else if ((Vflag == 1) && (vflag == 3)) 
		{
			*H = (1 - ((*V - G) / (*V - v))) * 60;
		}
		else if ((Vflag == 2) && (vflag == 3)) 
		{
			*H = (1 + ((*V - G) / (*V - R))) * 60;
		}
		else if ((Vflag == 2) && (vflag == 1)) 
		{
			*H = (3 - ((*V - B) / (*V - v))) * 60;
		}
		else if ((Vflag == 3) && (vflag == 1)) 
		{
			*H = (3 + ((*V - G) / (*V - v))) * 60;
		}
		else if ((Vflag == 3) && (vflag == 2)) 
		{
			*H = (5 - ((*V - R) / (*V - v))) * 60;
		}
	}
}