This templated class is intended for offline feature extraction, i.e. More...

#include <feature-common.h>

Collaboration diagram for OfflineFeatureTpl< F >:

Public Types
typedef F::Options	Options

Public Member Functions
	OfflineFeatureTpl (const Options &opts)

void	Compute (const VectorBase< BaseFloat > &wave, BaseFloat vtln_warp, Matrix< BaseFloat > output, Vector< BaseFloat > deprecated_wave_remainder=NULL)

void	Compute (const VectorBase< BaseFloat > &wave, BaseFloat vtln_warp, Matrix< BaseFloat > output, Vector< BaseFloat > deprecated_wave_remainder=NULL) const

int32	Dim () const

	OfflineFeatureTpl (const OfflineFeatureTpl< F > &other)

Private Member Functions
OfflineFeatureTpl< F > &	operator= (const OfflineFeatureTpl< F > &other)

Private Attributes
F	computer_

FeatureWindowFunction	feature_window_function_

Detailed Description

template<class F>
class kaldi::OfflineFeatureTpl< F >

This templated class is intended for offline feature extraction, i.e.

where you have access to the entire signal at the start. It exists mainly to be drop-in replacement for the old (pre-2016) classes Mfcc, Plp and so on, for use in the offline case. In April 2016 we reorganized the online feature-computation code for greater modularity and to have correct support for the snip-edges=false option.

Definition at line 111 of file feature-common.h.

Member Typedef Documentation

typedef F::Options Options

Definition at line 113 of file feature-common.h.

Constructor & Destructor Documentation

OfflineFeatureTpl ( const Options & opts )

inline

Definition at line 117 of file feature-common.h.

                                         :
       computer_(opts),
       feature_window_function_(computer_.GetFrameOptions()) { }

OfflineFeatureTpl ( const OfflineFeatureTpl< F > & other )

inline

Definition at line 144 of file feature-common.h.

                                                       :
       computer_(other.computer_),
       feature_window_function_(other.feature_window_function_) { }

Member Function Documentation

void Compute	(	const VectorBase< BaseFloat > &	wave,
		BaseFloat	vtln_warp,
		Matrix< BaseFloat > *	output,
		Vector< BaseFloat > *	deprecated_wave_remainder = `NULL`
	)

Definition at line 28 of file feature-common-inl.h.

References VectorBase< Real >::Dim(), kaldi::ExtractWaveformRemainder(), kaldi::ExtractWindow(), KALDI_ASSERT, kaldi::NumFrames(), and Matrix< Real >::Resize().

Referenced by OfflineFeatureTpl< F >::Compute(), main(), kaldi::TestOnlineAppendFeature(), kaldi::TestOnlineMfcc(), kaldi::TestOnlinePlp(), UnitTestHTKCompare1(), UnitTestHTKCompare2(), UnitTestHTKCompare3(), UnitTestHTKCompare4(), UnitTestHTKCompare5(), UnitTestHTKCompare6(), and UnitTestSimple().

                                                   {
   KALDI_ASSERT(output != NULL);
   int32 rows_out = NumFrames(wave.Dim(), computer_.GetFrameOptions()),
       cols_out = computer_.Dim();
   if (rows_out == 0) {
     output->Resize(0, 0);
     if (deprecated_wave_remainder != NULL)
       *deprecated_wave_remainder = wave;
     return;
   }
   output->Resize(rows_out, cols_out);
   if (deprecated_wave_remainder != NULL)
     ExtractWaveformRemainder(wave, computer_.GetFrameOptions(),
                              deprecated_wave_remainder);
   Vector<BaseFloat> window;  // windowed waveform.
   bool use_raw_log_energy = computer_.NeedRawLogEnergy();
   for (int32 r = 0; r < rows_out; r++) {  // r is frame index.
     BaseFloat raw_log_energy = 0.0;
     ExtractWindow(0, wave, r, computer_.GetFrameOptions(),
                   feature_window_function_, &window,
                   (use_raw_log_energy ? &raw_log_energy : NULL));
 
     SubVector<BaseFloat> output_row(*output, r);
     computer_.Compute(raw_log_energy, vtln_warp, &window, &output_row);
   }
 }

void Compute	(	const VectorBase< BaseFloat > &	wave,
		BaseFloat	vtln_warp,
		Matrix< BaseFloat > *	output,
		Vector< BaseFloat > *	deprecated_wave_remainder = `NULL`
	)		const

Definition at line 60 of file feature-common-inl.h.

References OfflineFeatureTpl< F >::Compute().

                                                         {
   OfflineFeatureTpl<F> temp(*this);
   // call the non-const version of Compute() on a temporary copy of this object.
   // This is a workaround for const-ness that may sometimes be useful in
   // multi-threaded code, although it's not optimally efficient.
   temp.Compute(wave, vtln_warp, output, deprecated_wave_remainder);
 }