Skip to content

GitLab

ITABase
ITABase
Commit 29c5bb02 authored by Dipl.-Ing. Jonas Stienen's avatar Dipl.-Ing. Jonas Stienen
Browse files
Options

Introducing ITABaser namespace, starting with data classes

parent 6dc041dc
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 642 additions and 602 deletions
include/ITAConstants.h
View file @ 29c5bb02
......@@ -24,8 +24,9 @@
// STL
#include <cmath>
#include <numeric>
#include <limits>
#include <numeric>
#include <vector>
namespace ITAConstants
{
......@@ -58,6 +59,12 @@ namespace ITAConstants
static float MINUS_INFINITY_F = -std::numeric_limits< float >::infinity();
static double INFINITY_D = std::numeric_limits< double >::infinity();
static double MINUS_INFINITY_D = -std::numeric_limits< double >::infinity();
static std::vector< float > THIRD_OCTAVE_CENTER_FREQUENCIES_ISO_F = { 20, 25, 31.5f, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000, 12500, 16000, 20000 };
static std::vector< double > THIRD_OCTAVE_CENTER_FREQUENCIES_ISO_D = { 20, 25, 31.5f, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000, 12500, 16000, 20000 };
static std::vector< float > OCTAVE_CENTER_FREQUENCIES_ISO_F = { 31.5f, 63, 125, 250, 500, 1000, 2000, 4000, 8000, 16000 };
static std::vector< double > OCTAVE_CENTER_FREQUENCIES_ISO_D = { 31.5f, 63, 125, 250, 500, 1000, 2000, 4000, 8000, 16000 };
};
#endif // INCLUDE_WATCHER_ITA_CONSTANTS
include/ITAFiniteImpulseResponse.h
View file @ 29c5bb02
......@@ -25,62 +25,67 @@
#include <string>
//! Single channel finite impulse response class / FIR filter
/**
* ITASampleBuffer with a sampling rate = finite impulse response.
* For multi channel FIR filter, @sa ITAMultichannelFiniteImpulseResponse
*/
class ITA_BASE_API CITAFiniteImpulseResponse : public ITASampleBuffer
namespace ITABase
{
public:
//! Create empty FIR filter
/**
* Requires initialization to be used, otherwise methods will throw ITAException.
*/
CITAFiniteImpulseResponse();
//! Create FIR filter of certain size with given sampling frequency
//! Single channel finite impulse response class / FIR filter
/**
* \param iLength Length (size) of buffer in samples
* ITASampleBuffer with a sampling rate = finite impulse response.
* For multi channel FIR filter, @sa ITAMultichannelFiniteImpulseResponse
*/
explicit CITAFiniteImpulseResponse( const int iLength, const float fSampleRate, const bool bZeroInit = true );
class ITA_BASE_API CFiniteImpulseResponse : public ITASampleBuffer
{
public:
//! Create empty FIR filter
/**
* Requires initialization to be used, otherwise methods will throw ITAException.
*/
CFiniteImpulseResponse();
//! Copy constructor as pointer
/**
* \param pSource Pointer to source buffer
*/
CITAFiniteImpulseResponse( const CITAFiniteImpulseResponse* pSource );
//! Create FIR filter of certain size with given sampling frequency
/**
* \param iLength Length (size) of buffer in samples
*/
explicit CFiniteImpulseResponse( const int iLength, const float fSampleRate, const bool bZeroInit = true );
//! Copy constructor as reference
/**
* \param pbSource Reference to source buffer
*/
CITAFiniteImpulseResponse( const CITAFiniteImpulseResponse& sbSource );
//! Copy constructor as pointer
/**
* \param pSource Pointer to source buffer
*/
CFiniteImpulseResponse( const CFiniteImpulseResponse* pSource );
virtual inline ~CITAFiniteImpulseResponse() {};
//! Copy constructor as reference
/**
* \param pbSource Reference to source buffer
*/
CFiniteImpulseResponse( const CFiniteImpulseResponse& sbSource );
//! Sampling frequency of FIR filter (double of Nyquist frequency)
float GetSampleRate() const;
virtual inline ~CFiniteImpulseResponse() {};
//! Nyquist frequency of FIR filter (half of sample rate)
float GetNyquistFrequency() const;
//! Sampling frequency of FIR filter (double of Nyquist frequency)
float GetSampleRate() const;
//! Nyquist frequency of FIR filter (half of sample rate)
float GetNyquistFrequency() const;
//! Initialize
/**
* (Re-)Initialize a sample buffer
*
* @param[in] iLength Number of new samples
* @param[in] fSampleRate Sampling rate of FIR filter (double of Nyquist frequency)
* @param[in] bZeroInit Init with zeros
*/
void Init( const int iLength, const float fSampleRate, const bool bZeroInit = true );
//! Initialize
/**
* (Re-)Initialize a sample buffer
*
* @param[in] iLength Number of new samples
* @param[in] fSampleRate Sampling rate of FIR filter (double of Nyquist frequency)
* @param[in] bZeroInit Init with zeros
*/
void Init( const int iLength, const float fSampleRate, const bool bZeroInit = true );
private:
//! Disable this Init method from sample buffer
void Init( int, bool );
private:
//! Disable this Init method from sample buffer
void Init( int, bool );
float m_fSampleRate; //!< Sampling rate
};
float m_fSampleRate; //!< Sampling rate
};
}
#endif // INCLUDE_WATCHER_ITA_FINITE_IMPULSE_RESPONSE
include/ITAHDFTSpectra.h
View file @ 29c5bb02
......@@ -26,84 +26,89 @@
// STL includes
#include <vector>
class ITAHDFTSpectrum;
//! Multi-channel half-sided discrete fourier spectra
/**
*
* This class describes DFT spectrum data with variable number channels
* and provides functionality for manipulation and math operations.
*
* This class extends the \ITAHDFTSpectrum for multi-channel applications.
*
*/
class ITA_BASE_API ITAHDFTSpectra
namespace ITABase
{
public:
//! Constructor that initializes the
ITAHDFTSpectra( const float fSampleRate, const int iNumChannels, const int iDFTSize, const bool bZeroInit=true );
class CHDFTSpectrum;
//! Constructor that uses a non-empty HDFTSpectrum vector
ITAHDFTSpectra( const std::vector< ITAHDFTSpectrum* >& vpSpectrumVec );
//! Standard destructor
~ITAHDFTSpectra();
//! Return number of channels
//! Multi-channel half-sided discrete fourier spectra
/**
* \return Number of spectra / dimension of filter
*
* This class describes DFT spectrum data with variable number channels
* and provides functionality for manipulation and math operations.
*
* This class extends the \ITAHDFTSpectrum for multi-channel applications.
*
*/
int GetNumChannels() const;
class ITA_BASE_API CHDFTSpectra
{
public:
//! Return DFT size
/**
* \return Number of coeffs + 1 for DC value
*/
int GetDFTSize() const;
//! Constructor that initializes the
CHDFTSpectra( const float fSampleRate, const int iNumChannels, const int iDFTSize, const bool bZeroInit = true );
//! Constructor that uses a non-empty HDFTSpectrum vector
CHDFTSpectra( const std::vector< CHDFTSpectrum* >& vpSpectrumVec );
//! Standard destructor
~CHDFTSpectra();
//! Return number of channels
/**
* \return Number of spectra / dimension of filter
*/
int GetNumChannels() const;
//! Return DFT size
/**
* \return Number of coeffs + 1 for DC value
*/
int GetDFTSize() const;
//! Return sampling rate
double GetSampleRate() const;
//! Return sampling rate
double GetSampleRate() const;
//! Adds the given spectra channel-wise
void add( const CHDFTSpectra* );
//! Adds the given spectra channel-wise
void add( const ITAHDFTSpectra* );
//! Subtracts the given spectra channel-wise
void sub( const CHDFTSpectra* );
//! Subtracts the given spectra channel-wise
void sub( const ITAHDFTSpectra* );
//! Multiplies the given spectra channel-wise
void mul( const CHDFTSpectra* );
//! Multiplies the given spectra channel-wise
void mul( const ITAHDFTSpectra* );
//! Multiplies the conjugate of the given spectra without data copy channel-wise
void mul_conj( const CHDFTSpectra* );
//! Multiplies the conjugate of the given spectra without data copy channel-wise
void mul_conj( const ITAHDFTSpectra* );
//! Multiplies a scalar
void mul_scalar( double );
//! Multiplies a scalar
void mul_scalar( double );
//! Divides the given spectra channel-wise
void div( const CHDFTSpectra* );
//! Divides the given spectra channel-wise
void div( const ITAHDFTSpectra* );
//! Set unity (all coefficiants real one)
void SetUnity();
//! Set unity (all coefficiants real one)
void SetUnity();
//! Set unity (all coefficiants real one)
void SetZero();
//! Set unity (all coefficiants real one)
void SetZero();
//! Copy from another Spectra
void CopyFrom( const CHDFTSpectra* otherSpectra );
//! Copy from another Spectra
void CopyFrom(const ITAHDFTSpectra* otherSpectra);
//! Returns maximum energy from all spectra
float GetMaxEnergy( int* piChannelIndex = nullptr ) const;
//! Returns maximum energy from all spectra
float GetMaxEnergy( int* piChannelIndex = nullptr ) const;
//! Subscript operator gives direct access to spectrum channel
const CHDFTSpectrum* operator[]( const int ) const;
CHDFTSpectrum* operator[]( const int );
//! Subscript operator gives direct access to spectrum channel
const ITAHDFTSpectrum* operator[]( const int ) const;
ITAHDFTSpectrum* operator[]( const int );
private:
//! Standard constructor
CHDFTSpectra();
private:
//! Standard constructor
ITAHDFTSpectra();
std::vector< CHDFTSpectrum* > m_vpSpectra; //! DFT spectra
};
std::vector< ITAHDFTSpectrum* > m_vpSpectra; //! DFT spectra
};
}
#endif // INCLUDE_WATCHER_ITA_HDFT_SPECTRA
include/ITAHDFTSpectrum.h
View file @ 29c5bb02
This diff is collapsed.
include/ITAMagnitudeSpectrum.h
View file @ 29c5bb02
......@@ -22,76 +22,81 @@
#include <ITABaseDefinitions.h>
#include <ITASpectrum.h>
// Forward for aliasing classes
class CITAGainMagnitudeSpectrum;
//! A factor magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed.
/**
* This alias class is used to give the user a hint that the underlying data should be treated as linear values (factors)
* or gains, because a magnitude spectrum does not specify on that. It is used like a CITAMagnitudeSpectrum.
* There is no real difference between a factor and a gain except that gains are commonly used in DSP (i.e. for "gain" control
* of audio signal channels) and factors are more common in acoustic materials such as absorption and transmission "factor".
*/
typedef CITAGainMagnitudeSpectrum CITAFactorMagnitudeSpectrum;
//! Magnitude spectrum of arbitrary size and base frequencies
/**
* Implementation class for magnitude spectra, that does not specify on underlying data. To be more precise in your code and
* for validation of data it is recommended to use the alias classes CITADecibelMagnitudeSpectrum, CITAGainMagnitudeSpectrum or CITAFactorMagnitudeSpectrum,
* which implement the abstract methods and are ready to use.
*
* Will raise CITAException on errors.
*
* @sa CITAThirdOctaveSpectrum, CITAPhaseSpectrum, CITAHDFTSpectrum
*
*/
class ITA_BASE_API CITAMagnitudeSpectrum : public CITASpectrum
namespace ITABase
{
public:
CITAMagnitudeSpectrum( const int nNumBands );
virtual inline ~CITAMagnitudeSpectrum() {};
std::vector< float > GetMagnitudesCopy() const;
const std::vector< float >& GetMagnitudes() const;
void SetMagnitudes( const std::vector< float >& vfMagnitudes );
void SetMagnitude( const int iFrequencyBandIndex, const float fMagnitudeValue );
bool CompareEqualValues( const CITAMagnitudeSpectrum& oOtherSpectrum, const float fThreshold = 10.0e-10 ) const;
};
//! A decibel magnitude spectrum with values that have been transformed into logarithmic scale. Values are mostly between -\infinity and 0, but can also exceed.
/**
* This alias class is used to give the user a hint that the underlying data should be treated as decibel values (log scale),
* because a magnitude spectrum does not specify on that. It is used like a CITAMagnitudeSpectrum.
*/
class ITA_BASE_API CITADecibelMagnitudeSpectrum : public CITAMagnitudeSpectrum
{
public:
CITADecibelMagnitudeSpectrum( const int nNumBands );
virtual ~CITADecibelMagnitudeSpectrum();
void SetIdentity();
void SetZero();
bool IsIdentity() const;
bool IsZero() const;
};
//! A gain magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed.
/**
* @sa CITAFactorMagnitudeSpectrum
*/
class ITA_BASE_API CITAGainMagnitudeSpectrum : public CITAMagnitudeSpectrum
{
public:
CITAGainMagnitudeSpectrum( const int nNumBands );
virtual ~CITAGainMagnitudeSpectrum();
void SetIdentity();
void SetZero();
bool IsIdentity() const;
bool IsZero() const;
};
// Forward for aliasing classes
class CGainMagnitudeSpectrum;
//! A factor magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed.
/**
* This alias class is used to give the user a hint that the underlying data should be treated as linear values (factors)
* or gains, because a magnitude spectrum does not specify on that. It is used like a CITAMagnitudeSpectrum.
* There is no real difference between a factor and a gain except that gains are commonly used in DSP (i.e. for "gain" control
* of audio signal channels) and factors are more common in acoustic materials such as absorption and transmission "factor".
*/
typedef CGainMagnitudeSpectrum CFactorMagnitudeSpectrum;
//! Magnitude spectrum of arbitrary size and base frequencies
/**
* Implementation class for magnitude spectra, that does not specify on underlying data. To be more precise in your code and
* for validation of data it is recommended to use the alias classes CITADecibelMagnitudeSpectrum, CITAGainMagnitudeSpectrum or CITAFactorMagnitudeSpectrum,
* which implement the abstract methods and are ready to use.
*
* Will raise CITAException on errors.
*
* @sa CITAThirdOctaveSpectrum, CITAPhaseSpectrum, CITAHDFTSpectrum
*
*/
class ITA_BASE_API CMagnitudeSpectrum : public CITASpectrum
{
public:
CMagnitudeSpectrum( const int nNumBands );
virtual inline ~CMagnitudeSpectrum() {};
std::vector< float > GetMagnitudesCopy() const;
const std::vector< float >& GetMagnitudes() const;
void SetMagnitudes( const std::vector< float >& vfMagnitudes );
void SetMagnitude( const int iFrequencyBandIndex, const float fMagnitudeValue );
bool CompareEqualValues( const CMagnitudeSpectrum& oOtherSpectrum, const float fThreshold = 10.0e-10 ) const;
};
//! A decibel magnitude spectrum with values that have been transformed into logarithmic scale. Values are mostly between -\infinity and 0, but can also exceed.
/**
* This alias class is used to give the user a hint that the underlying data should be treated as decibel values (log scale),
* because a magnitude spectrum does not specify on that. It is used like a CITAMagnitudeSpectrum.
*/
class ITA_BASE_API CDecibelMagnitudeSpectrum : public CMagnitudeSpectrum
{
public:
CDecibelMagnitudeSpectrum( const int nNumBands );
virtual ~CDecibelMagnitudeSpectrum();
void SetIdentity();
void SetZero();
bool IsIdentity() const;
bool IsZero() const;
};
//! A gain magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed.
/**
* @sa CITAFactorMagnitudeSpectrum
*/
class ITA_BASE_API CGainMagnitudeSpectrum : public CMagnitudeSpectrum
{
public:
CGainMagnitudeSpectrum( const int nNumBands );
virtual ~CGainMagnitudeSpectrum();
void SetIdentity();
void SetZero();
bool IsIdentity() const;
bool IsZero() const;
};
}
#endif // INCLUDE_WATCHER_ITA_MAGNITUDE_SPECTRUM
include/ITAThirdOctaveMagnitudeSpectrum.h
View file @ 29c5bb02
......@@ -23,153 +23,153 @@
#include <ITAMagnitudeSpectrum.h>
#include <ITAConstants.h>
//! Third octave magnitude spectrum
/**
* Class for third octave magnitude spectra with predefined center frequencies.
*
* Will raise CITAException on errors.
*
* @sa CITAWholeOctaveMagnitudeSpectrum
*/
class CITAThirdOctaveMagnitudeSpectrum : public CITAMagnitudeSpectrum
namespace ITABase
{
public:
inline CITAThirdOctaveMagnitudeSpectrum()
: CITAMagnitudeSpectrum( GetNumBands() )
{
m_vfCenterFrequencies = GetCenterFrequencies();
};
inline static int GetNumBands()
//! Third octave magnitude spectrum
/**
* Class for third octave magnitude spectra with predefined center frequencies.
*
* Will raise CITAException on errors.
*
* @sa CITAWholeOctaveMagnitudeSpectrum
*/
class CThirdOctaveMagnitudeSpectrum : public CMagnitudeSpectrum
{
return 31;
};
public:
inline CThirdOctaveMagnitudeSpectrum()
: CMagnitudeSpectrum( GetNumBands() )
{
m_vfCenterFrequencies = GetCenterFrequencies();
};
inline static std::vector< float > GetCenterFrequencies()
{
return
inline static int GetNumBands()
{
20, 25, 31.5f, 40, 50, 63, 80, 100, 125, 160, 200,
250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000,
2500, 3150, 4000, 5000, 6300, 8000, 10000, 12500, 16000, 20000
return 31;
};
};
virtual inline ~CITAThirdOctaveMagnitudeSpectrum() {};
inline static std::vector< float > GetCenterFrequencies()
{
return ITAConstants::THIRD_OCTAVE_CENTER_FREQUENCIES_ISO_F;
};
virtual inline bool CompareEqualValues( const CITAThirdOctaveMagnitudeSpectrum& oOtherSpectrum, const float fThreshold = 10.0e-10 )
{
return CITASpectrum::CompareEqualValues( oOtherSpectrum, fThreshold );
};
virtual inline ~CThirdOctaveMagnitudeSpectrum() {};
protected:
void SetCenterFrequencies( const std::vector< float >& vfCenterFrequencies );
};
virtual inline bool CompareEqualValues( const CThirdOctaveMagnitudeSpectrum& oOtherSpectrum, const float fThreshold = 10.0e-10 )
{
return CITASpectrum::CompareEqualValues( oOtherSpectrum, fThreshold );
};
//! Implementation of magnitude spectrum for gain values
class CITAThirdOctaveGainMagnitudeSpectrum : public CITAThirdOctaveMagnitudeSpectrum
{
public:
inline CITAThirdOctaveGainMagnitudeSpectrum()
: CITAThirdOctaveMagnitudeSpectrum()
protected:
void SetCenterFrequencies( const std::vector< float >& vfCenterFrequencies );
};
//! Implementation of magnitude spectrum for gain values
class CThirdOctaveGainMagnitudeSpectrum : public CThirdOctaveMagnitudeSpectrum
{
public:
inline CThirdOctaveGainMagnitudeSpectrum()
: CThirdOctaveMagnitudeSpectrum()
{
};
};
virtual ~CITAThirdOctaveGainMagnitudeSpectrum() {};
virtual ~CThirdOctaveGainMagnitudeSpectrum() {};
inline void SetIdentity()
{
for( size_t n = 0; n < m_vfValues.size(); n++ )
m_vfValues[ n ] = 1.0f;
};
inline void SetIdentity()
{
for( size_t n = 0; n < m_vfValues.size(); n++ )
m_vfValues[ n ] = 1.0f;
};
inline void SetZero()
{
for( size_t n = 0; n < m_vfValues.size(); n++ )
m_vfValues[ n ] = 0.0f;
};
inline void SetZero()
{
for( size_t n = 0; n < m_vfValues.size(); n++ )
m_vfValues[ n ] = 0.0f;
};
inline bool IsIdentity() const
{
for( size_t n = 0; n < m_vfValues.size(); n++ )
inline bool IsIdentity() const
{
if( m_vfValues[ n ] != 1.0f )
return false;
}
for( size_t n = 0; n < m_vfValues.size(); n++ )
{
if( m_vfValues[ n ] != 1.0f )
return false;
}
return true;
};
return true;
};
inline bool IsZero() const
{
for( size_t n = 0; n < m_vfValues.size(); n++ )
inline bool IsZero() const
{
if( m_vfValues[ n ] != 0.0f )
return false;
}
for( size_t n = 0; n < m_vfValues.size(); n++ )
{
if( m_vfValues[ n ] != 0.0f )
return false;
}
return true;
return true;
};
};
};
//! A factor magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed.
/**
* This alias class is used to give the user a hint that the underlying data should be treated as linear values (factors)
* or gains, because a magnitude spectrum does not specify on that. It is used like a CITAThirdOctaveMagnitudeSpectrum.
* There is no real difference between a factor and a gain except that gains are commonly used in DSP (i.e. for "gain" control
* of audio signal channels) and factors are more common in acoustic materials such as absorption and transmission "factor".
*/
typedef CITAThirdOctaveGainMagnitudeSpectrum CITAThirdOctaveFactorMagnitudeSpectrum;
//! A factor magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed.
/**
* This alias class is used to give the user a hint that the underlying data should be treated as linear values (factors)
* or gains, because a magnitude spectrum does not specify on that. It is used like a CITAThirdOctaveMagnitudeSpectrum.
* There is no real difference between a factor and a gain except that gains are commonly used in DSP (i.e. for "gain" control
* of audio signal channels) and factors are more common in acoustic materials such as absorption and transmission "factor".
*/
typedef CThirdOctaveGainMagnitudeSpectrum CITAThirdOctaveFactorMagnitudeSpectrum;
//! A decibel magnitude spectrum with values that have been transformed into logarithmic scale. Values are mostly between -\infinity and 0, but can also exceed.
class CITAThirdOctaveDecibelMagnitudeSpectrum : public CITAThirdOctaveMagnitudeSpectrum
{
public:
inline CITAThirdOctaveDecibelMagnitudeSpectrum()
: CITAThirdOctaveMagnitudeSpectrum()
//! A decibel magnitude spectrum with values that have been transformed into logarithmic scale. Values are mostly between -\infinity and 0, but can also exceed.
class CITAThirdOctaveDecibelMagnitudeSpectrum : public CThirdOctaveMagnitudeSpectrum
{
public:
inline CITAThirdOctaveDecibelMagnitudeSpectrum()
: CThirdOctaveMagnitudeSpectrum()
{
};
};
virtual ~CITAThirdOctaveDecibelMagnitudeSpectrum() {};
virtual ~CITAThirdOctaveDecibelMagnitudeSpectrum() {};
inline void SetIdentity()