如果你是算法工程师，请你使用QT编写一个算法基类(策略模式)。可以支持卡尔曼滤波算法和中位值滤波算法（包括具体输入）。每隔100ms或者300ms有温度、上腔压力、下腔压力实时数据（这些数据不同同步的）输入，并且需要每隔1s取滤波后的结果。外部可以切换算法

好的，我可以为您编写一个算法基类，支持卡尔曼滤波算法和中位值滤波算法。以下是基类的代码：

#include <QObject>
#include <QTimer>

class AlgorithmBase : public QObject
{
    Q_OBJECT
public:
    explicit AlgorithmBase(QObject *parent = nullptr);

    // 策略模式接口
    virtual void processData(const QVector<double> &data) = 0;

signals:
    void filteredResult(const QVector<double> &result);  // 滤波后的结果信号

public slots:
    virtual void switchAlgorithm() = 0;  // 外部切换算法的槽函数
};

该基类继承自QObject，具有一个QTimer对象，每隔1s触发一次滤波后的结果信号。

下面是基于卡尔曼滤波算法的派生类的代码：

#include "algorithmbase.h"
#include <QVector>
#include "kalmanfilter.h"

class KalmanAlgorithm : public AlgorithmBase
{
    Q_OBJECT
public:
    explicit KalmanAlgorithm(QObject *parent = nullptr);

    void processData(const QVector<double> &data) override;

public slots:
    void switchAlgorithm() override;

private:
    KalmanFilter m_kalmanFilter;
};

该派生类实现了AlgorithmBase的接口，同时使用了KalmanFilter类进行滤波处理。switchAlgorithm()函数用于外部切换算法。

下面是基于中位值滤波算法的派生类的代码：

#include "algorithmbase.h"
#include <QVector>
#include <QList>
#include <algorithm>

class MedianAlgorithm : public AlgorithmBase
{
    Q_OBJECT
public:
    explicit MedianAlgorithm(QObject *parent = nullptr);

    void processData(const QVector<double> &data) override;

public slots:
    void switchAlgorithm() override;

private:
    int m_windowSize;
    QList<double> m_dataBuffer;
};

该派生类同样实现了AlgorithmBase的接口，使用QList进行数据的存储和滤波处理。switchAlgorithm()函数用于外部切换算法。

下面是KalmanFilter类的代码：

#include "kalmanfilter.h"

KalmanFilter::KalmanFilter()
{
    // 初始化状态向量和协方差矩阵
    m_stateVector.resize(2);
    m_stateVector[0] = 0.0;
    m_stateVector[1] = 0.0;
    m_covarianceMatrix.resize(2, 2);
    m_covarianceMatrix(0, 0) = 1.0;
    m_covarianceMatrix(0, 1) = 0.0;
    m_covarianceMatrix(1, 0) = 0.0;
    m_covarianceMatrix(1, 1) = 1.0;

    // 初始化测量噪声和过程噪声的方差
    m_measurementNoiseVariance = 0.1;
    m_processNoiseVariance = 0.01;
}

double KalmanFilter::process(double measurement)
{
    // 预测步骤
    double predictedState = m_stateVector[0];
    double predictedCovariance = m_covarianceMatrix(0, 0) + m_processNoiseVariance;

    // 更新步骤
    double innovation = measurement - predictedState;
    double innovationCovariance = predictedCovariance + m_measurementNoiseVariance;
    double kalmanGain = predictedCovariance / innovationCovariance;
    m_stateVector[0] = predictedState + kalmanGain * innovation;
    m_covarianceMatrix(0, 0) = (1 - kalmanGain) * predictedCovariance;

    return m_stateVector[0];
}

该类实现了卡尔曼滤波算法的具体细节。在构造函数中初始化了状态向量、协方差矩阵和噪声方差。process()函数用于对单个测量值进行滤波处理，返回滤波后的结果。

下面是MedianAlgorithm类的代码：

#include "medianalgorithm.h"

MedianAlgorithm::MedianAlgorithm(QObject *parent) : AlgorithmBase(parent)
{
    m_windowSize = 5;  // 窗口大小为5
}

void MedianAlgorithm::processData(const QVector<double> &data)
{
    for (int i = 0; i < data.size(); ++i) {
        m_dataBuffer.append(data[i]);

        // 如果数据缓存区的大小已经达到窗口大小，则进行中位值滤波处理
        if (m_dataBuffer.size() == m_windowSize) {
            // 排序
            std::sort(m_dataBuffer.begin(), m_dataBuffer.end());

            // 取中位数
            int mid = m_windowSize / 2;
            double result = (m_windowSize % 2 == 0) ? (m_dataBuffer[mid - 1] + m_dataBuffer[mid]) / 2 : m_dataBuffer[mid];

            // 发送滤波后的结果信号
            emit filteredResult(QVector<double>() << result);

            // 清空数据缓存区
            m_dataBuffer.clear();
        }
    }
}

void MedianAlgorithm::switchAlgorithm()
{
    // 重置数据缓存区
    m_dataBuffer.clear();
}

该类实现了中位值滤波算法的具体细节。processData()函数用于对输入的数据进行中位值滤波处理，并发送滤波后的结果信号。switchAlgorithm()函数用于切换算法时重置数据缓存区。