C++ Signal::size方法代码示例

TEST(core_signal_test, empty_slot_is_not_same_as_no_slot) {
  Signal signal;

  signal.connect();
  ASSERT_EQ(1u, signal.size());

  signal.connect(Signal::Slot());
  ASSERT_EQ(2u, signal.size());
}

Contour<float> DioF0Estimator::estimate(const Signal &signal, double msFramePeriod)
{
    int decimationRatio = qMax(1, qMin(12, (int)(signal.samplingFrequency() / decimatedFs)));
    int decimatedLength = 1 + signal.size() / decimationRatio;
    fft = new Fft(Fft::suitableLength(decimatedLength), Fft::Real);

    Spectrum decimatedSpectrum(createDecimatedSpectrum(signal, decimationRatio));

    Contour<float> result(estimate(decimatedSpectrum, signal.size(), signal.samplingFrequency(), msFramePeriod));

    delete fft;

    return result;
}

// receiver: decode received bits.  Ns samples per bit.
Bits
BluetoothReceiver::receive(const Signal& input) {
    // Input length should be a multiple of Ns
    int nBits = input.size()/Ns;
    _ASSERTE((input.size()) % Ns == 0);
    Bits bitsOut(nBits);

    for (int i=0; i<nBits; ++i) {
        slice sl_i(i*Ns, Ns);
        bitsOut[i] = receiveBit(input[sl_i]);
    }

    return bitsOut;
}

void Downsampler::revert(Signal& signal) const
{
    // Resize and set the sample rate on the signal
    int revertedSize = _fineStructure.size();
    signal.resize(revertedSize);
    signal.sampleRate = _fineStructure.sampleRate;

    // Move the values to their new positions and add the fine structure
    double sizeRatio = signal.size() / revertedSize;
    for(int i = revertedSize - 1; i >= 0; i--)
        signal[i] = signal[sizeRatio * i] + _fineStructure[i];
}

TEST(core_signal_test, executing_signal_actually_works_for_all_of_them) {
  Signal signal;
  int a = 0, b = 0;

  signal.connect([&a](int _i) { a = _i; });
  signal.connect([&b](int _i) { b = _i + 1; });

  signal(5);

  ASSERT_EQ(2u, signal.size());
  ASSERT_EQ(5, a);
  ASSERT_EQ(6, b);
}

// receiveBit: decode one bit of received data
bool
BluetoothReceiver::receiveBit(const Signal& inputSlice) {
    // Check input: Ns samples per bit
    _ASSERTE(inputSlice.size() == Ns);
    double phase = 0.0; // Integrate over phase difference
    for (int i=0; i<Ns; ++i) {
        Sample bpOut   = bandpassFilter.FilterStep(inputSlice[i]);
        Sample diffOut = differentiatorFilter.FilterStep(bpOut);
        phase += limiterDiscriminator(bpOut, diffOut);
    }

    return (phase < 0.0);
}

TransformeeFourier::Signal TransformeeFourier::inverse(const Signal & signal){
	Signal returnRecompoTransfoFourier;
	double N = signal.size();
	returnRecompoTransfoFourier.resize((int)(N));
	
	for(double j = -N/2; j < N/2; j++){
		returnRecompoTransfoFourier[(j+(N/2))] = 0;
		for(double i = 0; i < N; i ++){	
			std::complex<double> c(0.0, ((j+(N/2)))*i*M_PI*2.0/N);
			returnRecompoTransfoFourier[(j+(N/2))] += signal[i] * exp(c);
		}	
	}
	return returnRecompoTransfoFourier;
}

void TransformeeFourier::fourier(const Signal & contour){
	
	Signal returnTransfoFourier;
	double N = contour.size();
	tabComplex.resize((int)(N)); 
	
	for(double j = -N/2; j < N/2; j++){
		tabComplex[(j+(N/2))] = 0;
		for(double i = 0; i < N; i ++){	
			std::complex<double> c(0.0, ((j+(N/2)))*i*M_PI*2.0/N);
			tabComplex[(j+(N/2))] += contour[i] * exp(-c);
		}
		tabComplex[(j+(N/2))] /= N;		
	}
	
}

DioF0Estimator::Spectrum DioF0Estimator::createDecimatedSpectrum(const Signal &signal, int decimationRatio)
{
    int decimatedLength = 1 + signal.size() / decimationRatio;
    int fftLength = fft->fftLength;
    double *decimatedWave = new double[fftLength];
    Decimator::decimate(signal, decimationRatio, decimatedWave, decimatedLength);
    double mean = 0.0;
    for(int i = 0; i < decimatedLength; i++)
    {
        mean += decimatedWave[i];
    }
    mean /= decimatedLength;
    for(int i = 0; i < decimatedLength; i++)
    {
        decimatedWave[i] -= mean;
    }
    for(int i = decimatedLength; i < fftLength; i++)
    {
        decimatedWave[i] = 0.0;
    }
    fft->execute(Fft::Forward, decimatedWave);
    return Spectrum(decimatedWave, decimatedLength, fftLength, (double)signal.samplingFrequency() / decimationRatio);
}

Downsampler::Downsampler(Signal& signal, double targetRate):
    _fineStructure(signal),
    _newSampleRate(signal.sampleRate /
        pow(2, (int)(log(signal.sampleRate / targetRate) / log(2))))
{
    int oldSize = signal.size();

    // Apply a lowpass filter to obtain the fine structure
    LowpassFilter filter(_newSampleRate / 2);
    filter.filter(signal);
    for(int i = 0; i < oldSize; i++)
        _fineStructure[i] -= signal[i];

    // Fill values into new positions
    int newSize = (int)(_newSampleRate / signal.sampleRate * oldSize);
    double sizeRatio = oldSize / newSize;
    for(int i = 0; i < newSize; i++)
        signal[i] = signal[(int)(sizeRatio * i)];

    // Set the new size and sample rate
    signal.resize(std::min(newSize, oldSize));
    signal.sampleRate = _newSampleRate;
}