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