Class ArbitraryResample allows you to resample a signal (assumed zero outside the sample region, not periodic) at arbitrary specified time values, which don't have to be linearly spaced. More...

#include <resample.h>

Collaboration diagram for ArbitraryResample:

[legend]

Public Member Functions
	ArbitraryResample (int32 num_samples_in, BaseFloat samp_rate_hz, BaseFloat filter_cutoff_hz, const Vector< BaseFloat > &sample_points_secs, int32 num_zeros)

int32	NumSamplesIn () const

int32	NumSamplesOut () const

void	Resample (const MatrixBase< BaseFloat > &input, MatrixBase< BaseFloat > *output) const
	This function does the resampling. More...

void	Resample (const VectorBase< BaseFloat > &input, VectorBase< BaseFloat > *output) const
	This version of the Resample function processes just one vector. More...

Private Member Functions
void	SetIndexes (const Vector< BaseFloat > &sample_points)

void	SetWeights (const Vector< BaseFloat > &sample_points)

BaseFloat	FilterFunc (BaseFloat t) const
	Here, t is a time in seconds representing an offset from the center of the windowed filter function, and FilterFunction(t) returns the windowed filter function, described in the header as h(t) = f(t)g(t), evaluated at t. More...

Private Attributes
int32	num_samples_in_

BaseFloat	samp_rate_in_

BaseFloat	filter_cutoff_

int32	num_zeros_

std::vector< int32 >	first_index_

std::vector< Vector< BaseFloat > >	weights_

Detailed Description

Class ArbitraryResample allows you to resample a signal (assumed zero outside the sample region, not periodic) at arbitrary specified time values, which don't have to be linearly spaced.

The low-pass filter cutoff "filter_cutoff_hz" should be less than half the sample rate; "num_zeros" should probably be at least two preferably more; higher numbers give sharper filters but will be less efficient.

Definition at line 95 of file resample.h.

Constructor & Destructor Documentation

◆ ArbitraryResample()

ArbitraryResample	(	int32	num_samples_in,
		BaseFloat	samp_rate_hz,
		BaseFloat	filter_cutoff_hz,
		const Vector< BaseFloat > &	sample_points_secs,
		int32	num_zeros
	)

Definition at line 262 of file resample.cc.

References KALDI_ASSERT, ArbitraryResample::SetIndexes(), and ArbitraryResample::SetWeights().

                     :
     num_samples_in_(num_samples_in),
     samp_rate_in_(samp_rate_in),
     filter_cutoff_(filter_cutoff),
     num_zeros_(num_zeros) {
   KALDI_ASSERT(num_samples_in > 0 && samp_rate_in > 0.0 &&
                filter_cutoff > 0.0 &&
                filter_cutoff * 2.0 <= samp_rate_in
                && num_zeros > 0);
   // set up weights_ and indices_.  Please try to keep all functions short and
   SetIndexes(sample_points);
   SetWeights(sample_points);
 }

Member Function Documentation

◆ FilterFunc()

BaseFloat FilterFunc ( BaseFloat t ) const

private

Here, t is a time in seconds representing an offset from the center of the windowed filter function, and FilterFunction(t) returns the windowed filter function, described in the header as h(t) = f(t)g(t), evaluated at t.

Definition at line 353 of file resample.cc.

References ArbitraryResample::filter_cutoff_, M_2PI, M_PI, and ArbitraryResample::num_zeros_.

Referenced by LinearResample::GetOutputSamplingRate(), ArbitraryResample::NumSamplesOut(), and ArbitraryResample::SetWeights().

                                                          {
   BaseFloat window,  // raised-cosine (Hanning) window of width
                   // num_zeros_/2*filter_cutoff_
       filter;  // sinc filter function
   if (fabs(t) < num_zeros_ / (2.0 * filter_cutoff_))
     window = 0.5 * (1 + cos(M_2PI * filter_cutoff_ / num_zeros_ * t));
   else
     window = 0.0;  // outside support of window function
   if (t != 0.0)
     filter = sin(M_2PI * filter_cutoff_ * t) / (M_PI * t);
   else
     filter = 2.0 * filter_cutoff_;  // limit of the function at zero.
   return filter * window;
 }

◆ NumSamplesIn()

int32 NumSamplesIn ( ) const

inline

Definition at line 103 of file resample.h.

References ArbitraryResample::num_samples_in_.

103 { return num_samples_in_; }

kaldi::ArbitraryResample::num_samples_in_

int32 num_samples_in_

Definition: resample.h:126

◆ NumSamplesOut()

int32 NumSamplesOut ( ) const

inline

Definition at line 105 of file resample.h.

References ArbitraryResample::FilterFunc(), ArbitraryResample::Resample(), ArbitraryResample::SetIndexes(), ArbitraryResample::SetWeights(), and ArbitraryResample::weights_.

Referenced by ArbitraryResample::Resample(), and ArbitraryResample::SetWeights().

105 { return weights_.size(); }

kaldi::ArbitraryResample::weights_

std::vector< Vector< BaseFloat > > weights_

Definition: resample.h:133

◆ Resample() [1/2]

void Resample	(	const MatrixBase< BaseFloat > &	input,
		MatrixBase< BaseFloat > *	output
	)		const

This function does the resampling.

input.NumRows() and output.NumRows() should be equal and nonzero. input.NumCols() should equal NumSamplesIn() and output.NumCols() should equal NumSamplesOut().

Definition at line 280 of file resample.cc.

References MatrixBase< Real >::CopyColFromVec(), ArbitraryResample::first_index_, rnnlm::i, KALDI_ASSERT, kaldi::kNoTrans, ArbitraryResample::num_samples_in_, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), ArbitraryResample::NumSamplesOut(), and ArbitraryResample::weights_.

Referenced by OnlinePitchFeatureImpl::AcceptWaveform(), ArbitraryResample::NumSamplesOut(), UnitTestArbitraryResample(), and UnitTestLinearResample().

                                                                       {
   // each row of "input" corresponds to the data to resample;
   // the corresponding row of "output" is the resampled data.
 
   KALDI_ASSERT(input.NumRows() == output->NumRows() &&
                input.NumCols() == num_samples_in_ &&
                output->NumCols() == weights_.size());
 
   Vector<BaseFloat> output_col(output->NumRows());
   for (int32 i = 0; i < NumSamplesOut(); i++) {
     SubMatrix<BaseFloat> input_part(input, 0, input.NumRows(),
                                     first_index_[i],
                                     weights_[i].Dim());
     const Vector<BaseFloat> &weight_vec(weights_[i]);
     output_col.AddMatVec(1.0, input_part,
                          kNoTrans, weight_vec, 0.0);
     output->CopyColFromVec(output_col, i);
   }
 }

◆ Resample() [2/2]

void Resample	(	const VectorBase< BaseFloat > &	input,
		VectorBase< BaseFloat > *	output
	)		const

This version of the Resample function processes just one vector.

Definition at line 301 of file resample.cc.

References VectorBase< Real >::Dim(), ArbitraryResample::first_index_, rnnlm::i, KALDI_ASSERT, ArbitraryResample::num_samples_in_, kaldi::VecVec(), and ArbitraryResample::weights_.

                                                                       {
   KALDI_ASSERT(input.Dim() == num_samples_in_ &&
                output->Dim() == weights_.size());
 
   int32 output_dim = output->Dim();
   for (int32 i = 0; i < output_dim; i++) {
     SubVector<BaseFloat> input_part(input, first_index_[i], weights_[i].Dim());
     (*output)(i) = VecVec(input_part, weights_[i]);
   }
 }

◆ SetIndexes()

void SetIndexes ( const Vector< BaseFloat > & sample_points )

private

Definition at line 313 of file resample.cc.

References VectorBase< Real >::Dim(), ArbitraryResample::filter_cutoff_, ArbitraryResample::first_index_, rnnlm::i, ArbitraryResample::num_samples_in_, ArbitraryResample::num_zeros_, ArbitraryResample::samp_rate_in_, and ArbitraryResample::weights_.

Referenced by ArbitraryResample::ArbitraryResample(), and ArbitraryResample::NumSamplesOut().

                                                                          {
   int32 num_samples = sample_points.Dim();
   first_index_.resize(num_samples);
   weights_.resize(num_samples);
   BaseFloat filter_width = num_zeros_ / (2.0 * filter_cutoff_);
   for (int32  i = 0; i < num_samples; i++) {
     // the t values are in seconds.
     BaseFloat t = sample_points(i),
         t_min = t - filter_width, t_max = t + filter_width;
     int32 index_min = ceil(samp_rate_in_ * t_min),
         index_max = floor(samp_rate_in_ * t_max);
     // the ceil on index min and the floor on index_max are because there
     // is no point using indices just outside the window (coeffs would be zero).
     if (index_min < 0)
       index_min = 0;
     if (index_max >= num_samples_in_)
       index_max = num_samples_in_ - 1;
     first_index_[i] = index_min;
     weights_[i].Resize(index_max - index_min + 1);
   }
 }

◆ SetWeights()

void SetWeights ( const Vector< BaseFloat > & sample_points )

private

Definition at line 335 of file resample.cc.

References ArbitraryResample::FilterFunc(), ArbitraryResample::first_index_, rnnlm::i, rnnlm::j, ArbitraryResample::NumSamplesOut(), ArbitraryResample::samp_rate_in_, and ArbitraryResample::weights_.

Referenced by ArbitraryResample::ArbitraryResample(), and ArbitraryResample::NumSamplesOut().

                                                                          {
   int32 num_samples_out = NumSamplesOut();
   for (int32 i = 0; i < num_samples_out; i++) {
     for (int32 j = 0 ; j < weights_[i].Dim(); j++) {
       BaseFloat delta_t = sample_points(i) -
           (first_index_[i] + j) / samp_rate_in_;
       // Include at this point the factor of 1.0 / samp_rate_in_ which
       // appears in the math.
       weights_[i](j) = FilterFunc(delta_t) / samp_rate_in_;
     }
   }
 }

Member Data Documentation

◆ filter_cutoff_

BaseFloat filter_cutoff_

private

Definition at line 128 of file resample.h.

Referenced by ArbitraryResample::FilterFunc(), and ArbitraryResample::SetIndexes().

◆ first_index_

std::vector<int32> first_index_

private

Definition at line 131 of file resample.h.

Referenced by ArbitraryResample::Resample(), ArbitraryResample::SetIndexes(), and ArbitraryResample::SetWeights().

◆ num_samples_in_

int32 num_samples_in_

private

Definition at line 126 of file resample.h.

Referenced by ArbitraryResample::NumSamplesIn(), ArbitraryResample::Resample(), and ArbitraryResample::SetIndexes().

◆ num_zeros_

int32 num_zeros_

private

Definition at line 129 of file resample.h.

Referenced by ArbitraryResample::FilterFunc(), and ArbitraryResample::SetIndexes().

◆ samp_rate_in_

BaseFloat samp_rate_in_

private

Definition at line 127 of file resample.h.

Referenced by LinearResample::GetInputSamplingRate(), ArbitraryResample::SetIndexes(), and ArbitraryResample::SetWeights().

◆ weights_

std::vector<Vector<BaseFloat> > weights_

private

Definition at line 133 of file resample.h.

Referenced by ArbitraryResample::NumSamplesOut(), ArbitraryResample::Resample(), ArbitraryResample::SetIndexes(), and ArbitraryResample::SetWeights().

The documentation for this class was generated from the following files:

feat/resample.h
feat/resample.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ArbitraryResample()

Member Function Documentation

◆ FilterFunc()

◆ NumSamplesIn()

◆ NumSamplesOut()

◆ Resample() [1/2]

◆ Resample() [2/2]

◆ SetIndexes()

◆ SetWeights()

Member Data Documentation

◆ filter_cutoff_

◆ first_index_

◆ num_samples_in_

◆ num_zeros_

◆ samp_rate_in_

◆ weights_