fers_signal::FileSignal Class Reference

File-backed sampled waveform with explicit radar-mode identity. More...

#include "radar_signal.h"

Inheritance diagram for fers_signal::FileSignal:

Collaboration diagram for fers_signal::FileSignal:

Public Member Functions
	FileSignal (FileWaveformKind kind)
	~FileSignal () override=default
	FileSignal (const FileSignal &)=delete
FileSignal &	operator= (const FileSignal &)=delete
	FileSignal (FileSignal &&)=delete
FileSignal &	operator= (FileSignal &&)=delete
FileWaveformKind	getKind () const noexcept
bool	isFmcwFamily () const noexcept override
	Returns true when this signal belongs to the FMCW waveform family.
void	clear () noexcept
	Clears the internal signal data.
void	load (std::span< const ComplexType > inData, unsigned samples, RealType sampleRate)
	Loads complex radar waveform data.
RealType	getRate () const noexcept
	Gets the sample rate of the signal.
unsigned	getSampleCount () const noexcept
	Gets the number of native samples held by this signal.
virtual std::vector< ComplexType >	render (const std::vector< interp::InterpPoint > &points, unsigned &size, double fracWinDelay) const
	Renders the signal data based on interpolation points.
virtual std::vector< ComplexType >	renderSlice (const std::vector< interp::InterpPoint > &points, RealType outputStartTime, RealType outputSampleRate, std::size_t sampleCount, RealType fracWinDelay) const
	Renders a bounded absolute-time slice on the requested output grid.
ComplexType	sampleAt (RealType time_since_start) const noexcept
	Samples the finite stored complex envelope using the render interpolation filter.

Detailed Description

File-backed sampled waveform with explicit radar-mode identity.

Definition at line 304 of file radar_signal.h.

Constructor & Destructor Documentation

FileSignal() [1/3]

fers_signal::FileSignal::FileSignal ( FileWaveformKind  kind )

explicit

Definition at line 307 of file radar_signal.h.

: _kind(kind) {}

~FileSignal()

fers_signal::FileSignal::~FileSignal ( )

overridedefault

FileSignal() [2/3]

fers_signal::FileSignal::FileSignal ( const FileSignal &  )

delete

FileSignal() [3/3]

fers_signal::FileSignal::FileSignal ( FileSignal &&  )

delete

Member Function Documentation

clear()

void fers_signal::Signal::clear ( )

noexceptinherited

Clears the internal signal data.

Definition at line 347 of file radar_signal.cpp.

    {
        _size = 0;
        _rate = 0;
    }

Referenced by fers_signal::Signal::load().

Here is the caller graph for this function:

getKind()

FileWaveformKind fers_signal::FileSignal::getKind ( ) const

noexcept

Definition at line 316 of file radar_signal.h.

{ return _kind; }

getRate()

RealType fers_signal::Signal::getRate ( ) const

noexceptinherited

Gets the sample rate of the signal.

Returns

The sample rate of the signal.

Definition at line 94 of file radar_signal.h.

{ return _rate; }

getSampleCount()

unsigned fers_signal::Signal::getSampleCount ( ) const

noexceptinherited

Gets the number of native samples held by this signal.

Definition at line 97 of file radar_signal.h.

{ return _size; }

isFmcwFamily()

bool fers_signal::FileSignal::isFmcwFamily ( ) const

overridevirtualnoexcept

Returns true when this signal belongs to the FMCW waveform family.

Reimplemented from fers_signal::Signal.

Definition at line 317 of file radar_signal.h.

{ return _kind == FileWaveformKind::Fmcw; }

References fers_signal::Fmcw.

load()

void fers_signal::Signal::load ( std::span< const ComplexType >  inData, unsigned  samples, RealType  sampleRate  )

inherited

Loads complex radar waveform data.

Parameters

inData	The input span of complex signal data.
samples	The number of samples in the input data.
sampleRate	The sample rate of the input data.

Definition at line 353 of file radar_signal.cpp.

    {
        clear();
        const unsigned ratio = params::oversampleRatio();
        const auto oversampled_samples = static_cast<std::size_t>(samples) * static_cast<std::size_t>(ratio);
        if (oversampled_samples > std::numeric_limits<unsigned>::max())
        {
            throw std::overflow_error("Oversampled signal sample count exceeds unsigned range");
        }
        _data.resize(oversampled_samples);
        _size = static_cast<unsigned>(oversampled_samples);
        _rate = sampleRate * static_cast<RealType>(ratio);
 
        if (ratio == 1)
        {
            std::ranges::copy(inData, _data.begin());
        }
        else
        {
            upsample(inData, samples, _data);
        }
    }

References fers_signal::Signal::clear(), max, params::oversampleRatio(), and fers_signal::upsample().

Here is the call graph for this function:

operator=() [1/2]

FileSignal & fers_signal::FileSignal::operator= ( const FileSignal &  )

delete

operator=() [2/2]

FileSignal & fers_signal::FileSignal::operator= ( FileSignal &&  )

delete

render()

std::vector< ComplexType > fers_signal::Signal::render ( const std::vector< interp::InterpPoint > &  points, unsigned &  size, double  fracWinDelay  ) const

virtualinherited

Renders the signal data based on interpolation points.

Parameters

points	A vector of interpolation points used to render the signal.
size	Reference to store the size of the rendered data.
fracWinDelay	Fractional window delay to apply during rendering.

Returns

A vector of rendered complex signal data.

Reimplemented in fers_signal::CwSignal, fers_signal::SteppedFrequencySignal, fers_signal::FmcwChirpSignal, and fers_signal::FmcwTriangleSignal.

Definition at line 402 of file radar_signal.cpp.

    {
        size = _size;
        if (points.empty())
        {
            return std::vector<ComplexType>(_size);
        }
        return renderSlice(points, points.front().time, _rate, _size, fracWinDelay);
    }

References max, and fers_signal::Signal::renderSlice().

Here is the call graph for this function:

renderSlice()

std::vector< ComplexType > fers_signal::Signal::renderSlice ( const std::vector< interp::InterpPoint > &  points, RealType  outputStartTime, RealType  outputSampleRate, std::size_t  sampleCount, RealType  fracWinDelay  ) const

virtualinherited

Renders a bounded absolute-time slice on the requested output grid.

Definition at line 413 of file radar_signal.cpp.

    {
        auto out = std::vector<ComplexType>(sampleCount);
        if (_size == 0 || _rate <= 0.0 || outputSampleRate <= 0.0 || points.empty())
        {
            return out;
        }
 
        const RealType timestep = 1.0 / outputSampleRate;
        const int filt_length = static_cast<int>(params::renderFilterLength());
        const auto& interp = interp::InterpFilter::getInstance();
 
        auto iter = points.begin();
        auto next = points.size() > 1 ? std::next(iter) : iter;
        const RealType idelay = std::round(_rate * iter->delay);
        RealType sample_time = outputStartTime;
 
        for (std::size_t i = 0; i < sampleCount; ++i)
        {
            while (sample_time > next->time && next != iter)
            {
                iter = next;
                if (std::next(next) != points.end())
                {
                    ++next;
                }
                else
                {
                    break;
                }
            }
 
            auto [amplitude, phase, fdelay, i_sample_unwrap] =
                calculateWeightsAndDelays(iter, next, sample_time, idelay, fracWinDelay);
            const RealType native_position = (sample_time - points.front().time) * _rate;
            const auto source_index = static_cast<int>(std::floor(native_position));
            RealType source_fraction = native_position - static_cast<RealType>(source_index);
            if (source_fraction < 0.0 && source_fraction > -1.0e-12)
            {
                source_fraction = 0.0;
            }
 
            const RealType combined_delay = fdelay + source_fraction;
            const auto delay_unwrap = static_cast<int>(std::floor(combined_delay));
            fdelay = combined_delay - static_cast<RealType>(delay_unwrap);
            i_sample_unwrap += delay_unwrap;
 
            const auto& filt = interp.getFilter(fdelay);
            const ComplexType accum =
                performConvolution(source_index, filt.data(), filt_length, amplitude, i_sample_unwrap);
            out[i] = std::exp(ComplexType(0.0, 1.0) * phase) * accum;
 
            sample_time += timestep;
        }
 
        return out;
    }

References interp::InterpFilter::getInstance(), max, and params::renderFilterLength().

Referenced by fers_signal::Signal::render().

Here is the call graph for this function:

Here is the caller graph for this function:

sampleAt()

ComplexType fers_signal::Signal::sampleAt ( RealType  time_since_start ) const

noexceptinherited

Samples the finite stored complex envelope using the render interpolation filter.

Times outside [0, duration) return zero; file-backed signals never wrap implicitly.

Definition at line 376 of file radar_signal.cpp.

    {
        if (_data.empty() || _rate <= 0.0 || !std::isfinite(time_since_start) || time_since_start < 0.0 ||
            time_since_start >= static_cast<RealType>(_size) / _rate)
        {
            return {0.0, 0.0};
        }
 
        const RealType position = time_since_start * _rate;
        const auto center = static_cast<long long>(std::floor(position));
        const RealType fraction = position - std::floor(position);
        const auto& filter = interp::InterpFilter::getInstance().getFilter(fraction);
        const auto filter_length = static_cast<long long>(filter.size());
        const auto sample_count = static_cast<long long>(_data.size());
        ComplexType value{0.0, 0.0};
        for (long long tap = 0; tap < filter_length; ++tap)
        {
            const long long sample_index = center + tap - filter_length / 2;
            if (sample_index >= 0 && sample_index < sample_count)
            {
                value += _data[static_cast<std::size_t>(sample_index)] * filter[static_cast<std::size_t>(tap)];
            }
        }
        return value;
    }

References interp::InterpFilter::getFilter(), interp::InterpFilter::getInstance(), max, and position.

Here is the call graph for this function:

---

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

• packages/libfers/src/signal/radar_signal.h