image-analysis/Filters.cpp at main · Amine830/image-analysis · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#include <opencv2/opencv.hpp>

cv::Mat applyMedianFilter(const cv::Mat &src, int kernelSize){
    cv::Mat dst = src.clone();
    int border = kernelSize / 2;

    for (int y = border; y < src.rows - border; ++y) {
        for (int x = border; x < src.cols - border; ++x) {
            for (int c = 0; c < src.channels(); ++c) {
                std::vector<uchar> neighborhood;

                for (int ky = -border; ky <= border; ++ky) {
                    for (int kx = -border; kx <= border; ++kx) {
                        neighborhood.push_back(src.at<cv::Vec3b>(y + ky, x + kx)[c]);
                    }
                }

                std::sort(neighborhood.begin(), neighborhood.end());
                dst.at<cv::Vec3b>(y, x)[c] = neighborhood[neighborhood.size() / 2];
            }
        }
    }

    return dst;
}

cv::Mat applyGaussianBlur(const cv::Mat &src, int kernelSize, double sigma)
{
    cv::Mat dst = src.clone();
    int border = kernelSize / 2;

    std::vector<std::vector<double>> kernel(kernelSize, std::vector<double>(kernelSize));
    double sum = 0.0;

    // Créer le noyau de convolution
    for (int y = -border; y <= border; ++y)
    {
        for (int x = -border; x <= border; ++x)
        {
            kernel[y + border][x + border] = exp(-(x * x + y * y) / (2 * sigma * sigma)) / (2 * CV_PI * sigma * sigma);
            sum += kernel[y + border][x + border];
        }
    }

    // Normaliser le noyau
    for (int y = 0; y < kernelSize; ++y)
    {
        for (int x = 0; x < kernelSize; ++x)
        {
            kernel[y][x] /= sum;
        }

    }

    for (int y = border; y < src.rows - border; ++y)
    {
        for (int x = border; x < src.cols - border; ++x)
        {
            for (int c = 0; c < src.channels(); ++c)
            {
                double sum = 0.0;

                for (int ky = -border; ky <= border; ++ky)
                {
                    for (int kx = -border; kx <= border; ++kx)
                    {
                        sum += src.at<cv::Vec3b>(y + ky, x + kx)[c] * kernel[ky + border][kx + border];
                    }
                }

                dst.at<cv::Vec3b>(y, x)[c] = static_cast<uchar>(sum);
            }
        }
    }

    return dst;
}

cv::Mat applySobelFilter(const cv::Mat &src)
{
    cv::Mat dst = src.clone();
    cv::Mat kernel_x = (cv::Mat_<int>(5, 5) << -1, 0, 1, -2, 0, 2, -1, 0, 1);
    cv::Mat kernel_y = (cv::Mat_<int>(3, 3) << -1, -2, -1, 0, 0, 0, 1, 2, 1);

    int border = 1;

    for (int y = border; y < src.rows - border; ++y)
    {
        for (int x = border; x < src.cols - border; ++x)
        {
            for (int c = 0; c < src.channels(); ++c)
            {
                double sum_x = 0.0;
                double sum_y = 0.0;

                for (int ky = -border; ky <= border; ++ky)
                {
                    for (int kx = -border; kx <= border; ++kx)
                    {
                        sum_x += src.at<cv::Vec3b>(y + ky, x + kx)[c] * kernel_x.at<int>(ky + border, kx + border);
                        sum_y += src.at<cv::Vec3b>(y + ky, x + kx)[c] * kernel_y.at<int>(ky + border, kx + border);
                    }
                }

                double sum = sqrt(sum_x * sum_x + sum_y * sum_y);
                dst.at<cv::Vec3b>(y, x)[c] = static_cast<uchar>(sum);
            }
        }
    }

    return dst;
}

cv::Mat applyMeanFilter(const cv::Mat &src, int kernelSize)
{
    cv::Mat dst = src.clone();
    int border = kernelSize / 2;

    for (int y = border; y < src.rows - border; ++y)
    {
        for (int x = border; x < src.cols - border; ++x)
        {
            for (int c = 0; c < src.channels(); ++c)
            {
                float sum = 0.0;
                int count = 0;

                for (int ky = -border; ky <= border; ++ky)
                {
                    for (int kx = -border; kx <= border; ++kx)
                    {
                        sum += src.at<cv::Vec3b>(y + ky, x + kx)[c];
                        count++;
                    }
                }

                dst.at<cv::Vec3b>(y, x)[c] = static_cast<uchar>(sum / count);
            }
        }
    }

    return dst;
}