精华内容
下载资源
问答
  • 绘制波形图

    2019-01-23 14:07:18
    wpf中绘画波形图,下载就可用,只需要在后台设置一下x和y的值就可以了
  • 易语言BASS绘制波形图源码,BASS绘制波形图,draw,取低十六位,取高十六位
  • VC++ 实现绘制波形图动态图 VC++ 实现绘制波形图动态图 VC++ 实现绘制波形图动态图 VC++ 实现绘制波形图动态图 VC++ 实现绘制波形图动态图 VC++ 实现绘制波形图动态图
  • BASS绘制波形图.rar

    2020-04-04 11:01:17
    BASS绘制波形图.rar
  • 绘制波形图的软件

    2016-04-18 16:07:58
    绘制波形图的软件
  • 摘要:C#源码,图形图像,波形图,图形绘制 学习C#的参考范例源码,绘制波形图的源代码,运行编译的程序后,直接生成波形图,要了解原理的朋友,就请下载C#源码一看究竟。
  • VC++ 实现绘制波形图动态图,类似示波器的界面,信号用正弦信号模拟,可调节显示的幅度档和时间档,可对信号进行暂停观测,可上下左右移动信号波形。
  • 易语言BASS绘制波形图源码
  • C#绘制波形图Demo

    2018-07-07 10:41:34
    利用C#把数据绘制成二维图波形图,实时动态显示数据的变化
  • 主要介绍了java读取wav文件(波形文件)并绘制波形图的方法,涉及java操作多媒体音频文件转换的相关技巧,需要的朋友可以参考下
  • 一直想写个波线图,但写出来发现这是点阵组成的,不知道如何把线条弄的特别的平滑,有会的,求留言评论指导。1.[代码][JavaScript]代码Document.container{width:500px;height:500px;border:1px solid #DEDEDE;...

    一直想写个波线图,但写出来发现这是点阵组成的,不知道如何把线条弄的特别的平滑,有会的,求留言评论指导。

    1.[代码][JavaScript]代码

    Document

    .container{width:500px;height:500px;border:1px solid #DEDEDE;}

    .container span{width:1px;height:50px;float:left;border-bottom:2px solid #F00;margin-bottom:0px;}

    var i = 0;

    (function abc() {

    setTimeout(function () {

    if (i++ < 500) {

    var me = document.getElementsByClassName("container");

    var j = document.createElement('span');

    var th = document.getElementsByTagName("span");

    var h = 0;

    if (i > 1) {

    var l = i - 2;

    var h = th[l].clientHeight;

    } else {

    h = 50;

    }

    var arr = new Array(-2,-1,0,1,2);

    var k = Math.floor((Math.random() * 5));

    j.style.height = h + arr[k] + "px";

    me[0].appendChild(j);

    abc();

    }

    }, 50);

    })()

    展开全文
  • Qt中使用Qwt-6.0.1绘制波形图c++
  • ffmpeg -i test_pcm_mulaw.wav -f wav -codec:a pcm_s16le -ar 8000 -ac 1 out.wavyingc@yingc:~/media/audio$ ffprobe out.wavffprobe version 2.2.4 Copyright (c) 2007-2014 the FFmpeg developersbuilt on Apr ....

    ffmpeg -i test_pcm_mulaw.wav -f wav -codec:a pcm_s16le -ar 8000 -ac 1 out.wav

    yingc@yingc:~/media/audio$ ffprobe out.wav

    ffprobe version 2.2.4 Copyright (c) 2007-2014 the FFmpeg developers

    built on Apr 13 2016 08:42:24 with gcc 4.6 (Ubuntu/Linaro 4.6.3-1ubuntu5)

    configuration: --prefix=/home/yingc/git/thirdparty/av/ffmpeg/output/ffmpeg_build/ --bindir=/home/yingc/git/thirdparty/av/ffmpeg/output/bin --extra-cflags=' -I/home/yingc/git/thirdparty/av/ffmpeg/output/ffmpeg_build/include' --extra-ldflags=-L/home/yingc/git/thirdparty/av/ffmpeg/output/ffmpeg_build/lib --extra-libs=-ldl --enable-gpl --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-nonfree --enable-x11grab --disable-stripping --enable-extra-warnings --disable-optimizations --enable-openssl --enable-static --enable-debug=3

    libavutil 52. 66.100 / 52. 66.100

    libavcodec 55. 52.102 / 55. 52.102

    libavformat 55. 33.100 / 55. 33.100

    libavdevice 55. 10.100 / 55. 10.100

    libavfilter 4. 2.100 / 4. 2.100

    libswscale 2. 5.102 / 2. 5.102

    libswresample 0. 18.100 / 0. 18.100

    libpostproc 52. 3.100 / 52. 3.100

    Input #0, wav, from 'out.wav':

    Metadata:

    encoder : Lavf55.33.100

    Duration: 00:08:10.03, bitrate: 128 kb/s

    Stream #0:0: Audio: pcm_s16le ([1][0][0][0] / 0x0001), 8000 Hz, 1 channels, s16, 128 kb/s

    展开全文
  • MFC绘制波形图代码

    2018-12-18 09:45:44
    改代码实现了波形图的的绘制并显示,是在基于MFC框架下开发的,一键编译运行即可,并可查看源码,可快速移植
  • java 读取.wav文件(波形文件)并绘制波形图例子-附件资源
  • 利用Java实现DFT、FFT,读取WAV文件,并绘制波形图和频谱图,音频播放频谱或波形图实时显示效果。 几个工程打包于文件夹DFT_FFT: DFT_IDFT:计算前N点DFT,并绘制波形图或频谱图; FFT:计算前N点FFT,并绘制波形图...
  • VoiceRecorderDemo iOS根据音频文件的音调高低,绘制波形图,可以做参考。
  • 读取双通道波形并绘制波形图 import wave import matplotlib.pyplot as plt import numpy as np """读取双通道波形并绘制波形图""" # 打开WAV音频 f = wave.open("./audio/audio.wav", "rb") # 读取格式信息 # ...

    读取双通道波形并绘制波形图

    import wave
    import matplotlib.pyplot as plt
    import numpy as np
    """读取双通道波形并绘制波形图"""
    # 打开WAV音频
    f = wave.open("./audio/audio.wav", "rb")
    
    # 读取格式信息
    # (声道数、量化位数、采样频率、采样点数、压缩类型、压缩类型的描述)
    # (nchannels, sampwidth, framerate, nframes, comptype, compname)
    params = f.getparams()
    nchannels, sampwidth, framerate, nframes = params[:4]
    print("声道数---", nchannels)
    print("量化位数---", sampwidth)
    print("采样频率---", framerate)
    print("采样点数---", nframes)
    
    # 读取nframes个数据,返回字符串格式
    str_data = f.readframes(nframes)
    f.close()
    
    # 将字符串转换为数组,得到一维的short类型的数组
    wave_data = np.fromstring(str_data, dtype=np.short)
    
    # 赋值的归一化
    wave_data = wave_data * 1.0 / (max(abs(wave_data)))
    
    # 整合左声道和右声道的数据
    wave_data = np.reshape(wave_data, [nframes, nchannels])
    # wave_data.shape = (-1, 2)   # -1的意思就是没有指定,根据另一个维度的数量进行分割
    
    # 最后通过采样点数和取样频率计算出每个取样的时间
    time = np.arange(0, nframes) * (1.0 / framerate)
    
    plt.figure()
    # 左声道波形
    plt.subplot(3, 1, 1)
    plt.plot(time, wave_data[:, 0])
    plt.xlabel("time (seconds)")
    plt.ylabel("Amplitude")
    plt.title("Left channel")
    plt.grid()  # 标尺
    
    plt.subplot(3, 1, 3)
    # 右声道波形
    plt.plot(time, wave_data[:, 1], c="g")
    plt.xlabel("time (seconds)")
    plt.ylabel("Amplitude")
    plt.title("Left channel")
    plt.title("right channel")
    plt.grid()
    
    plt.show()
    

    这种方法读取的是字符型,需要经过 np.fromstring(str_data, dtype=np.short)类型转换。

    第二种读取wav文件的方式:

    from scipy.io import wavfile

    sampling_freq, audio = wavfile.read(" .wav")

    这里读取的audio直接是数组形式。

    import wave
    import matplotlib.pyplot as plt
    import numpy as np
    from scipy.io import wavfile
    """读取双通道波形并绘制波形图"""
    f = wavfile.read("./audio/audio.wav")
    nframes = len(f[1])  #获取采样点数
    nchannels = 2  #  通道数=2
    framerate = f[0] #  获取采样频率
    wave_data = f[1]  #  获取音频数据
    wave_data = np.reshape(wave_data, [nframes, nchannels])
    # 最后通过采样点数和取样频率计算出每个取样的时间
    time = np.arange(0, nframes) * (1.0 / framerate)
    
    plt.figure()
    # 左声道波形
    plt.subplot(3, 1, 1)
    plt.plot(time, wave_data[:, 0])
    plt.xlabel("time (seconds)")
    plt.ylabel("Amplitude")
    plt.title("Left channel")
    plt.grid()  # 标尺
    
    plt.subplot(3, 1, 3)
    # 右声道波形
    plt.plot(time, wave_data[:, 1], c="g")
    plt.xlabel("time (seconds)")
    plt.ylabel("Amplitude")
    plt.title("Left channel")
    plt.title("right channel")
    plt.grid()
    plt.show()
    

    结果如下:

    在这里插入图片描述

    音频信号的短时频域处理

    语音信号处理中,信号再频域或其他变换域上的分析处理非常重要,再频域上研究语音可以使信号在时域上无法表现出来的特征变得十分明显,一个音频信号的本质是由其频率内容来决定的。—短时傅里叶变换

    import numpy as np
    from scipy.io import wavfile
    import matplotlib.pyplot as plt
    
    sampling_freq, audio = wavfile.read("./audio/audio.wav")  # 读取文件
    
    audio = audio / np.max(audio)  # 归一化,标准化
    
    # 应用傅里叶变换
    fft_signal = np.fft.fft(audio)
    print(fft_signal)
    
    fft_signal = abs(fft_signal)
    print(fft_signal)
    
    # 建立时间轴
    Freq = np.arange(0, len(fft_signal))
    
    # 绘制语音信号的
    plt.figure()
    plt.plot(Freq, fft_signal, color='blue')
    plt.xlabel('Freq (in kHz)')
    plt.ylabel('Amplitude')
    plt.show()
    

    在这里插入图片描述

    显示双通道语音信号和频谱图:

    import wave
    import matplotlib.pyplot as plt
    import numpy as np
    from scipy.io import wavfile
    """读取双通道波形并绘制波形图"""
    sampling_freq, f = wavfile.read("./audio/audio.wav")
    
    nframes = len(f)  #获取采样点数
    nchannels = 2  #  通道数=2
    framerate = sampling_freq #  获取采样频率
    wave_data = f  #  获取音频数据
    wave_data = np.reshape(wave_data, [nframes, nchannels])
    # 最后通过采样点数和取样频率计算出每个取样的时间
    time = np.arange(0, nframes) * (1.0 / framerate)
    #  归一化标准化
    f = f / np.max(f)
    # 应用傅里叶变换
    f = np.fft.fft(f)
    f = abs(f)
    # 建立时间轴
    freq = np.arange(0, len(f))
    
    plt.figure()
    # 左声道波形
    plt.subplot(3, 1, 1)
    plt.plot(time, wave_data[:, 0])
    plt.xlabel("time (seconds)")
    plt.ylabel("Amplitude")
    plt.title("Left channel")
    plt.grid()  # 标尺
    
    # 右声道波形
    plt.subplot(3, 1, 2)
    plt.plot(time, wave_data[:, 1], c="g")
    plt.xlabel("time (seconds)")
    plt.ylabel("Amplitude")
    plt.title("Left channel")
    plt.title("right channel")
    plt.grid()
    
    # 绘制频谱图
    plt.subplot(3, 1, 3)
    plt.plot(freq, f, color='blue')
    plt.xlabel('Freq (in kHz)')
    plt.ylabel('Amplitude')
    plt.grid()
    
    plt.show()
    

    在这里插入图片描述

    写入wav文件(合成wav文件)

    先读取一个存在的音频文件,然后写入一个新的文件。

    import wave
    import numpy as np
    import struct
    
    f = wave.open("./audio/audio.wav", "rb")  # 已存在的wav文件
    params = f.getparams()  # 读取该文件的参数
    # 读取原文件的通道数,量化位数,采样频率,采样点数
    nchannels_old, sampwidth_old, framerate_old, nframes_old = params[:4]
    strData = f.readframes(nframes_old)
    #转换读取的格式
    waveData = np.fromstring(strData, dtype=np.int16)
    f.close()
    waveData = waveData * 1.0 / (max(abs(waveData)))
    
    # wav文件写入
    # 待写入wav的数据,这里仍然取waveData数据
    outData = waveData
    outwave = wave.open("./audio/compose_test.wav", 'wb')
    # 通道数,量化位数,采样频率,采样点数设置。也可自行选择
    nchannels = nchannels_old 
    sampwidth = sampwidth_old  
    framerate = framerate_old  
    nframes = nframes_old  
    # 写入文件参数配置
    comptype = "NONE"
    compname = "not compressed"
    outwave.setparams((nchannels, sampwidth, framerate, nframes,
                       comptype, compname))
    
    for i in outData:
        outwave.writeframes(struct.pack('h', int(i * 64000 / 2)))
    
        # struct.pack(FMT, V1)将V1的值转换为FMT格式字符串
    outwave.close()
    

    录音

    以SAMPLING_RATE为采样频率,每次读入一块有NUM_SAMPLES个采样的数据块,当读入的采样数据中有COUNT_NUM个值大于LEVEL的取样的时候,将数据保存进WAV文件,一旦开始保存数据,所保存的数据长度最短为SAVE_LENGTH个块。WAV文件以保存时的时刻作为文件名。

    从声卡读入的数据和从WAV文件读入的类似,都是二进制数据,由于我们用paInt16格式(16bit的short类型)保存采样值,因此将它自己转换为dtype为np.short的数组。

    '''
    以SAMPLING_RATE为采样频率,
    每次读入一块有NUM_SAMPLES个采样点的数据块,
    当读入的采样数据中有COUNT_NUM个值大于LEVEL的取样的时候,
    将采样数据保存进WAV文件,
    一旦开始保存数据,所保存的数据长度最短为SAVE_LENGTH个数据块。
     
    从声卡读入的数据和从WAV文件读入的类似,都是二进制数据,
    由于我们用paInt16格式(16bit的short类型)保存采样值,
    因此将它自己转换为dtype为np.short的数组。
    '''
     
     
    from pyaudio import PyAudio, paInt16
    import numpy as np
    import wave
     
    # 将data中的数据保存到名为filename的WAV文件中
    def save_wave_file(filename, data):
        wf = wave.open(filename, 'wb')
        wf.setnchannels(1)          # 单通道
        wf.setsampwidth(2)          # 量化位数
        wf.setframerate(SAMPLING_RATE)  # 设置采样频率
        wf.writeframes(b"".join(data))  # 写入语音帧
        wf.close()
     
     
    NUM_SAMPLES = 2000      # pyAudio内部缓存块的大小
    SAMPLING_RATE = 8000    # 取样频率
    LEVEL = 1500           # 声音保存的阈值,小于这个阈值不录
    COUNT_NUM = 20 # 缓存快类如果有20个大于阈值的取样则记录声音
    SAVE_LENGTH = 8 # 声音记录的最小长度:SAVE_LENGTH * NUM_SAMPLES 个取样
     
    # 开启声音输入
    pa = PyAudio()
    stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE, input=True,
                    frames_per_buffer=NUM_SAMPLES)
     
    save_count = 0  # 用来计数
    save_buffer = []    #
     
    while True:
        # 读入NUM_SAMPLES个取样
        string_audio_data = stream.read(NUM_SAMPLES)
        # 将读入的数据转换为数组
        audio_data = np.fromstring(string_audio_data, dtype=np.short)
        # 计算大于LEVEL的取样的个数
        large_sample_count = np.sum( audio_data > LEVEL )
        print(np.max(audio_data))
        # 如果个数大于COUNT_NUM,则至少保存SAVE_LENGTH个块
        if large_sample_count > COUNT_NUM:
            save_count = SAVE_LENGTH
        else:
            save_count -= 1
     
        if save_count < 0:
            save_count = 0
     
        if save_count > 0:
            # 将要保存的数据存放到save_buffer中
            save_buffer.append( string_audio_data )
        else:
            # 将save_buffer中的数据写入WAV文件,WAV文件的文件名是保存的时刻
            if len(save_buffer) > 0:
                filename = "recorde" + ".wav"
                save_wave_file(filename, save_buffer)
                print(filename, "saved")
                break
    

    MFCC特征提取

    import numpy as np
    import matplotlib.pyplot as plt
    from scipy.io import wavfile
    from python_speech_features import mfcc, logfbank
    
    # 读取输入音频文件
    sampling_freq, audio = wavfile.read("./audio/audio.wav")
    
    # 提取MFCC和滤波器组特征
    mfcc_features = mfcc(audio, sampling_freq)
    filterbank_features = logfbank(audio, sampling_freq)
    
    print('\nMFCC:\n窗口数 =', mfcc_features.shape[0])
    print('每个特征的长度 =', mfcc_features.shape[1])
    print('\nFilter bank:\n窗口数 =', filterbank_features.shape[0])
    print('每个特征的长度 =', filterbank_features.shape[1])
    
    # 画出特征图,将MFCC可视化。转置矩阵,使得时域是水平的
    mfcc_features = mfcc_features.T
    plt.matshow(mfcc_features)
    plt.title('MFCC')
    # 将滤波器组特征可视化。转置矩阵,使得时域是水平的
    filterbank_features = filterbank_features.T
    plt.matshow(filterbank_features)
    plt.title('Filter bank')
    
    plt.show()
    

    结果如下(因为输入的音频较大,故有点长。在传统的音频处理中,输入音频大多为短时音频,形状为矩形。感兴趣的可尝试输入不同的音频):
    在这里插入图片描述

    语谱图

    import wave
    import matplotlib.pyplot as plt
    import numpy as np
    
    f = wave.open('./audio/audio.wav', 'rb')
    params = f.getparams()
    nchannels, sampwidth, framerate, nframes = params[:4]
    strdata = f.readframes(nframes)
    wavedata = np.fromstring(strdata, dtype=np.int16)
    wavedata = wavedata * 1.0 / (max(abs(wavedata)))
    wavedata = np.reshape(wavedata, [nframes, nchannels]).T
    f.close()
    
    plt.specgram(wavedata[0], Fs=framerate, scale_by_freq=True, sides = 'default')
    plt.ylabel('Frequency(HZ)')
    plt.xlabel('Time(s)')
    plt.show()
    

    在这里插入图片描述

    语音识别

    如下是一个语音识别的实例

    import os
    import argparse
    import numpy as np
    from scipy.io import wavfile
    from hmmlearn import hmm
    from python_speech_features import mfcc
    
    # 解析命令行的输入参数
    def build_arg_parser():
        parser = argparse.ArgumentParser(description='Trains the HMM classifier')
        parser.add_argument( "--input-folder",dest="input_folder", required=True,
                help="Input folder containing the audio files in subfolders")
        return parser
    
    # 创建类,处理HMM相关过程
    class HMMTrainer(object):
        '''用到高斯隐马尔科夫模型
        n_components:定义了隐藏状态的个数
        cov_type:定义了转移矩阵的协方差类型
        n_iter:定义了训练的迭代次数
        '''
        def __init__(self, model_name='GaussianHMM', n_components=4, cov_type='diag', n_iter=1000):
            self.model_name = model_name
            self.n_components = n_components
            self.cov_type = cov_type
            self.n_iter = n_iter
            self.models = []
    
            if self.model_name == 'GaussianHMM':
                self.model = hmm.GaussianHMM(n_components=self.n_components,
                        covariance_type=self.cov_type, n_iter=self.n_iter)
            else:
                raise TypeError('Invalid model type')
    
        # X是二维数组,其中每一行有13个数
        def train(self, X):
            np.seterr(all='ignore')
            self.models.append(self.model.fit(X))
    
        # 对输入数据运行模型
        def get_score(self, input_data):
            return self.model.score(input_data)
    
    if __name__=='__main__':
        # 解析输入参数
        args = build_arg_parser().parse_args(['--input-folder', 'input_folder'])
        input_folder = args.input_folder
    
        hmm_models = [] # 初始化隐马尔科夫模型的变量
    
        # 解析输入路径
        for dirname in os.listdir(input_folder):
            # 获取子文件夹名称
            subfolder = os.path.join(input_folder, dirname)
            if not os.path.isdir(subfolder):
                continue
            # 子文件夹名称即为该类的标记
            # 提取特征
            label = subfolder[subfolder.rfind('/') + 1:]
    
            # 初始化变量
            X = np.array([])
            y_words = []
    
            # 迭代所有音频文件(分别保留一个进行测试)
            for filename in [x for x in os.listdir(subfolder) if x.endswith('.wav')][:-1]:
                # 读取每个音频文件
                filepath = os.path.join(subfolder, filename)
                sampling_freq, audio = wavfile.read(filepath)
    
                # 提取MFCC特征
                mfcc_features = mfcc(audio, sampling_freq)
    
                # 将MFCC特征添加到X变量
                if len(X) == 0:
                    X = mfcc_features
                else:
                    X = np.append(X, mfcc_features, axis=0)
    
    
                # 添加标记
                y_words.append(label)
    
            print('X.shape =', X.shape)
            # 训练并且保存HMM模型
            hmm_trainer = HMMTrainer()
            hmm_trainer.train(X)
            hmm_models.append((hmm_trainer, label))
    
            hmm_trainer = None
    
        # 测试文件
        input_files = [
                'data/pineapple/pineapple15.wav',
                'data/orange/orange15.wav',
                'data/apple/apple15.wav',
                'data/kiwi/kiwi15.wav'
                ]
    
        # 为输入数据分类
        for input_file in input_files:
            # 读取每个音频文件
            sampling_freq, audio = wavfile.read(input_file)
    
            # 提取MFCC特征
            mfcc_features = mfcc(audio, sampling_freq)
    
            # 定义变量
            max_score = 0
            output_label = None
            score_data = []
            # 迭代HMM模型并选取得分最高的模型
            for item in hmm_models:
                hmm_model, label = item
                score = hmm_model.get_score(mfcc_features)
                score_data.append(score)
                max_score = max(score_data)
            for item in hmm_models:
                hmm_model, label = item
                score = hmm_model.get_score(mfcc_features)
                if score >= max_score:
                    max_score = score
                    output_label = label
    
            # 打印结果
            print("\nTrue:", input_file[input_file.find('/')+1:input_file.rfind('/')])
            print("Predicted:", output_label)
    
    

    在这里插入图片描述

    信号分帧

    在这里插入图片描述

    wlen为帧长,inc 为帧移,重叠部分为overlap,overlap = wlen - inc

    信号帧数为:fn = (N - overlap) / inc = (N - wlen) / inc + 1

    N为语音数据长度。

    加窗

    通常对信号截断,分帧需要加窗,因为截断都有频域能量泄露,而窗函数可以减少截断带来的影响。窗函数再scipy.signal信号处理工具箱中。

    短时能量

    短时能量主要用于区分浊音段和清音段

    下面绘制未加窗,加窗,以及短时能量图:

    import numpy as np
    import wave
    import matplotlib.pyplot as plt
    import scipy.signal as signal
    
    wlen = 512  # 每一帧信号的长度
    inc = 128  #  帧移
    f = wave.open('./data/apple/apple01.wav', 'rb')
    params = f.getparams()
    nchannels, sampwidth, framerate, nframes = params[:4]  # 读取文件的参数并赋值-通道数,量化位数,采样频率,采样点数
    str_data = f.readframes(nframes)
    wave_data = np.fromstring(str_data, dtype=np.short)  # 处理采样点数的数据,将str型转为为short型
    wave_data = wave_data * 1.0 / (max(abs(wave_data)))  #  归一化处理
    
    time = np.arange(0, wlen) * (1.0 / framerate)
    
    signal_length = len(wave_data)  # 获取信号长度
    
    if signal_length <= wlen:
        nf = 1
    else :
        nf = int(np.ceil((1.0 * signal_length - wlen + inc) / inc))
    
    pad_length = int((nf - 1 ) * inc + wlen)
    zeros = np.zeros((pad_length - signal_length,))
    pad_signal = np.concatenate((wave_data, zeros))
    indices = np.tile(np.arange(0, wlen), (nf, 1)) + np.tile(np.arange(0, nf*inc, inc), (wlen, 1)).T
    
    indices = np.array(indices, dtype = np.int32)
    frames = pad_signal[indices]
    # 绘制第10-11帧的图像
    a = frames[10:11]
    # 使用汉明窗
    windown = np.hanning(wlen)
    b = a[0] * windown
    c = np.square(b)
    
    plt.figure(figsize=(10, 4))
    # 绘制未加窗的图
    plt.subplot(3, 1, 1)
    plt.plot(time, a[0], c='b')
    plt.xlabel("no-window")
    plt.grid()
    #  绘制增加汉明窗的图
    plt.subplot(3, 1, 2)
    plt.plot(time, b, c='g')
    plt.xlabel("hanning-window")
    plt.grid()
    #  绘制短时能量图
    plt.subplot(3, 1, 3)
    plt.plot(time, c, c='r')
    plt.xlabel("short-power")
    plt.grid()
    plt.show()
    

    在这里插入图片描述

    绘制第10-11帧的图像

    a = frames[10:11]

    使用汉明窗

    windown = np.hanning(wlen)
    b = a[0] * windown
    c = np.square(b)

    plt.figure(figsize=(10, 4))

    绘制未加窗的图

    plt.subplot(3, 1, 1)
    plt.plot(time, a[0], c=‘b’)
    plt.xlabel(“no-window”)
    plt.grid()

    绘制增加汉明窗的图

    plt.subplot(3, 1, 2)
    plt.plot(time, b, c=‘g’)
    plt.xlabel(“hanning-window”)
    plt.grid()

    绘制短时能量图

    plt.subplot(3, 1, 3)
    plt.plot(time, c, c=‘r’)
    plt.xlabel(“short-power”)
    plt.grid()
    plt.show()
    在这里插入图片描述

    展开全文
  • 利用Java实现DFT、FFT,读取WAV文件,并绘制波形图和频谱图,音频播放频谱或波形图实时显示效果。 使用及转载请标明出处(最好点个赞及star哈哈)代码放于末尾 几个工程打包于文件夹DFT_FFT: DFT_IDFT:计算前N点...

    DFT_FFT_drawWAV

    利用Java实现DFT、FFT,读取WAV文件,并绘制波形图和频谱图,音频播放频谱或波形图实时显示效果。

    使用及转载请标明出处(最好点个赞及star哈哈)代码放于末尾

    几个工程打包于文件夹DFT_FFT:

    1. DFT_IDFT:计算前N点DFT,并绘制波形图或频谱图;
    2. FFT:计算前N点FFT,并绘制波形图或频谱图,能播放WAV音乐,不过不能实时显示频谱或波形;
    3. FFT2_backup和FFT2_Finish:计算N点DFT或FFT,能播放WAV音频,且能实时显示波形或频谱,音频与波形或频谱不同步,需自己调节,但做不到十分精准。

    对WaveFileReader.java进行了修改,使之可以读取部分格式工厂转化的WAV文件。

    rawwavs:这是我用的一些WAV音乐文件,修改下代码中路径就可以直接运行使用。

    WAV文件解析参考以下链接:

    1. https://blog.csdn.net/imxiangzi/article/details/80265978
      注意,看了第1个链接你会发现很简单,而你也确实可以解析一些WAV文件了,但是还有许多是其它格式的。

    2. https://www.cnblogs.com/Free-Thinker/p/10489491.html

      img
      img

    主要就是参考第二个链接里的这两个图片修改的。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    码云链接
    GitHub链接

    展开全文
  • 绘制波形图,随时间向前不断移动,曲线可以另存为, 绘制动态曲线 数据采集 通讯
  • 绘制波形图控件

    2016-01-05 18:41:52
    基于D3D 9 sdk开发的2D图形显示控件,请将line.fx和exe放在一起,其中一个接口SetBuffer是传入坐标点数组的

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,995
精华内容 5,598
关键字:

如何绘制波形图