常用窗函数的C++实现

最新推荐文章于 2022-09-12 23:58:00 发布
最新推荐文章于 2022-09-12 23:58:00 发布
阅读量1.6k 收藏 17
点赞数 3
文章标签： c/c++ 操作系统 python
原文链接：https://my.oschina.net/zmjerry/blog/3673
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

头文件：

/*
 * Copyright (c) 2008-2011 Zhang Ming (M. Zhang), zmjerry@163.com
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 2 or any later version.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. A copy of the GNU General Public License is available at:
 * http://www.fsf.org/licensing/licenses
 */


/*****************************************************************************
 *                                 window.h
 *
 * This file includes seven usually used windows in signal processing:
 *      Rectangle        Bartlett        Hanning     Hamming
 *      Blackman         Kaiser          Gauss
 * All of them are same to those in "Matlab".
 *
 * Zhang Ming, 2010-01, Xi'an Jiaotong University.
 *****************************************************************************/


#ifndef WINDOW_H
#define WINDOW_H


#include <vector.h>


namespace splab
{

    template<typename Type> Vector<Type> window( const string&, int, Type );
	template<typename Type> Vector<Type> window( const string&, int,
                                                 Type, Type );

    template<typename Type> Vector<Type> rectangle( int, Type );
    template<typename Type> Vector<Type> bartlett( int, Type );
    template<typename Type> Vector<Type> hanning( int, Type );
    template<typename Type> Vector<Type> hamming( int, Type );
    template<typename Type> Vector<Type> blackman( int, Type );
    template<typename Type> Vector<Type> kaiser( int, Type, Type );
    template<typename Type> Vector<Type> gauss( int, Type, Type );

	template<typename Type> Type I0( Type alpha );


	#include <window-impl.h>

}
// namespace splab


#endif
// WINDOW_H

 实现文件：

/*
 * Copyright (c) 2008-2011 Zhang Ming (M. Zhang), zmjerry@163.com
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 2 or any later version.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. A copy of the GNU General Public License is available at:
 * http://www.fsf.org/licensing/licenses
 */


/*****************************************************************************
 *                                 window.h
 *
 * Implementation for window function.
 *
 * Zhang Ming, 2010-01, Xi'an Jiaotong University.
 *****************************************************************************/


/**
 * Get the specified window.
 */
template <typename Type>
Vector<Type> window( const string &wnName, int N, Type amp )
{
    if( wnName == "Rectangle" )
        return rectangle( N, amp );
    else if( wnName == "Bartlett" )
        return bartlett( N, amp );
    else if( wnName == "Hanning" )
        return hanning( N, amp );
    else if( wnName == "Hamming" )
        return hamming( N, amp );
    else if( wnName == "Blackman" )
        return blackman( N, amp );
    else
    {
        cerr << "No such type window!" << endl;
        return Vector<Type> (0);
    }
}

template <typename Type>
Vector<Type> window( const string &wnName, int N, Type alpha, Type amp )
{
    if( wnName=="Kaiser" )
        return kaiser( N, alpha, amp );
    else if( wnName=="Gauss" )
        return gauss( N, alpha, amp );
    else
    {
        cerr << "No such type window!" << endl;
        return Vector<Type> (0);
    }
}


/**
 * Calculates rectangle window coefficients.
 */
template <typename Type>
Vector<Type> rectangle( int N, Type amp )
{
    Vector<Type> win(N);

    for( int i=0; i<(N+1)/2; ++i )
    {
        win[i] = amp;
        win[N-1-i] = win[i];
    }

    return win;
}


/**
 * Calculates bartlett window coefficients.
 */
template <typename Type>
Vector<Type> bartlett( int N, Type amp )
{
    Vector<Type> win(N);

    for( int i=0; i<(N+1)/2; ++i )
    {
        win[i] = amp*2*i / (N-1);
        win[N-1-i] = win[i];
    }

    return win;
}


/**
 * Calculates hanning window coefficients.
 */
template <typename Type>
Vector<Type> hanning( int N, Type amp )
{
   Vector<Type> win(N);

    for( int i=0; i<(N+1)/2; ++i )
    {
        win[i] = amp * Type( 0.5 - 0.5*cos(TWOPI*i/(N-1)) );
        win[N-1-i] = win[i];
    }

    return win;
}


/**
 * Calculates hamming window coefficients.
 */
template <typename Type>
Vector<Type> hamming( int N, Type amp )
{
    Vector<Type> win(N);

    for( int i=0; i<(N+1)/2; ++i )
    {
        win[i] = amp * Type( 0.54 - 0.46*cos(TWOPI*i/(N-1.0)) );
        win[N-1-i] = win[i];
    }

    return win;
}


/**
 * Calculates hamming window coefficients.
 */
template <typename Type>
Vector<Type> blackman( int N, Type amp )
{
    Vector<Type> win(N);

    for( int i=0; i<(N+1)/2; ++i )
    {
        win[i] = amp * Type ( 0.42 - 0.50*cos(TWOPI*i/(N-1.0))
                              + 0.08*cos(2*TWOPI*i/(N-1.0)) );
        win[N-1-i] = win[i];
    }

    return win;
}


/**
 * Calculates hamming window coefficients.
 */
template <typename Type>
Vector<Type> kaiser( int N, Type alpha, Type amp )
{
    Vector<Type> win(N);

    for( int i=0; i<(N+1)/2; ++i )
    {
        Type beta = 2*alpha * Type( sqrt(i*(N-i-1.0))/(N-1.0) );
        win[i] = amp * I0(beta) / I0(alpha);
        win[N-1-i] = win[i];
    }

    return win;
}


/**
 * Calculates gauss window coefficients. "Alpha: is a optional parameter,
 * the default value is 2.5.
 */
template <typename Type>
Vector<Type> gauss( int N, Type alpha, Type amp )
{
    Vector<Type> win(N);
    Type center = (N-1)/Type(2);

    for( int i=0; i<(N+1)/2; ++i )
    {
        Type tmp = alpha*(i-center) / center;
        win[i] = amp * Type( exp(-0.5*tmp*tmp ) );
        win[N-1-i] = win[i];
    }

    return win;
}


/**
 * The zeroth N modified Bessel function of the first kind.
 */
template <typename Type>
Type I0( Type alpha )
{
    double  J = 1.0,
            K = alpha / 2.0,
            iOld = 1.0,
            iNew;
    bool    converge = false;

    // Use series expansion definition of Bessel.
    for( int i=1; i<MAXTERM; ++i )
    {
        J *= K/i;
        iNew = iOld + J*J;

        if( (iNew-iOld) < EPS )
        {
            converge = true;
            break;
        }
        iOld = iNew;
    }

    if( !converge )
        return Type(0);

    return Type(iNew);
}

测试代码：

/*****************************************************************************
 *                               window_test.cpp
 *
 * Windows function testing.
 *
 * Zhang Ming, 2010-01, Xi'an Jiaotong University.
 *****************************************************************************/


#define BOUNDS_CHECK

#include <iostream>
#include <iomanip>
#include <window.h>


using namespace std;
using namespace splab;


typedef double  Type;


int main()
{
    int N = 5;
    Type A = 1.0;

    cout << setiosflags(ios::fixed) << setprecision(4);
    cout << "Rectangle window : " << rectangle(N,A) << endl;
    cout << "Bartlett window : " << bartlett(N,A) << endl;
    cout << "Hanning window : " << hanning(N,A) << endl;
    cout << "Hamming window : " << hamming(N,A) << endl;
    cout << "Blackman window : " << blackman(N,A) << endl;
    cout << "Kaiser window : " << kaiser(N,Type(8/PI),A) << endl;
    cout << "Gauss window : " << gauss(N,Type(2.5),A) << endl;

    cout << "Rectangle window : " << window("Rectangle",N,A) << endl;
    cout << "Bartlett window : " << window("Bartlett",N,A) << endl;
    cout << "Hanning window : " << window("Hanning",N,A) << endl;
    cout << "Hamming window : " << window("Hamming",N,A) << endl;
    cout << "Blackman window : " << window("Blackman",N,A) << endl;
    cout << "Kaiser window : " << window("Kaiser",N, Type(8/PI),A) << endl;
    cout << "Gauss window : " << window("Gauss",N,Type(2.5),A) << endl;

    return 0;
}

运行结果：

Rectangle window : size: 5 by 1
1.0000
1.0000
1.0000
1.0000
1.0000

Bartlett window : size: 5 by 1
0.0000
0.5000
1.0000
0.5000
0.0000

Hanning window : size: 5 by 1
0.0000
0.5000
1.0000
0.5000
0.0000

Hamming window : size: 5 by 1
0.0800
0.5400
1.0000
0.5400
0.0800

Blackman window : size: 5 by 1
-0.0000
0.3400
1.0000
0.3400
-0.0000

Kaiser window : size: 5 by 1
0.2933
0.7742
1.0000
0.7742
0.2933

Gauss window : size: 5 by 1
0.0439
0.4578
1.0000
0.4578
0.0439

Rectangle window : size: 5 by 1
1.0000
1.0000
1.0000
1.0000
1.0000

Bartlett window : size: 5 by 1
0.0000
0.5000
1.0000
0.5000
0.0000

Hanning window : size: 5 by 1
0.0000
0.5000
1.0000
0.5000
0.0000

Hamming window : size: 5 by 1
0.0800
0.5400
1.0000
0.5400
0.0800

Blackman window : size: 5 by 1
-0.0000
0.3400
1.0000
0.3400
-0.0000

Kaiser window : size: 5 by 1
0.2933
0.7742
1.0000
0.7742
0.2933

Gauss window : size: 5 by 1
0.0439
0.4578
1.0000
0.4578
0.0439


Process returned 0 (0x0)   execution time : 0.140 s
Press any key to continue.

转载于:https://my.oschina.net/zmjerry/blog/3673

weixin_34044273
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用C++建立一个窗口
weixin_30613343的博客
04-15 2515
如何用C++建立一个窗口，对于一个新手来说还是比较复杂的，今天就简单给大家介绍如何在空项目下建立一个窗口： #include "windows.h" //6、处理消息（窗口过程） //CALLBACK代表__stdcall参数传递顺序 从右往左依次入栈，并且在函数返回前自动清空堆栈内容 LRESULT CALLBACK WindowProc( H...
C++实用函数
扬弃
12-03 202
C++实用函数 lower_bound 用法：lower_bound(起始位置，结束位置，数值val) 作用：返回区间中第一个大于或等于val的元素地址 注意点： 1. 区间是左闭右开 2. 前提是有序数组(或者这一区间有序) 3. 如果所有元素都小于val，则返回结束地址(越界) //找到数组中第一个大于或等于10的元素下标 int m = lower_bound(s.begin(), s.end(), 10) - s.begin(); upper_bound 用法：upper_bound(起始
常见窗函数C 实现
xinshuwei的博客
09-12 1504
在信号处理中，我们通常对信号进行截断分析，如果信号截断为非周期截断，那么频谱将发生泄露。通过加窗，可以减少频谱的泄露。我们可以这么想象，窗函数可以将一个非周期的信号，强行变成一个周期的信号。
Blackman 窗函数
Sparkling_Y的博客
07-07 1万+
Blackman 窗函数 由于计算机无法对无限长的信号进行FFT运算，所以我们截取有限长序列进行分析，但这种做法会产生频谱能量泄露。采用窗函数来截取信号能够减少频谱能量泄露，不同的窗函数会对频谱泄露产生不同的抑制效果。其中，余弦窗具有良好的旁瓣特性和简单的表达形式，这里介绍Blackman余弦窗函数。 特性： 主瓣宽且幅值大 旁瓣宽度小 衰减速度快 时域表达式: w(n)=0.42−0.5cos(2πn/N)+0.08(4πn/N)w(n) = 0.42 - 0.5cos(2\pi n/N) + 0
Matlab kaiser窗 C++实现
黄笳倞的博客
03-20 8829
Kaiser窗 此种窗是一种应用广泛的可调节窗，它可以通过改变窗函数的形状来控制窗函数旁瓣的大小，从而在设计中可用滤波器的衰减指标来确定窗函数的形状。长度为N的Kaiser窗定义为（=） 其中是一个可调参数，可以通过改变的值来调整窗函数的形状，从而达到不同的阻带衰减要求。上式中的是零阶第一类修正贝塞尔函数。可用幂级数表示为 对于任意的一个实变量x，函数的值都是正的。在实际计算中，上式...
学习C/C++第十四天 接昨天的课程
w707577314的博客
12-11 144
#define _CRTDBG_MAP_ALLOC #include <crtdbg.h> #include <stdlib.h> #include <stdio.h> #include <iostream> #include <Windows.h> #ifdef _DEBUG #ifndef DBG_NEW #defi...
SAR信号处理之窗函数9——凯泽（Kaiser）窗
热门推荐
smyounger的博客
03-28 1万+
Kaiser窗
【OpenCV4】C++ 创建二维汉宁窗 Hann Window / Hanning Window
AItrust的博客
08-04 1875
代码】【OpenCV4】创建二维汉宁窗 Hann Window / Hanning Window。
c++ 实现matlab smooth 函数
11-12
C++ 实现 Matlab Smooth 函数 C++ 平滑一维数组数据的实现是基于 Matlab 的 smooth 函数原理。Smooth 函数是一种常用的 signal 处理技术，用于减少信号中的噪声和波动。Matlab 提供了 smooth 函数来实现该功能，而...
matlab smooth函数C++实现_c++smooth函数_smoothC++_smooth_C++_smoothmatl
09-11
C++实现的移动平均平滑算法相比于Matlab的`smooth`函数，可能存在性能上的优势，因为C++是编译型语言，运行速度通常更快。但同时，C++的实现可能需要更多的代码管理和调试工作。因此，在选择使用哪种语言实现数据...
汉明Hamming编码(计算机网络)C++代码实现
04-27
本代码实现了汉明编码的具体实现过程，其中有详细的代码注释，能够帮助大家更好的理解实现的方法，帮助大家理解hammingCode
hanning.rar_c窗函数_hanning_hanning c语言_窗函数 C++_窗函数c
07-15
用C语言编写的加窗函数， hanning窗，实现信号的加窗
25种数字信号处理c++程序涉及到各种算法
05-15
25种数字信号处理c++程序涉及到各种算法如：离散傅里叶 实序数快速傅里叶 切比雪夫法 窗函数法等等
窗函数的实现及分析（4中窗函数源程序）
01-10
矩形窗，汉宁窗，海明窗，布莱克曼窗，4中窗函数源程序，课设
高斯窗滤波实例
01-09
可选 6、8、12阶三种不同的高斯窗函数实现对离散采样点的滤波 广泛应用于各种功率衰减滤波，程序中还提供了离散数据的稠密程度的控制 刚开始学习 MFC，整理了点算法笔记 斑驳敬上
C++ 实现银行排队服务模拟
06-19
本文将详细介绍 C++ 实现银行排队服务模拟的知识点，主要包括 OOP 编程思想、std::rand() 函数原理、概率编程、排队理论、链式队列数据结构及其模板实现、事件驱动的设计、蒙特卡洛方法、C++ 动态内存管理和设计理念...
毕业设计-FIR窗函数法C++实现音频均衡器-音频滤波
05-13
在本项目中，"毕业设计-FIR窗函数法C++实现音频均衡器-音频滤波"，我们将探讨几个核心的IT知识点，主要集中在音频处理、编程语言C++以及信号处理技术上。首先，我们来看看涉及的主要概念： 1. **C++编程**：作为...
基于C++实现卷积神经网络
10-14
在C++实现CNN时，你需要了解以下关键技术点： 1. 数据预处理：C++中处理图像数据前，需要进行归一化、裁剪、灰度化等预处理步骤，确保数据适合输入神经网络。 2. 数组和矩阵操作库：为了进行高效的数值计算，可以...
SAR信号处理之窗函数8——布莱克曼（Blackman）窗
smyounger的博客
03-26 1万+
Blackman窗的定义如下 其中n=1,2,⋯,N-1 ，N 表示窗函数的总长度，M 表示窗函数的有效长度。Blackman窗的形状如下图所示。 理想sinc函数被Blackman窗加权后，结果如下图所示，可以看出，加Blackman窗，分辨率展宽1.85倍，峰值旁瓣比约为-58.1dB，积分旁瓣比约为-57.2dB。 上图所示脉冲函数的部分指标如下 分辨率： 1.8517 峰值旁瓣比：-58....
切比雪夫窗函数c++
最新发布
12-08
切比雪夫窗函数是一种在信号处理中常用的窗函数之一。它的主要作用是在频谱分析和滤波器设计中用来限制频域波形泄露和减小频谱主瓣宽度。 切比雪夫窗函数的特点在于它的频谱主瓣具有较尖锐的下降特性，可以有效地减小频域泄露。这对于需要精确频谱分析的情况非常有用。同时，切比雪夫窗函数在一定频率范围内具有相对较小的副瓣幅度，这也是它在滤波器设计中的重要应用之一。 切比雪夫窗函数的数学表达式是一个余弦函数的组合，通过调节窗口的参数可以得到不同形状的窗口函数。在实际应用中，可以根据具体的需求选择合适的窗口参数来实现不同的频谱分析和滤波效果。 总的来说，切比雪夫窗函数可以通过控制频谱主瓣的锐度和副瓣的幅度来满足不同信号处理需求，是一种非常实用的窗口函数。在实际应用中，设计者需要根据具体的信号特性和要求来选择合适的窗口参数，以达到最佳的信号处理效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值