### Introduction

Filtering algorithms are techniques used in data processing for screening and extracting specific data. Their core purpose is to identify and retain data that meets specific conditions from a large amount of data while excluding irrelevant data.

### Median Filter Algorithm

The median filter algorithm is a non-linear filtering technique mainly used to eliminate noise, especially salt-and-pepper noise, while preserving the edge information of images. The following will explain in detail the principle, implementation, and application of the median filter algorithm:

- **Basic Principle**
    - **Concept**: The basic principle of the median filter algorithm is to replace the gray value of a pixel with the median of the gray values of all pixels in its neighborhood. This algorithm can effectively remove isolated noise points while keeping image details from being blurred.
    - **Neighborhood Selection**: Usually, a two-dimensional sliding template (such as 3×3 or 5×5) is used. The pixel values within the template are sorted, and the value in the middle position is taken as the new value of the current pixel.

- **Implementation Method**
    - **Data Sorting**: Use a sorting algorithm (such as bubble sort, quick sort, etc.) to sort the data in the neighborhood and then select the median.
    - **Boundary Processing**: For pixels on the image boundary, methods such as not processing, repeating boundary values, filling with 0, or reducing the window size can be chosen for processing.

- **Application Scenarios**
    - **Image Denoising**: The median filter is especially suitable for removing salt-and-pepper noise and is widely used in the field of digital image processing.
    - **Signal Processing**: In one-dimensional signal processing, the median filter can also be used to eliminate abnormal data points and smooth the signal.

- **Advantages and Disadvantages**
    - **Advantages**: The median filter can well preserve edge information while removing noise and has a remarkable effect on salt-and-pepper noise.
    - **Disadvantages**: It has a relatively large computational cost, especially for large-sized windows, requiring more computing resources and time.

### Kalman Filter Algorithm

The Kalman filter algorithm is an efficient autoregressive data processing algorithm mainly used for data fusion, state estimation, and prediction update. It combines data from different sensors to obtain more accurate measurement values and state estimates. The following will explain in detail the principle, implementation, and application of the Kalman filter algorithm:

- **Basic Principle**
    - **Concept**: The Kalman filter is essentially a data fusion algorithm that fuses data with the same measurement purpose but from different sensors to obtain a more accurate measurement value for the target. Its core lies in using the state of the previous moment (and possible measurement values) to obtain the optimal estimate of the state at the current moment.
    - **Limitations**: The Kalman filter can only fit linear Gaussian systems, but it has a small computational amount and high efficiency.

- **Implementation Method**
    - **Prediction Update**: Based on the state and motion measurement values of the previous moment, predict the state vector and covariance matrix of the current moment through the state transition equation. This step increases uncertainty because both state transitions and motion measurements have noise.
    - **Measurement Update**: When new measurement values are obtained, use the measurement model to correct the predicted state to obtain a more accurate state estimate. This step requires calculating the Kalman gain and updating the state vector and covariance matrix.

- **Application Scenarios**
    - **Satellite Navigation**: In applications combining GPS and IMU, the Kalman filter is often used to fuse data from different sensors to improve navigation accuracy.
    - **SLAM**: Although the mainstream trend of SLAM is graph optimization, the Kalman filter still provides a good reference for data fusion.

- **Advantages and Disadvantages**
    - **Advantages**: It has a small computational amount and is suitable for real-time applications; it can effectively fuse multi-sensor data and improve the accuracy of state estimation.
    - **Disadvantages**: It is limited to linear Gaussian systems. For nonlinear or non-Gaussian systems, improved algorithms such as the extended Kalman filter or unscented Kalman filter need to be used.

### Average Filter Algorithm

The average filter algorithm is a simple linear filtering technique mainly used to smooth data and eliminate noise. It replaces the value of a pixel with the average of all pixel values in its surrounding neighborhood. The following will explain in detail the principle, implementation, and application of the average filter algorithm:

- **Basic Principle**
    - **Concept**: The basic principle of the average filter algorithm is to replace the gray value of a pixel with the average of the gray values of all pixels in its neighborhood. This algorithm can effectively smooth the image and eliminate high-frequency noise, but it may lead to the loss of image details.
    - **Neighborhood Selection**: Usually, a two-dimensional sliding template (such as 3×3 or 5×5) is used. The pixel values within the template are averaged, and the result is taken as the new value of the current pixel.

- **Implementation Method**
    - **Data Smoothing**: Achieve data smoothing by calculating the average of the data within the sliding window. For example, for a one-dimensional data set, you can select n data points before and after, and calculate the average of these 2n + 1 points as the filtered value of the current point.
    - **Boundary Processing**: For pixels on the image boundary, methods such as not processing, repeating boundary values, filling with 0, or reducing the window size can be chosen for processing.

- **Application Scenarios**
    - **Image Processing**: The average filter is widely used in image denoising and smoothing processing, especially for dealing with random white noise.
    - **Signal Processing**: In one-dimensional signal processing, the average filter can also be used to eliminate abnormal data points and smooth the signal.

- **Advantages and Disadvantages**
    - **Advantages**: The algorithm is simple, has a small computational amount, and is suitable for real-time applications; it can effectively smooth data and eliminate random noise.
    - **Disadvantages**: It will cause the loss of image details and lead to edge blurring; it has limited effect on non-random noise such as Gaussian noise.

- **Improved Algorithms**
    - **Weighted Average Filter**: By performing a weighted average on the pixel values in the neighborhood, different weights can be assigned according to the distance from the central pixel, so as to better preserve image details.
    - **Adaptive Average Filter**: Automatically adjust the sliding window size or weights according to the local characteristics of the image to meet the needs of different regions.

### Interface

```c
void filter_median(double *data, int size, int window);
void filter_kalman(double *measurements, double *estimates, int numMeasurements, double processNoise, double measurementNoise);
void filter_average(double *data, int size, int window);
```

### Testing

```c
static void test_median(void)
{
    double data[] = {1, 2, 3, 2.5, 3.5, 2, 3, 4, 5};
    int size = sizeof(data) / sizeof(data[0]);
    int windowSize = 3;

    filter_median(data, size, windowSize);

    printf("Filtered data: \n");
    for (int i = 0; i < size; i++) 
    {
        printf("%f ", data[i]);
    }
    printf("\n");
}
```

**Result**

```
2.000000 2.000000 2.500000 2.500000 2.500000 2.500000 3.000000 4.000000 4.000000
```

```c
static void test_average(void)
{
    double data[] = {1, 2, 3, 2.5, 3.5, 2, 3, 4, 5};
    int size = sizeof(data) / sizeof(data[0]);
    int windowSize = 3;
    
    filter_average(data, size, windowSize);

    printf("Filtered data: \n");
    for (int i = 0; i < size; i++) 
    {
        printf("%f ", data[i]);
    }
    printf("\n");
}
```

**Result**

```
1.000000 2.000000 2.500000 2.833333 2.777778 2.592593 3.197531 4.065844 3.021948
```

```c
static void test_kalman(void)
{
    double measurements[] = {1.0, 2.0, 3.0, 2.5, 3.5, 2.0, 3.0, 4.0, 5.0};
    double estimates[1];
    int numMeasurements = sizeof(measurements) / sizeof(measurements[0]);
    double processNoise = 0.1;
    double measurementNoise = 0.2;
    
    filter_kalman(measurements, estimates, numMeasurements, processNoise, measurementNoise);

    printf("Estimated value: %f\n", estimates[0]);
}
```

**Result**

```
Estimated value: 2.826087
```