c++编程实现knn均值滤波算法

KNN均值滤波算法是一种图像处理算法，可以用于去除图像中的噪声。下面是C语言实现KNN均值滤波算法的代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define K 5 // KNN中K的值，可以根据实际情况进行调整

int main()
{
    int m, n; // 图像的行数和列数
    printf("请输入图像的行数和列数：");
    scanf("%d %d", &m, &n);

    int **img = (int **)malloc(m * sizeof(int *)); // 原始图像
    int **img_filter = (int **)malloc(m * sizeof(int *)); // 过滤后的图像
    for (int i = 0; i < m; i++) {
        img[i] = (int *)malloc(n * sizeof(int));
        img_filter[i] = (int *)malloc(n * sizeof(int));
    }

    // 读入原始图像
    printf("请输入原始图像：\n");
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &img[i][j]);
        }
    }

    // KNN均值滤波
    int sum, count;
    int rows[K], cols[K], dist[K];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            sum = count = 0;
            for (int k = 0; k < K; k++) {
                dist[k] = 999999; // 初始化为一个极大值
            }
            for (int ii = 0; ii < m; ii++) {
                for (int jj = 0; jj < n; jj++) {
                    if (ii == i && jj == j) { // 排除当前像素
                        continue;
                    }
                    int d = abs(img[i][j] - img[ii][jj]); // 计算距离
                    if (d < dist[K - 1]) { // 如果距离比KNN中最大的距离小
                        // 将该像素插入KNN中，并按距离从小到大排序
                        dist[K - 1] = d;
                        rows[K - 1] = ii;
                        cols[K - 1] = jj;
                        for (int kk = K - 2; kk >= 0; kk--) {
                            if (dist[kk] > dist[kk + 1]) {
                                // 交换位置
                                int temp = dist[kk];
                                dist[kk] = dist[kk + 1];
                                dist[kk + 1] = temp;
                                temp = rows[kk];
                                rows[kk] = rows[kk + 1];
                                rows[kk + 1] = temp;
                                temp = cols[kk];
                                cols[kk] = cols[kk + 1];
                                cols[kk + 1] = temp;
                            } else {
                                break;
                            }
                        }
                    }
                }
            }
            for (int k = 0; k < K; k++) {
                if (dist[k] == 999999) { // 如果KNN中没有像素，即当前像素是孤立的
                    continue;
                }
                sum += img[rows[k]][cols[k]];
                count++;
            }
            img_filter[i][j] = sum / count; // 取均值
        }
    }

    // 输出过滤后的图像
    printf("过滤后的图像为：\n");
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", img_filter[i][j]);
        }
        printf("\n");
    }

    // 释放内存
    for (int i = 0; i < m; i++) {
        free(img[i]);
        free(img_filter[i]);
    }
    free(img);
    free(img_filter);

    return 0;
}

需要注意的是，上面的代码只是一种简单的实现方式，实际应用中可能需要进行优化和改进。