MatchedFilter.cs

using System;
using System.Linq;

namespace SDRSharp.TimeDomainScope
{
    public enum PulseShape
    {
        Square,
        RaisedCosine,
        Gaussian
    }

    public enum CarrierWaveform
    {
        None,        // No carrier - envelope only
        Sine,        // Sine wave carrier
        Square,      // Square wave carrier
        Triangle,    // Triangle wave carrier
        Sawtooth     // Sawtooth wave carrier
    }

    public enum FilterMode
    {
        FilterInputSignal,
        FilterEnvelopeOnly
    }

    public enum FilterQuality
    {
        Fast,           // Downsample for speed
        High            // No downsampling, full quality
    }

    public class MatchedFilter
    {
        private float[] _template;
        private float[] _filterOutput;
        private readonly object _lock = new object();

        // Signal parameters - SAME AS SIGNAL GENERATOR
        private double _sampleRate = 250000;
        private double _pulseWidth = 50.0;           // milliseconds (ON time)
        private double _dutyCycle = 50.0;            // percentage (0-100)
        private double _carrierFrequency = 0;        // Hz
        private PulseShape _pulseShape = PulseShape.Square;
        private CarrierWaveform _carrierWaveform = CarrierWaveform.None;

        // Filter parameters
        private FilterMode _filterMode = FilterMode.FilterEnvelopeOnly;
        private FilterQuality _quality = FilterQuality.Fast;
        private bool _enabled = false;

        // Template generation mode
        private bool _useOOKPattern = false;

        public bool Enabled
        {
            get => _enabled;
            set => _enabled = value;
        }

        public double SampleRate
        {
            get => _sampleRate;
            set
            {
                if (_sampleRate != value)
                {
                    _sampleRate = value;
                    GenerateTemplate();
                }
            }
        }

        public double PulseWidthMs
        {
            get => _pulseWidth;
            set
            {
                if (_pulseWidth != value)
                {
                    _pulseWidth = value;
                    GenerateTemplate();
                }
            }
        }

        public double DutyCycle
        {
            get => _dutyCycle;
            set
            {
                if (_dutyCycle != value && value >= 0 && value <= 100)
                {
                    _dutyCycle = value;
                    GenerateTemplate();
                }
            }
        }

        public double PulsePeriod
        {
            get
            {
                if (_dutyCycle > 0 && _dutyCycle < 100)
                    return _pulseWidth / (_dutyCycle / 100.0);
                return _pulseWidth * 2;
            }
        }

        public double OffTimeMs
        {
            get { return PulsePeriod - _pulseWidth; }
        }

        public double CarrierFrequency
        {
            get => _carrierFrequency;
            set
            {
                if (_carrierFrequency != value)
                {
                    _carrierFrequency = value;
                    GenerateTemplate();
                }
            }
        }

        public PulseShape Shape
        {
            get => _pulseShape;
            set
            {
                if (_pulseShape != value)
                {
                    _pulseShape = value;
                    GenerateTemplate();
                }
            }
        }

        public CarrierWaveform Carrier
        {
            get => _carrierWaveform;
            set
            {
                if (_carrierWaveform != value)
                {
                    _carrierWaveform = value;
                    GenerateTemplate();
                }
            }
        }

        public bool UseOOKPattern
        {
            get => _useOOKPattern;
            set
            {
                if (_useOOKPattern != value)
                {
                    _useOOKPattern = value;
                    GenerateTemplate();
                }
            }
        }

        public FilterMode Mode
        {
            get => _filterMode;
            set => _filterMode = value;
        }

        public FilterQuality Quality
        {
            get => _quality;
            set => _quality = value;
        }

        public MatchedFilter()
        {
            GenerateTemplate();
        }

        private void GenerateTemplate()
        {
            lock (_lock)
            {
                if (_sampleRate <= 0 || _pulseWidth <= 0)
                    return;

                int templateLength;

                if (_useOOKPattern)
                {
                    double periodSec = PulsePeriod / 1000.0;
                    templateLength = (int)(_sampleRate * periodSec);
                }
                else
                {
                    double pulseWidthSec = _pulseWidth / 1000.0;
                    templateLength = (int)(_sampleRate * pulseWidthSec);
                }

                if (templateLength <= 0)
                    return;

                _template = new float[templateLength];

                int onSamples = (int)(_sampleRate * _pulseWidth / 1000.0);

                for (int i = 0; i < templateLength; i++)
                {
                    float sample;

                    if (_useOOKPattern)
                    {
                        if (i < onSamples)
                        {
                            float t = (float)i / onSamples;
                            float envelope = GenerateEnvelope(t);
                            float carrier = GenerateCarrier(i);
                            sample = envelope * carrier;
                        }
                        else
                        {
                            sample = 0.0f;
                        }
                    }
                    else
                    {
                        float t = (float)i / templateLength;
                        float envelope = GenerateEnvelope(t);
                        float carrier = GenerateCarrier(i);
                        sample = envelope * carrier;
                    }

                    _template[i] = sample;
                }

                float maxVal = _template.Max(Math.Abs);
                if (maxVal > 0)
                {
                    for (int i = 0; i < _template.Length; i++)
                    {
                        _template[i] /= maxVal;
                    }
                }
            }
        }

        private float GenerateEnvelope(float t)
        {
            switch (_pulseShape)
            {
                case PulseShape.Square:
                    return 1.0f;

                case PulseShape.RaisedCosine:
                    return 0.5f * (1.0f - (float)Math.Cos(2 * Math.PI * t));

                case PulseShape.Gaussian:
                    float sigma = 0.3f;
                    float x = (t - 0.5f) / sigma;
                    return (float)Math.Exp(-0.5 * x * x);

                default:
                    return 1.0f;
            }
        }

        private float GenerateCarrier(int sampleIndex)
        {
            if (_carrierWaveform == CarrierWaveform.None || _carrierFrequency == 0)
                return 1.0f;

            float phase = (float)(2.0 * Math.PI * _carrierFrequency * sampleIndex / _sampleRate);

            while (phase < 0) phase += 2.0f * (float)Math.PI;
            while (phase >= 2.0f * Math.PI) phase -= 2.0f * (float)Math.PI;

            switch (_carrierWaveform)
            {
                case CarrierWaveform.None:
                    return 1.0f;

                case CarrierWaveform.Sine:
                    return (float)Math.Cos(phase);

                case CarrierWaveform.Square:
                    return phase < Math.PI ? 1.0f : -1.0f;

                case CarrierWaveform.Triangle:
                    if (phase < Math.PI)
                        return -1.0f + (2.0f * phase / (float)Math.PI);
                    else
                        return 3.0f - (2.0f * phase / (float)Math.PI);

                case CarrierWaveform.Sawtooth:
                    return -1.0f + (phase / (float)Math.PI);

                default:
                    return (float)Math.Cos(phase);
            }
        }

        public unsafe float[] ApplyFilter(float[] input)
        {
            if (input == null || _template == null)
                return null;

            if (!_enabled)
            {
                float[] passthrough = new float[input.Length];
                Array.Copy(input, passthrough, input.Length);
                return passthrough;
            }

            lock (_lock)
            {
                int inputLength = input.Length;
                int templateLength = _template.Length;

                if (inputLength < templateLength)
                {
                    return new float[inputLength];
                }

                float[] output = new float[inputLength];

                int step = (_quality == FilterQuality.Fast) ? 2 : 1;

                if (_quality == FilterQuality.Fast && inputLength > 10000)
                {
                    step = Math.Min(4, inputLength / 5000);
                }

                fixed (float* pInput = input, pTemplate = _template, pOutput = output)
                {
                    int halfTemplate = templateLength / 2;

                    for (int i = halfTemplate; i < inputLength - halfTemplate; i += step)
                    {
                        float sum = 0;
                        float* inputPtr = pInput + i - halfTemplate;
                        float* templatePtr = pTemplate;

                        for (int j = 0; j < templateLength; j++)
                        {
                            sum += inputPtr[j] * templatePtr[j];
                        }

                        pOutput[i] = sum;

                        if (step > 1 && i + step < inputLength - halfTemplate)
                        {
                            float nextSum = 0;
                            float* nextInputPtr = pInput + i + step - halfTemplate;

                            for (int j = 0; j < templateLength; j++)
                            {
                                nextSum += nextInputPtr[j] * templatePtr[j];
                            }

                            for (int k = 1; k < step && i + k < inputLength; k++)
                            {
                                float alpha = (float)k / step;
                                pOutput[i + k] = sum * (1 - alpha) + nextSum * alpha;
                            }
                        }
                    }
                }

                _filterOutput = output;
                return output;
            }
        }

        public float[] GetFilterOutput()
        {
            lock (_lock)
            {
                if (_filterOutput == null)
                    return null;

                float[] copy = new float[_filterOutput.Length];
                Array.Copy(_filterOutput, copy, _filterOutput.Length);
                return copy;
            }
        }

        public float[] GetTemplate()
        {
            lock (_lock)
            {
                if (_template == null)
                    return null;

                float[] copy = new float[_template.Length];
                Array.Copy(_template, copy, _template.Length);
                return copy;
            }
        }

        public string GetTemplateDescription()
        {
            string desc = $"{_pulseShape} envelope";

            if (_carrierWaveform != CarrierWaveform.None)
            {
                desc += $" × {_carrierWaveform} carrier @ {_carrierFrequency / 1000:F1}kHz";
            }

            desc += $", PW:{_pulseWidth:F1}ms, Duty:{_dutyCycle:F0}%";

            if (_useOOKPattern)
            {
                desc += $" (Full OOK: {PulsePeriod:F1}ms period)";
            }

            return desc;
        }
    }
}