spectral.h

Go to the documentation of this file.

//=============================================================================================================
#ifndef SPECTRAL_H
#define SPECTRAL_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "utils_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 UTILSSHARED_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);
 
//    //=========================================================================================================
//    /**
//     * Calculates the full tapered spectra of a given input matrix data. This function calculates each row in parallel.
//     *
//     * @param[in] matData         input matrix data (time domain), for which the spectrum is computed.
//     * @param[in] matTaper        tapers used to compute the spectra.
//     * @param[in] iNfft           FFT length.
//     * @param[in] bUseThreads Whether to use multiple threads.
//     *
//     * @return tapered spectra of the input data.
//     */
//    static std::vector<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);
 
//    //=========================================================================================================
//    /**
//     * Reduces the taperedSpectra results to a final result. This function gets called in parallel.
//     *
//     * @param[out] finalData    The final data data.
//     * @param[in] resultData   The resulting data from the computation step.
//     */
//    static void reduce(std::vector<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