spectral.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef SPECTRAL_H
#define SPECTRAL_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "math_global.h"
 
#include <vector>
#include <utility>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QString>
#include <QPair>
#include <QSharedPointer>
 
//=============================================================================================================
// DEFINE NAMESPACE UTILSLIB
//=============================================================================================================
 
namespace UTILSLIB
{

struct TaperedSpectraInputData
{
    Eigen::RowVectorXd vecData;
    Eigen::MatrixXd matTaper;
    int iNfft;
};
 
//=============================================================================================================
class MATHSHARED_EXPORT Spectral
{
public:
    //=========================================================================================================
    Spectral() = delete;
 
    //=========================================================================================================
    static Eigen::MatrixXcd computeTaperedSpectraRow(const Eigen::RowVectorXd& vecData,
                                                     const Eigen::MatrixXd& matTaper,
                                                     int iNfft);
 
    //=========================================================================================================
    static QVector<Eigen::MatrixXcd> computeTaperedSpectraMatrix(const Eigen::MatrixXd& matData,
                                                                 const Eigen::MatrixXd& matTaper,
                                                                 int iNfft,
                                                                 bool bUseThreads = true);
 
    //=========================================================================================================
    static Eigen::MatrixXcd compute(const TaperedSpectraInputData& inputData);
 
    //=========================================================================================================
    static void reduce(QVector<Eigen::MatrixXcd>& finalData,
                       const Eigen::MatrixXcd& resultData);
 
    //=========================================================================================================
    static Eigen::RowVectorXd psdFromTaperedSpectra(const Eigen::MatrixXcd& matTapSpectrum,
                                                    const Eigen::VectorXd& vecTapWeights,
                                                    int iNfft,
                                                    double dSampFreq = 1.0);
 
    //=========================================================================================================
    static Eigen::RowVectorXcd csdFromTaperedSpectra(const Eigen::MatrixXcd& vecTapSpectrumSeed,
                                                     const Eigen::MatrixXcd& vecTapSpectrumTarget,
                                                     const Eigen::VectorXd& vecTapWeightsSeed,
                                                     const Eigen::VectorXd& vecTapWeightsTarget,
                                                     int iNfft,
                                                     double dSampFreq = 1.0);
 
    //=========================================================================================================
    static Eigen::VectorXd calculateFFTFreqs(int iNfft, double dSampFreq);
 
    //=========================================================================================================
    static QPair<Eigen::MatrixXd, Eigen::VectorXd> generateTapers(int iSignalLength,
                                                                  const QString& sWindowType = "hanning");
 
    //=========================================================================================================
    static std::pair<Eigen::MatrixXd, Eigen::VectorXd> generateTapers(int iSignalLength,
                                                                      const std::string& sWindowType = "hanning");
 
private:
    //=========================================================================================================
    static Eigen::MatrixXd hanningWindow(int iSignalLength);
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
} //namespace
 
#endif // SPECTRAL_H