【数据压缩】第一周作业及实验一——浊音、清音、爆破音频谱分析与RGB文件熵计算

1.1 查看浊音、清音、爆破音的时域波形及分析其频域特性

使用Audacity分析浊音、清音以及爆破音的时域及频域特性分析

1. 浊音“a”
   1）时域
   浊音时域波形比较规律，具有短时周期性，过零点不明显；
   2)频域
   能量集中在低频，存在明显的共振峰，峰值在300Hz左右。
   

2. 浊音“o”
   1）时域
   2）频域
   

3. 浊音“e”
   1）时域
   

   2）频域
   浊音“a\o\e”的时域与频域特性都十分相似

4. 清音“s”
   1）时域
   波形较为均匀，幅度变化也比浊音小，波形频率高，过零点不清晰，短时过零率最大。2）频域
   能量分布较为平均，能量最大值位于2000Hz附近

5. 爆破音“p”
   1）时域
   波形一开始非常集中，变换的频率很高，中后部分的波形呈现非常有规律的“缓波”形2）频域
   能量集中在低频部分，短时过零率比浊音大，比清音小，波形抖动幅度最大，能量从低频向2000Hz急剧递减

1.2 RGB文件熵计算

1.实验目的
对RGB文件进行分析，计算三个通道(BGR BGR BGR)各自的熵。

2.代码思路
1）读入一个RGB文件，创建3个空文件
2）创建3个数组，将R、G、B各分量数据从RGB文件中读出，并保存到3个数组中
3）统计RGB的出现次数，计算概率分布
4）将值分别读入RGB个空文件中
5）计算熵
3.代码

#include <iostream>  
#include <stdio.h>  
#include <stdlib.h>  
using namespace std;  
const int Size = 256 * 256;//图像大小  
int main()  
{  
     //打开RGB并存入sum,创建三个空文件  
     FILE* image, * red, * green,*blue;   
     fopen_s(&image, "...\\test.rgb", "rb");  
     fopen_s(&red, "...\\Red.txt", "w");  
     fopen_s(&green, "...\\Green.txt", "w");  
     fopen_s(&blue, "...\\Blue.txt", "w");  
     
     unsigned char sum[256*256*3];  
     fread(sum, 1, 256*256*3, image);  
  
     //定义存放R、G、B分量的数组
     unsigned char R[size] = { 0 };
     unsigned char G[size] = { 0 };
     unsigned char B[size] = { 0 };  
     //定义频率分量  
     double R_F[256] = { 0 };
     double G_F[256] = { 0 };
     double B_F[256] = { 0 };  
     //定义熵  
     double R_S = 0,G_S = 0, B_S = 0;  
  
  	//分别读取R、G、B三个分量到数组中
     for (int i = 0, j = 0; i < 256*256*3; i = i + 3, j++)  
     {  
          B[j] = *(sum + i);  
          G[j] = *(sum + i + 1);  
          R[j] = *(sum + i + 2);   
     }  
  
     //统计每个颜色值i出现的次数F
     for (int i = 0; i < 256; i++)  //分量取值i范围0~255
     {  
          for (int j = 0; j < size; j++)  
          {  
               if (int(R[j] == i))   
                   R_F[i]++;  
               if (int(G[j] == i))   
                   G_F[i]++;  
               if (int(B[j] == i))  
                   B_F[i]++;  
          }  
     }  
  
    //计算每个色彩值i的频率F 
     for (int i = 0; i < 256; i++) 
     {  
          R_F[i] = R_F[i] / (256 * 256);  
          B_F[i] = B_F[i] / (256 * 256);  
          G_F[i] = G_F[i] / (256 * 256);  
     }  
  
     //将频率写入文件  
     fprintf(red, "值\t概率\n");  
     for (int i = 0; i < 256; i++)  
        fprintf(red, "%d\t%f\n", i, R_F[i]);  
  
     fprintf(green, "值\t概率\n");  
     for (int i = 0; i < 256; i++)  
         fprintf(green, "%d\t%f\n", i, G_F[i]);  
  
     fprintf(blue, "值\t概率\n");  
     for (int i = 0; i < 256; i++)  
         fprintf(blue, "%d\t%f\n", i, B_F[i]);  
  
     //计算并输出熵S
     for (int i = 0; i < 256; i++)  
     {  
          if (R_F[i] != 0)   
              R_S += -R_F[i] * log(R_F[i]) / log(double(2));  
          if (G_F[i] != 0)   
              G_S += -G_F[i] * log(G_F[i]) / log(double(2));  
          if (B_F[i] != 0)  
              B_S += -B_F[i] * log(B_F[i]) / log(double(2));  
     }  
  
     cout << "R熵为" << R_S << endl;  
     cout << "G熵为" << G_S << endl;  
     cout << "B熵为" << B_S << endl;  
  
     fclose(image);  
     fclose(red);  
     fclose(green);  
     fclose(blue);  
     return 0;  
} 

运行结果