Using high-pass filters in C#

Question

I generated a 1 Hz sine waveform for 10 seconds. I passed it through a second-order high-pass filter with a cutoff frequency of 3 Hz. I saved them to CSV. I graphed them in Python. But it is not nearly attenuated. What am I doing wrong? I try a similar process in Python and it is attenuated.

I use this.

https://filtering.mathdotnet.com/api/MathNet.Filtering/OnlineFilter.htm#CreateHighpass

Maybe I should use ImpulseResponse.Infinite instead of ImpulseResponse.Finite. But when I use it, the value keeps increasing and I don't get a decaying sine waveform.

But maybe I should use this.

https://filtering.mathdotnet.com/api/MathNet.Filtering.Butterworth/IirCoefficients.htm#HighPass

If I give each of the following parameters, how should I replace the current code?

stopbandFreq = 1.0
passbandFreq = 4.0
passbandRipple = 1.0
stopbandAttenuation = -20.0

Code by C#

using System;
using MathNet.Filtering;
using MathNet.Numerics;
using System.IO;
using System.Globalization;

class Program
{
    const double sampleFreq = 600;
    const double amplitude = 100;
    const double frequency = 1;
    const double duration = 10;
    const double samplePeriod = 1.0 / sampleFreq;
    const double cutOffFrequency = 3;
    const int filterOrder = 2;

    static void Main(string[] args)
    {
        var sampleCount = sampleFreq * duration;
        var signal = Generate.Sinusoidal((int)sampleCount, sampleFreq, frequency, amplitude);

        var filter = OnlineFilter.CreateHighpass(ImpulseResponse.Finite, sampleFreq, cutOffFrequency, filterOrder);
        var filteredSignal = filter.ProcessSamples(signal);

        string path = "data_csharp.csv";
        string header = "Time,RawData_uV,FilteredRawData_uV";

        using (StreamWriter sw = new StreamWriter(path))
        {
            sw.WriteLine(header);
            for (int i = 0; i < sampleCount; i++)
            {
                DateTime datetime = DateTime.Now.AddSeconds(i * samplePeriod);
                sw.WriteLine(String.Format("{0},{1},{2}", datetime.ToString("yyyy/MM/dd HH:mm:ss.fff", CultureInfo.CurrentCulture), signal[i], filteredSignal[i]));
            }
        }
    }
}

Code by Python

import numpy as np
from scipy import signal
import pandas as pd
from datetime import datetime, timedelta
# from matplotlib import pyplot as plt

def generate_dummy_signal(frequency, amplitude, duration, sample_rate):
    time = np.arange(0, duration, 1/sample_rate)
    signal = amplitude * np.sin(2 * np.pi * frequency * time)
    return time, signal

def apply_hpf(input_signal, cutoff_frequency, sample_rate, order):
    b, a = signal.butter(order, cutoff_frequency, btype='high', analog=False, fs=sample_rate)
    filtered_signal = signal.lfilter(b, a, input_signal)
    return filtered_signal

# Constants
FREQUENCY = 1  # in Hz
AMPLITUDE = 100  # in µV
DURATION = 10  # in seconds
SAMPLE_RATE = 600  # in Hz
CUTOFF_FREQUENCY = 3  # in Hz
ORDER = 2  # order of the filter

# Generate the dummy signal
time, raw_signal = generate_dummy_signal(FREQUENCY, AMPLITUDE, DURATION, SAMPLE_RATE)

# Apply the HPF
filtered_signal = apply_hpf(raw_signal, CUTOFF_FREQUENCY, SAMPLE_RATE, ORDER)

# Generate time-series starting from current timestamp
timestamps = [datetime.now() + timedelta(seconds=time[i]) for i in range(len(time))]

# Create dictionary for creating DataFrame
data_dict = {
    'Time': timestamps,
    'RawData_uV': raw_signal,
    'FilteredRawData_uV': filtered_signal
}

# Create DataFrame
data_df = pd.DataFrame(data_dict)

# Write DataFrame to CSV
data_df.to_csv('data.csv', index=False)

Generated csv by C# graphed in Python

Generated csv by C# (Infinite) graphed in Python

Generated csv by Python graphed in Python

Answer 1

I finally completed the HPF using the following method. A little too attenuated but I was able to attenuate it.

        //var filter = OnlineFilter.CreateHighpass(ImpulseResponse.Infinite, sampleFreq, cutOffFrequency, filterOrder);
        //var filteredSignal = filter.ProcessSamples(signal);

        var passBandFreq = 4 / (sampleFreq / 2.0);
        var stopBandFreq = 1 / (sampleFreq / 2.0);
        var passBandRipple = 1.0;
        var stopBandAttenuation = 20.0;
        var coefficients = MathNet.Filtering.Butterworth.IirCoefficients.HighPass(stopBandFreq, passBandFreq, passBandRipple, stopBandAttenuation);

        var coeffs = new List<double>();
        foreach (var numerator in coefficients.numerator)
        {
            coeffs.Add(numerator);
        }
        foreach (var denominator in coefficients.denominator)
        {
            coeffs.Add(denominator);
        }
        var filter = new MathNet.Filtering.IIR.OnlineIirFilter(coeffs.ToArray());
        var filteredSignal = filter.ProcessSamples(signal);