Created
July 7, 2013 08:21
-
-
Save q-depot/5942781 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
* ciXtractFeature.cpp | |
* | |
* Created by Andrea Cuius | |
* Nocte Studio Ltd. Copyright 2013 . All rights reserved. | |
* | |
* www.nocte.co.uk | |
* | |
*/ | |
#include "ciXtractFeature.h" | |
#include "ciXtract.h" | |
using namespace ci; | |
using namespace ci::app; | |
using namespace std; | |
// ------------------------------------------------------------------------------------------------ // | |
// ------------------------------------------------------------------------------------------------ // | |
// *************************************** VECTOR FEATURES **************************************** // | |
// ------------------------------------------------------------------------------------------------ // | |
// ------------------------------------------------------------------------------------------------ // | |
// Spectrum // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSpectrum::ciXtractSpectrum( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SPECTRUM, name, CI_XTRACT_VECTOR, {}, PCM_SIZE, FFT_SIZE ) | |
{ | |
mData = mXtract->getPcmData(); | |
mResult = std::shared_ptr<double>( new double[PCM_SIZE] ); | |
// params | |
mParams["sample_rate_N"] = { SAMPLERATE / (double)PCM_SIZE, CI_XTRACT_PARAM_DOUBLE }; | |
mParams["dc"] = { false, CI_XTRACT_PARAM_BOOL }; | |
mParams["norm"] = { false, CI_XTRACT_PARAM_BOOL }; | |
mParams["type"] = { XTRACT_MAGNITUDE_SPECTRUM, CI_XTRACT_PARAM_ENUM, | |
{ { "Magnitude", XTRACT_MAGNITUDE_SPECTRUM }, { "Log Magnitude", XTRACT_LOG_MAGNITUDE_SPECTRUM }, { "Power", XTRACT_POWER_SPECTRUM }, { "Log Power", XTRACT_LOG_POWER_SPECTRUM } } }; | |
xtract_init_fft( PCM_SIZE, XTRACT_SPECTRUM ); | |
} | |
void ciXtractSpectrum::update() | |
{ | |
mArgd[0] = mParams["sample_rate_N"].val; | |
mArgd[1] = mParams["type"].val; | |
mArgd[2] = mParams["dc"].val; | |
mArgd[3] = mParams["norm"].val; | |
xtract_spectrum( mData.get(), mDataN, mArgd, mResult.get() ); | |
} | |
// Autocorrelation // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractAutocorrelation::ciXtractAutocorrelation( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_AUTOCORRELATION, name, CI_XTRACT_VECTOR, {}, PCM_SIZE, FFT_SIZE ) | |
{ | |
mData = mXtract->getPcmData(); | |
mResult = std::shared_ptr<double>( new double[PCM_SIZE] ); | |
} | |
void ciXtractAutocorrelation::update() | |
{ | |
xtract_autocorrelation( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// AutoCorrelationFft // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractAutocorrelationFft::ciXtractAutocorrelationFft( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_AUTOCORRELATION_FFT, name, CI_XTRACT_VECTOR, {}, PCM_SIZE, FFT_SIZE ) | |
{ | |
mData = mXtract->getPcmData(); | |
mResult = std::shared_ptr<double>( new double[PCM_SIZE] ); | |
xtract_init_fft( PCM_SIZE << 1, XTRACT_AUTOCORRELATION_FFT ); | |
} | |
void ciXtractAutocorrelationFft::update() | |
{ | |
xtract_autocorrelation_fft( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Harmonic Spectrum // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractHarmonicSpectrum::ciXtractHarmonicSpectrum( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_HARMONIC_SPECTRUM, name, CI_XTRACT_VECTOR, { XTRACT_F0 }, PCM_SIZE, FFT_SIZE ) | |
{ | |
mData = mXtract->getPcmData(); | |
mResult = std::shared_ptr<double>( new double[PCM_SIZE] ); | |
mParams["threshold"].val = 0.3f; | |
} | |
void ciXtractHarmonicSpectrum::update() | |
{ | |
mArgd[0] = *mXtract->getFeatureResult(XTRACT_F0).get(); | |
mArgd[1] = mParams["threshold"].val; | |
xtract_harmonic_spectrum( mData.get(), mDataN, mArgd, mResult.get() ); | |
} | |
// Peak Spectrum // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractPeakSpectrum::ciXtractPeakSpectrum( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_PEAK_SPECTRUM, name, CI_XTRACT_VECTOR, { XTRACT_SPECTRUM }, FFT_SIZE, FFT_SIZE ) | |
{ | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
mResult = std::shared_ptr<double>( new double[PCM_SIZE] ); | |
mParams["sample_rate_N"] = { SAMPLERATE / (double)PCM_SIZE, CI_XTRACT_PARAM_DOUBLE }; | |
mParams["threshold"] = { 0.0f, CI_XTRACT_PARAM_DOUBLE }; | |
} | |
void ciXtractPeakSpectrum::update() | |
{ | |
mArgd[0] = mParams["sample_rate_N"].val; | |
mArgd[1] = mParams["threshold"].val; | |
xtract_peak_spectrum( mData.get(), mDataN, mArgd, mResult.get() ); | |
} | |
// Bark | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractBark::ciXtractBark( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_BARK_COEFFICIENTS, name, CI_XTRACT_VECTOR, { XTRACT_SPECTRUM }, FFT_SIZE, XTRACT_BARK_BANDS ) | |
{ | |
mResult = std::shared_ptr<double>( new double[ XTRACT_BARK_BANDS ] ); | |
mBandLimits = std::shared_ptr<int>( new int[ XTRACT_BARK_BANDS ] ); | |
mParams["sample_rate_N"] = { SAMPLERATE / (double)PCM_SIZE, CI_XTRACT_PARAM_DOUBLE }; | |
mParams["threshold"] = { 0.0f, CI_XTRACT_PARAM_DOUBLE }; | |
xtract_init_bark( FFT_SIZE, SAMPLERATE >> 1, mBandLimits.get() ); | |
} | |
void ciXtractBark::update() | |
{ | |
mArgd[0] = mParams["sample_rate_N"].val; | |
mArgd[1] = mParams["threshold"].val; | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
xtract_bark_coefficients( mData.get(), mDataN, mBandLimits.get(), mResult.get() ); | |
} | |
// Mfcc | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractMfcc::ciXtractMfcc( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_MFCC, name, CI_XTRACT_VECTOR, { XTRACT_SPECTRUM }, FFT_SIZE, MFCC_FREQ_BANDS ) | |
{ | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
mResult = std::shared_ptr<double>( new double[ MFCC_FREQ_BANDS ] ); | |
mMelFilters.n_filters = MFCC_FREQ_BANDS; | |
mMelFilters.filters = (double **)malloc(MFCC_FREQ_BANDS * sizeof(double *)); | |
for( int n = 0; n < MFCC_FREQ_BANDS; ++n ) | |
mMelFilters.filters[n] = (double *)malloc(PCM_SIZE * sizeof(double)); | |
xtract_init_mfcc( FFT_SIZE, SAMPLERATE >> 1, XTRACT_EQUAL_GAIN, MFCC_FREQ_MIN, MFCC_FREQ_MAX, mMelFilters.n_filters, mMelFilters.filters ); | |
} | |
ciXtractMfcc::~ciXtractMfcc() | |
{ | |
for( auto n = 0; n < MFCC_FREQ_BANDS; ++n ) | |
free( mMelFilters.filters[n] ); | |
free( mMelFilters.filters ); | |
} | |
void ciXtractMfcc::update() | |
{ | |
xtract_mfcc( mData.get(), mDataN, &mMelFilters, mResult.get() ); | |
} | |
// Sub Bands | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSubBands::ciXtractSubBands( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SUBBANDS, name, CI_XTRACT_VECTOR, { XTRACT_SPECTRUM }, FFT_SIZE, SUBBANDS_N ) | |
{ | |
mResult = std::shared_ptr<double>( new double[ SUBBANDS_N ] ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSubBands::update() | |
{ | |
int argd[4] = { XTRACT_MEAN, SUBBANDS_N, XTRACT_LINEAR_SUBBANDS, 5 }; // { XTRACT_SUM, ... XTRACT_OCTAVE_SUBBANDS, XTRACT_LINEAR_SUBBANDS | |
xtract_subbands( mData.get(), mDataN, argd, mResult.get() ); | |
} | |
// ------------------------------------------------------------------------------------------------ // | |
// ------------------------------------------------------------------------------------------------ // | |
// *************************************** SCALAR FEATURES **************************************** // | |
// ------------------------------------------------------------------------------------------------ // | |
// ------------------------------------------------------------------------------------------------ // | |
// F0 // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractF0::ciXtractF0( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_F0, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mParams["sample_rate"] = { SAMPLERATE, CI_XTRACT_PARAM_DOUBLE }; | |
} | |
void ciXtractF0::update() | |
{ | |
mArgd[0] = mParams["sample_rate"].val; | |
xtract_f0( mData.get(), mDataN, mArgd, mResult.get() ); | |
} | |
// Mean // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractMean::ciXtractMean( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_MEAN, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractMean::update() | |
{ | |
xtract_mean( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Variance // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractVariance::ciXtractVariance( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_VARIANCE, name, CI_XTRACT_SCALAR, { XTRACT_MEAN }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractVariance::update() | |
{ | |
xtract_variance( mData.get(), mDataN, mXtract->getFeatureResult(XTRACT_MEAN).get(), mResult.get() ); | |
} | |
// Standard Deviation // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractStandardDeviation::ciXtractStandardDeviation( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_STANDARD_DEVIATION, name, CI_XTRACT_SCALAR, { XTRACT_VARIANCE }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractStandardDeviation::update() | |
{ | |
xtract_standard_deviation( mData.get(), mDataN, mXtract->getFeatureResult(XTRACT_VARIANCE).get(), mResult.get() ); | |
} | |
// Average Deviation // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractAverageDeviation::ciXtractAverageDeviation( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_AVERAGE_DEVIATION, name, CI_XTRACT_SCALAR, { XTRACT_MEAN }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractAverageDeviation::update() | |
{ | |
xtract_average_deviation( mData.get(), mDataN, mXtract->getFeatureResult(XTRACT_MEAN).get(), mResult.get() ); | |
} | |
// Skewness // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSkewness::ciXtractSkewness( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SKEWNESS, name, CI_XTRACT_SCALAR, { XTRACT_STANDARD_DEVIATION }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSkewness::update() | |
{ | |
mArgd[0] = *mXtract->getFeatureResult(XTRACT_MEAN).get(); | |
mArgd[1] = *mXtract->getFeatureResult(XTRACT_STANDARD_DEVIATION).get(); | |
xtract_skewness( mData.get(), mDataN, mArgd, mResult.get() ); | |
} | |
// Kurtosis // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractKurtosis::ciXtractKurtosis( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_KURTOSIS, name, CI_XTRACT_SCALAR, { XTRACT_STANDARD_DEVIATION }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractKurtosis::update() | |
{ | |
mArgd[0] = *mXtract->getFeatureResult(XTRACT_MEAN).get(); | |
mArgd[1] = *mXtract->getFeatureResult(XTRACT_STANDARD_DEVIATION).get(); | |
xtract_kurtosis( mData.get(), mDataN, mArgd, mResult.get() ); | |
} | |
// Spectral Mean // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSpectralMean::ciXtractSpectralMean( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SPECTRAL_MEAN, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSpectralMean::update() | |
{ | |
xtract_spectral_mean( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Spectral Variance // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSpectralVariance::ciXtractSpectralVariance( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SPECTRAL_VARIANCE, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRAL_MEAN }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSpectralVariance::update() | |
{ | |
xtract_spectral_variance( mData.get(), mDataN, mXtract->getFeatureResult(XTRACT_SPECTRAL_MEAN).get(), mResult.get() ); | |
} | |
// Spectral Standard Deviation // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSpectralStandardDeviation::ciXtractSpectralStandardDeviation( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SPECTRAL_STANDARD_DEVIATION, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRAL_VARIANCE }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSpectralStandardDeviation::update() | |
{ | |
xtract_spectral_standard_deviation( mData.get(), mDataN, mXtract->getFeatureResult(XTRACT_SPECTRAL_VARIANCE).get(), mResult.get() ); | |
} | |
// Spectral Skewness // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSpectralSkewness::ciXtractSpectralSkewness( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SPECTRAL_SKEWNESS, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRAL_MEAN }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSpectralSkewness::update() | |
{ | |
xtract_spectral_skewness( mData.get(), mDataN, mXtract->getFeatureResult(XTRACT_SPECTRAL_MEAN).get(), mResult.get() ); | |
} | |
// Spectral Kurtosis // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSpectralKurtosis::ciXtractSpectralKurtosis( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SPECTRAL_KURTOSIS, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRAL_MEAN, XTRACT_SPECTRAL_STANDARD_DEVIATION }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSpectralKurtosis::update() | |
{ | |
mArgd[0] = *mXtract->getFeatureResult(XTRACT_SPECTRAL_MEAN).get(); | |
mArgd[1] = *mXtract->getFeatureResult(XTRACT_SPECTRAL_STANDARD_DEVIATION).get(); | |
xtract_spectral_kurtosis( mData.get(), mDataN, mArgd, mResult.get() ); | |
} | |
// Spectral Centroid // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSpectralCentroid::ciXtractSpectralCentroid( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SPECTRAL_CENTROID, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSpectralCentroid::update() | |
{ | |
xtract_spectral_centroid( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Irregularity K // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractIrregularityK::ciXtractIrregularityK( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_IRREGULARITY_K, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractIrregularityK::update() | |
{ | |
xtract_irregularity_k( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Irregularity J // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractIrregularityJ::ciXtractIrregularityJ( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_IRREGULARITY_J, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractIrregularityJ::update() | |
{ | |
xtract_irregularity_j( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Tristimulus 1 // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractTristimulus1::ciXtractTristimulus1( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_TRISTIMULUS_1, name, CI_XTRACT_SCALAR, { XTRACT_HARMONIC_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_HARMONIC_SPECTRUM); | |
} | |
void ciXtractTristimulus1::update() | |
{ | |
xtract_tristimulus_1( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Smoothness // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSmoothness::ciXtractSmoothness( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SMOOTHNESS, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
mParams["lower_bound"] = { 0.0f, CI_XTRACT_PARAM_DOUBLE }; | |
mParams["upper_bound"] = { 10.0f, CI_XTRACT_PARAM_DOUBLE }; | |
mParams["pre_scaling"] = { 1.0f, CI_XTRACT_PARAM_DOUBLE }; | |
} | |
void ciXtractSmoothness::update() | |
{ | |
int argd[3]; | |
argd[0] = mParams["lower_bound"].val; | |
argd[1] = mParams["upper_bound"].val; | |
argd[2] = mParams["pre_scaling"].val; | |
xtract_smoothness( mData.get(), mDataN, argd, mResult.get() ); | |
} | |
// Spread // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSpread::ciXtractSpread( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SPREAD, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRAL_CENTROID }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSpread::update() | |
{ | |
xtract_spread( mData.get(), mDataN, mXtract->getFeatureResult(XTRACT_SPECTRAL_CENTROID).get(), mResult.get() ); | |
} | |
// Zcr // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractZcr::ciXtractZcr( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_ZCR, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractZcr::update() | |
{ | |
xtract_zcr( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Rolloff // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractRolloff::ciXtractRolloff( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_ROLLOFF, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
mParams["sample_rate_N"] = { (double)SAMPLERATE / (double)( mDataN ), CI_XTRACT_PARAM_DOUBLE }; | |
mParams["threshold"] = { 15.0f, CI_XTRACT_PARAM_DOUBLE }; | |
} | |
void ciXtractRolloff::update() | |
{ | |
mArgd[0] = mParams["sample_rate_N"].val; | |
mArgd[1] = mParams["threshold"].val; | |
xtract_rolloff( mData.get(), mDataN, mArgd, mResult.get() ); | |
} | |
// Loudness // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractLoudness::ciXtractLoudness( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_LOUDNESS, name, CI_XTRACT_SCALAR, { XTRACT_BARK_COEFFICIENTS }, XTRACT_BARK_BANDS, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_BARK_COEFFICIENTS); | |
} | |
void ciXtractLoudness::update() | |
{ | |
xtract_loudness( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Flatness // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractFlatness::ciXtractFlatness( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_FLATNESS, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractFlatness::update() | |
{ | |
xtract_flatness( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Flatness Db // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractFlatnessDb::ciXtractFlatnessDb( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_FLATNESS_DB, name, CI_XTRACT_SCALAR, { XTRACT_FLATNESS }, 0, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
} | |
void ciXtractFlatnessDb::update() | |
{ | |
xtract_flatness_db( NULL, 0, mXtract->getFeatureResult(XTRACT_FLATNESS).get(), mResult.get() ); | |
} | |
// Tonality // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractTonality::ciXtractTonality( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_TONALITY, name, CI_XTRACT_SCALAR, { XTRACT_FLATNESS_DB }, 0, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
} | |
void ciXtractTonality::update() | |
{ | |
xtract_tonality( NULL, 0, mXtract->getFeatureResult(XTRACT_FLATNESS_DB).get(), mResult.get() ); | |
} | |
// RMS Amplitude // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractRmsAmplitude::ciXtractRmsAmplitude( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_RMS_AMPLITUDE, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractRmsAmplitude::update() | |
{ | |
xtract_rms_amplitude( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Spectral Inhamornicity // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSpectralInharmonicity::ciXtractSpectralInharmonicity( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SPECTRAL_INHARMONICITY, name, CI_XTRACT_SCALAR, { XTRACT_PEAK_SPECTRUM, XTRACT_F0 }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_PEAK_SPECTRUM); | |
} | |
void ciXtractSpectralInharmonicity::update() | |
{ | |
xtract_spectral_inharmonicity( mData.get(), mDataN, mXtract->getFeatureResult(XTRACT_F0).get(), mResult.get() ); | |
} | |
// Power // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractPower::ciXtractPower( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_POWER, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractPower::update() | |
{ | |
xtract_power( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Odd Even Ratio // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractOddEvenRatio::ciXtractOddEvenRatio( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_ODD_EVEN_RATIO, name, CI_XTRACT_SCALAR, { XTRACT_HARMONIC_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_HARMONIC_SPECTRUM); | |
} | |
void ciXtractOddEvenRatio::update() | |
{ | |
xtract_odd_even_ratio( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Sharpness // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSharpness::ciXtractSharpness( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SHARPNESS, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSharpness::update() | |
{ | |
xtract_sharpness( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Spectral Slope // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSpectralSlope::ciXtractSpectralSlope( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SPECTRAL_SLOPE, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSpectralSlope::update() | |
{ | |
xtract_spectral_slope( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Lowest Value // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractLowestValue::ciXtractLowestValue( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_LOWEST_VALUE, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
mParams["lower_limit"] = { 0.2f, CI_XTRACT_PARAM_DOUBLE }; | |
} | |
void ciXtractLowestValue::update() | |
{ | |
xtract_lowest_value( mData.get(), mDataN, &mParams["lower_limit"], mResult.get() ); | |
} | |
// Highest Value // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractHighestValue::ciXtractHighestValue( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_LOWEST_VALUE, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractHighestValue::update() | |
{ | |
xtract_highest_value( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Sum // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractSum::ciXtractSum( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_SUM, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
} | |
void ciXtractSum::update() | |
{ | |
xtract_sum( mData.get(), mDataN, NULL, mResult.get() ); | |
} | |
// Non-Zero Count // | |
// ------------------------------------------------------------------------------------------------ // | |
ciXtractNonZeroCount::ciXtractNonZeroCount( ciXtract *xtract, std::string name ) | |
: ciXtractFeature( xtract, XTRACT_NONZERO_COUNT, name, CI_XTRACT_SCALAR, { XTRACT_SPECTRUM }, FFT_SIZE, 1 ) | |
{ | |
mResult = std::shared_ptr<double>( new double(0.0f) ); | |
} | |
void ciXtractNonZeroCount::update() | |
{ | |
mData = mXtract->getFeatureResult(XTRACT_SPECTRUM); | |
xtract_nonzero_count( mData.get(), mDataN, NULL, mResult.get() ); | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment