• 一、实验内容及原理 1、均值滤波 ... (注:请分别为图像添加高斯噪声、胡椒噪声、盐噪声和椒盐噪声,并观察 滤波效果) (1)算术均值滤波器 f^(x,y)=1mn∑g(s,t)\hat {f}(x,y)=\frac {1}{mn}\sum g(s,t)...

    一、实验内容及原理

    1、均值滤波

    具体内容:利用 OpenCV 对灰度图像像素进行操作,分别利用算术均值滤波器、几何均值滤波器、谐波和逆谐波均值滤波器进行图像去噪。模板大小为 5*5。 (注:请分别为图像添加高斯噪声、胡椒噪声、盐噪声和椒盐噪声,并观察 滤波效果)

    (1)算术均值滤波器

    f^(x,y)=1mng(s,t)\hat {f}(x,y)=\frac {1}{mn}\sum g(s,t)

    (2)几何均值滤波器

    f^(x,y)=[g(s,t)]1mn\hat {f}(x,y)=[\prod g(s,t)]^{\frac {1}{mn}}

    注:这个累乘很容易会超过int或者long的表示范围,建议每n个灰度一起乘,再开根号

    (3)谐波均值滤波器

    f^(x,y)=mn1g(s,t)\hat {f}(x,y)=\frac {mn}{\frac {1}{\sum g(s,t)}}

    (4)逆谐波均值滤波器

    f^(x,y)=g(s,t)Q+1g(s,t)Q\hat {f}(x,y)=\frac {\sum g(s,t)^{Q+1}}{\sum g(s,t)^Q}

    2、中值滤波

    具体内容:利用 OpenCV 对灰度图像像素进行操作,分别利用555*5999*9 尺寸的模板对图像进行中值滤波。(注:请分别为图像添加胡椒噪声、盐噪声和 椒盐噪声,并观察滤波效果)

    3、自适应均值滤波。

    具体内容:利用 OpenCV 对灰度图像像素进行操作,设计自适应局部降 低噪声滤波器去噪算法。模板大小 7*7(对比该算法的效果和均值滤波器的效果)

    f^(x,y)=g(s,t)ση2σL2[g(s,t)mL]\hat {f}(x,y)=g(s,t)-\frac {\sigma_\eta^2}{\sigma_L^2}[g(s,t)-m_L]

    4、自适应中值滤波

    具体内容:利用 OpenCV 对灰度图像像素进行操作,设计自适应中值滤波算 法对椒盐图像进行去噪。模板大小 7*7(对比中值滤波器的效果)
    在这里插入图片描述
    在这里插入图片描述

    5、彩色图像均值滤波

    具体内容:利用 OpenCV 对彩色图像 RGB 三个通道的像素进行操作,利用算 术均值滤波器和几何均值滤波器进行彩色图像去噪。模板大小为 5*5

    二、实验代码

    实验环境:
    (1)OpenCV3.4.3
    (2)Ubuntu16.04
    (3)VS Code
    (4)C++

    #include <iostream>
    #include <opencv2/opencv.hpp>
    #include <string>
    #include <vector>
    #include <math.h>
    #include <cmath>
    #include <algorithm>
    
    class Exp4{
    public:
        // 1 初始化:彩色图片、灰度图片、加噪图片
        Exp4(std::vector<std::string> path){
            noise_name.push_back("高斯噪声");
            noise_name.push_back("胡椒噪声");
            noise_name.push_back("盐噪声");
            noise_name.push_back("椒盐噪声");
    
            filter_name.push_back("算术均值滤波");
            filter_name.push_back("几何均值滤波");
            filter_name.push_back("谐波均值滤波");
            filter_name.push_back("逆谐波均值滤波");
            filter_name.push_back("中值滤波");
            filter_name.push_back("自适应均值滤波");
            filter_name.push_back("自适应中值滤波");
    
            pic_color.push_back("灰度");
            pic_color.push_back("彩色");
            for(int i = 0; i < path.size(); i++){
                // 读取彩色图片、灰度图片
                original_color_image.push_back(cv::imread(path[i]));
                original_gray_image.push_back(color2Gray(original_color_image[i]));
    
                // 彩色图片加噪
                noise_color_image.push_back(addNoise(original_color_image[i], 0, 0));
                noise_color_image.push_back(addNoise(original_color_image[i], 1, 0));
                noise_color_image.push_back(addNoise(original_color_image[i], 2, 0));
                noise_color_image.push_back(addNoise(original_color_image[i], 3, 0));
    
                // 灰度图片加噪
                noise_gray_image.push_back(addNoise(original_gray_image[i], 0));
                noise_gray_image.push_back(addNoise(original_gray_image[i], 1));
                noise_gray_image.push_back(addNoise(original_gray_image[i], 2));
                noise_gray_image.push_back(addNoise(original_gray_image[i], 3));
            }
        }
        // 1.1 彩色图像转灰度图像
        cv::Mat color2Gray(cv::Mat src_image){
            //创建与原图同类型和同大小的矩阵
    	    cv::Mat gray_image(src_image.rows, src_image.cols, CV_8UC1);
            if(src_image.channels()!=1){
                for(int i = 0; i < src_image.rows; i++)
                    for(int j = 0; j < src_image.cols; j++)
                        gray_image.at<uchar>(i, j) = (src_image.at<cv::Vec3b>(i, j)[0] + src_image.at<cv::Vec3b>(i, j)[1] + src_image.at<cv::Vec3b>(i, j)[2]) / 3;
            }
            else
                gray_image = src_image.clone();
            return gray_image;
        }
        // 2 灰度图像滤波
        void grayFiltering(int id, int select, int filter_size=5, double Q=1){
            int size = filter_size;
            if(select == 6 || select == 5)
                size = 7;
            int m = size/2;
            int n=size*size;
            cv::Mat image = cv::Mat::zeros(noise_gray_image[id].size(), noise_gray_image[id].type());
    
            for(int i=m; i < noise_gray_image[id].rows - m; i++)
                for(int j=m; j < noise_gray_image[id].cols - m; j++){ 
                    cv::Mat sub_matrix = noise_gray_image[id](cv::Rect(j - m, i - m, size, size));
                    if(select == 0)
                        image.at<uchar>(i,j) = arithmeticMeanValueConvolution(sub_matrix);
                    else if(select == 1)
                        image.at<uchar>(i,j) = geometryMeanValueConvolution(sub_matrix);
                    else if(select == 2)
                        image.at<uchar>(i,j) = harmonicMeanValueConvolution(sub_matrix);
                    else if(select == 3)
                        image.at<uchar>(i,j) = inverseHarmonicMeanValueConvolution(sub_matrix);
                    else if(select == 4)
                        image.at<uchar>(i,j) = middleValueConvolution(sub_matrix);
                    else if(select == 5)
                        image.at<uchar>(i,j) = selfAdaptionMeanValueConvolution(sub_matrix, image.at<uchar>(i,j));
                    else if(select == 6)
                        image.at<uchar>(i,j) = selfAdaptionMiddleValueConvolution(sub_matrix);
                }
            noise_gray_image_process.push_back(image);
        }
    
        // 2.1 算术均值
        int arithmeticMeanValueConvolution(cv::Mat& image_block, int size=5){
            cv::Mat c_template(size, size, CV_8UC1, 1);
            int n=size*size;
            return c_template.dot(image_block) / n + 0.5;
        }
    
        // 2.2 几何平均
        int geometryMeanValueConvolution(cv::Mat& image_block, int size=5){
            std::vector<double> product(5,1);
            double n = 1.0 / double(size * size);
            for(int k1 = 0; k1 < size; k1++){
                double temp=1;
                for(int k2 = 0; k2 < size; k2++){
                    temp = temp * ((image_block.at<uchar>(k1,k2) > 0) ? double(image_block.at<uchar>(k1,k2)) : 1.0);
                    product[k1] = pow(temp, n);
                }
            }
            return int(product[0] * product[1] * product[2] * product[3] * product[4]);
        }
    
        // 2.3 谐波均值
        int harmonicMeanValueConvolution(cv::Mat& image_block, int size=5){
            std::vector<double> product(5,1);
            double sum=0;
            double n = double(size * size);
            for(int k1 = 0; k1 < size; k1++){
                for(int k2 = 0; k2 < size; k2++){
                    double temp;
                    if(image_block.at<uchar>(k1,k2))
                        temp = 1.0 / double(image_block.at<uchar>(k1,k2));
                    else
                        temp=0;
                    sum += temp;
                }
            }
            return int(n / sum);
        }
    
        // 2.4 逆谐波均值
        int inverseHarmonicMeanValueConvolution(cv::Mat& image_block, int size=5, double Q=1){
            double sum1=0, sum2=0;
            for(int k1 = 0; k1 < size; k1++){
                for(int k2 = 0; k2 < size; k2++){
                    sum1 += pow(double(image_block.at<uchar>(k1, k2)), Q);
                    sum2 += pow(double(image_block.at<uchar>(k1, k2)), Q+1);
                }
            }
            return int(sum2 / sum1);
        }
    
        // 3.1 中值滤波
        int middleValueConvolution(cv::Mat& image_block, int size=5){
            int min = 0, k = 0, pos = size*size/2;
            std::vector<int> nums;
            for(int k1 = 0; k1 < size; k1++)
                for(int k2 = 0; k2 < size; k2++)
                    nums.push_back(image_block.at<uchar>(k1,k2));
            int middle = findMiddleNum(nums, 0, size*size - 1, pos);
            return middle;
        }
    
        // 3.2.1 快速查找中位数
        int findMiddleNum(std::vector<int>& nums, int begin, int end, int n){
            int i = partition(nums, begin, end);
            if(i == n)
                return nums[i];
            else if(i > n)
                return findMiddleNum(nums, begin, i-1, n);
            else
                return findMiddleNum(nums, i+1, end, n);
        }
    
        // 3.2.2 交换
        void exchange(std::vector<int>& nums, int a,int b){
            int c = nums[a];
            nums[a] = nums[b];
            nums[b] = c;
            return;
        }
    
        // 3.2.2 快速查找中位数
        int partition(std::vector<int>& nums, int begin, int end){
            int i = begin, j = end + 1;
            int x = nums[begin];
            while (true) {
                while (nums[++i] < x) {// 向右扫描
                    if (i == end)
                        break;
                }
                while (nums[--j] > x) {// 向左扫描
                    if (j == begin)
                        break;
                }
                if (i >= j) // 指针相遇,切分位置确定
                    break;
                exchange(nums, i, j);// 交换左右逆序元素
            }
            // 运行到最后:i指向从左往右第一个大于x的元素,j指向从右往左第一个小于x的元素。
            exchange(nums, begin, j);// 将切分元素放在切分位置
            return j;
        }
    
        // 4、自适应均值滤波
        int selfAdaptionMeanValueConvolution(cv::Mat& image_block, int value, int size=7, int sigma_n=3000){
            int center = size/2;
            int mean = computerMeanValue(image_block);
            int sigma = computerVariance(image_block, mean);
            //std::cout<<sigma<<"\n";
            double rate = double(sigma_n)/double(sigma);
            if(rate > 1.0)
                rate = 1;
            int ans = value - rate * (value - mean);
            return ans;
        }
    
        // 4.1 计算图像块的平均值
        int computerMeanValue(cv::Mat& image_block, int size=7){
            int sum = 0,n = size*size;
            for(int k1 = 0; k1 < size; k1++)
                for(int k2 = 0; k2 < size; k2++)
                    sum += image_block.at<uchar>(k1,k2);
            return (sum / n);
        }
    
        // 4.2 计算图像块的方差
        int computerVariance(cv::Mat& image_block, int mean, int size=7){
            int sum = 0,n = size*size;
            for(int k1 = 0; k1 < size; k1++)
                for(int k2 = 0; k2 < size; k2++)
                    sum += pow((image_block.at<uchar>(k1,k2) - mean), 2);
            return (sum / n);
        }
    
        // 5、自适应中值滤波
        int selfAdaptionMiddleValueConvolution(cv::Mat& image_, int size=3, int sizemax=7){
            int center = sizemax/2;
            int zxy = image_.at<uchar>(center, center);
            int m = size/2;
            cv::Mat image_block = image_(cv::Rect(center - m, center - m, size, size)).clone();
            std::vector<int> nums;
            for(int k1 = 0; k1 < size; k1++)
                for(int k2 = 0; k2 < size; k2++)
                    nums.push_back(image_block.at<uchar>(k1,k2));
    
            sort(nums.begin(), nums.end());
            int zmin = nums[0], zmax = nums[nums.size()-1], zmid = nums[(size*size)/2];
            int A1 = (zmid - zmin), A2 = (zmid - zmax);
            if(A1 > 0 && A2 < 0){
                int B1 = (zxy - zmin), B2 = (zxy - zmax);
                if(B1 > 0 && B2 < 0)
                    return zxy;
                else
                    return zmid; 
            }
            else{
                if(size < sizemax)
                    return selfAdaptionMiddleValueConvolution(image_,  size+2);
                else
                    return zmid;
            }      
        }
    
         // 6、彩色图像滤波器
        void colorFiltering(int id, int select, int filter_size=5, int Q=1){
            int size = filter_size;
            if(select == 6)
                size = 7;
            int m = size/2;
            int n=size*size;
            cv::Mat image = cv::Mat::zeros(noise_color_image[id].rows, noise_color_image[id].cols, noise_color_image[id].type()); 
            std::vector<cv::Mat> channels;
            cv::split(noise_color_image[id], channels);
    
            for(int i=m; i < noise_color_image[id].rows - m; i++)
                for(int j=m; j < noise_color_image[id].cols - m; j++)
                    for(int k=0;k < 3;k++){
                        cv::Mat sub_matrix = channels.at(k)(cv::Rect(j - m, i - m, size, size));
                        if(select == 0)
                            image.at<cv::Vec3b>(i,j)[k] = arithmeticMeanValueConvolution(sub_matrix, size);
                        else if(select == 1)
                            image.at<cv::Vec3b>(i,j)[k] = geometryMeanValueConvolution(sub_matrix, size);
                        else if(select == 2)
                            image.at<cv::Vec3b>(i,j)[k] = harmonicMeanValueConvolution(sub_matrix, size);
                        else if(select == 3)
                            image.at<cv::Vec3b>(i,j)[k] = inverseHarmonicMeanValueConvolution(sub_matrix, size, Q);
                        else if(select == 4)
                            image.at<cv::Vec3b>(i,j)[k] = middleValueConvolution(sub_matrix, size);
                        else if(select == 5)
                            image.at<cv::Vec3b>(i,j)[k] = selfAdaptionMeanValueConvolution(sub_matrix, image.at<cv::Vec3b>(i,j)[k]);
                        else if(select == 6)
                            image.at<cv::Vec3b>(i,j)[k] = selfAdaptionMiddleValueConvolution(sub_matrix);
                    }
            noise_color_image_process.push_back(image);
        }
    
        // 7、运行代码
        void test_gray_filter(int num){
            int id = num;
            for(int i = 0; i < noise_name.size(); i++){
                grayFiltering(i, id);
                std::cout<< pic_color[0] << "-----" <<noise_name[i]<<"-----"<<filter_name[id]<<": 运行完毕!!!!  \n";
            }
    
            cv::imshow(filter_name[id] + "----准备就绪,可以开始!", original_color_image[0]);
            cv::waitKey(0);
    
            // 3 显示灰度滤波结果
            for(int i = 0; i < noise_name.size(); i++){
                cv::imshow(noise_name[i], noise_gray_image[i]);
                cv::waitKey(0);
                cv::imshow(noise_name[i] + "-----" + filter_name[id] + "-----" + pic_color[0], noise_gray_image_process[id * 4 + i]);
                cv::waitKey(0);
            }
            std::cout<<"\n \n";
            cv::destroyAllWindows();
        }
    
        void test_color_filter(int num){
            int id = num;
            for(int i = 0; i < noise_name.size(); i++){
                colorFiltering(i, id);
                std::cout<< pic_color[1] << "-----" <<noise_name[i]<<"-----"<<filter_name[id]<<": 运行完毕!!!!  \n";
            }
    
            cv::imshow(filter_name[id] + "----准备就绪,可以开始!", original_color_image[0]);
            cv::waitKey(0);
    
            // 3 显示灰度滤波结果
            for(int i = 0; i < noise_name.size(); i++){
                cv::imshow(noise_name[i], noise_color_image[i]);
                cv::waitKey(0);
                cv::imshow(noise_name[i] + "-----" + filter_name[id] + "-----" + pic_color[0], noise_color_image_process[id * 4 + i]);
                cv::waitKey(0);
            }
            std::cout<<"\n \n";
            cv::destroyAllWindows();
        }
    private:
        std::vector<std::string> noise_name;
        std::vector<std::string> filter_name;
        std::vector<std::string> pic_color;
    
        std::vector<cv::Mat> original_color_image;
        std::vector<cv::Mat> original_gray_image;
    
        std::vector<cv::Mat>  noise_color_image;
        std::vector<cv::Mat>  noise_gray_image;
    
        std::vector<cv::Mat>  noise_color_image_process;
        std::vector<cv::Mat>  noise_gray_image_process;
    
        /************************** 添加噪声***************************************/
    
        cv::Mat addNoise(cv::Mat src_image, int select=0, int gray=1, double SNR=0.99, double mean=0.0, double sigma=10.0, int k=2){
            cv::Mat outImage;
            cv::Mat image;
            if(gray){
                image = color2Gray(src_image);
                if(select==0)
                    outImage = addGaussNoise(image, mean, sigma, k);
                else if(select==1)
                    outImage = addPepperSaltNoise(image, SNR, select - 1);
                else if(select==2)
                    outImage = addPepperSaltNoise(image, SNR, select - 1);
                else if(select==3)
                    outImage = addPepperSaltNoise(image, SNR, select - 1);
            }
            else{
                std::vector<cv::Mat> channels, ch;
                cv::Mat image = src_image.clone();
                cv::split(src_image, channels);
                cv::split(image, ch);
                for(int k=0; k < 3; k++){
                    if(select==0)
                        ch.at(k) = addGaussNoise(channels.at(k), mean, sigma, k);
                    else if(select==1)
                        ch.at(k) = addPepperSaltNoise(channels.at(k), SNR, select - 1);
                    else if(select==2)
                        ch.at(k) = addPepperSaltNoise(channels.at(k), SNR, select - 1);
                    else if(select==3)
                        ch.at(k) = addPepperSaltNoise(channels.at(k), SNR, select - 1);
                }
                cv::merge(ch, outImage);
            }
            return outImage;
        }
    
        // 1、添加高斯噪声
        cv::Mat addGaussNoise(cv::Mat src_image, double mean=0.0, double sigma=100.0, int k=2, int gray=1){
            cv::Mat outImage;
            cv::Mat image = src_image.clone();
            //cv::Mat image = color2Gray(src_image);
            outImage.create(image.rows,image.cols,image.type());
            int PixcelMax = 255, PixcelMin = 0;
            for(int x=0;x<image.rows;x++){
                for(int y=0;y<image.cols;y++){
                    double temp = image.at<uchar>(x, y) + k * generateGaussianNoise(mean,sigma);
                    if(temp>PixcelMax)
                        temp=PixcelMax;
                    else if(temp<PixcelMin)
                        temp=PixcelMin;
                    outImage.at<uchar>(x, y) = temp;
                }
            }
            return outImage;
        }
    
        // 1.1、生成高斯噪声(其实就是服从高斯分布的随机数)
        double generateGaussianNoise(double mean, double sigma){
            static double V1, V2, S;
            static int phase = 0;
            double X;
            double U1,U2;
            if ( phase == 0 ) {
                do {
                    U1 = (double)rand() / RAND_MAX;
                    U2 = (double)rand() / RAND_MAX;
    
                    V1 = 2 * U1 - 1;
                    V2 = 2 * U2 - 1;
                    S = V1 * V1 + V2 * V2;
                } while(S >= 1 || S == 0);
    
                X = V1 * sqrt(-2 * log(S) / S);
            } 
            else{
                X = V2 * sqrt(-2 * log(S) / S);
            }
            phase = 1 - phase;
            return mean + sigma * X;
        }
    
        // 2、添加椒盐噪声(根据图像的信噪比,添加椒盐噪声)根据选择,可以添加:盐噪声(又称白噪声,白色点255)、胡椒噪声(黑色点)、椒盐噪声。
        cv::Mat addPepperSaltNoise(cv::Mat src_image, double SNR=0.9, int select=0, int gray=1){
            cv::Mat outImage;
            cv::Mat image = src_image.clone();
            //outImage.create(image.rows,image.cols,image.type());
            int SP = image.rows * image.cols;
            int NP = SP*(1-SNR);
            outImage = image.clone();
            // 噪声点的总个数 与 信噪比有关
            for(int i=0; i<NP; i++) {
                // 随机选取图像上的点
                int x = (int)(double(rand())*1.0/RAND_MAX* (double)image.rows);
                int y = (int)(double(rand())*1.0/RAND_MAX* (double)image.cols);
                // 峰值(255)和零值(0)出现的概率相同
                if(select==0)
                   outImage.at<uchar>(x,y) = 0;
                else if(select==1)
                    outImage.at<uchar>(x,y) = 255;
                else{
                    int r = rand()%2;
                    outImage.at<uchar>(x,y) = (r > 0) ? 255 : 0;
                }
            }
            return outImage;
        }
    };
    
    int main(){
        std::vector<std::string> path;
        path.push_back("/home/lyd/image_process/pic/lena.jpg");
        Exp4 a(path);
        //a.run();
        for(int i=0; i < 7; i++)
            a.test_gray_filter(i);
        for(int i=0; i < 7; i++)
            a.test_color_filter(i);
        return 1;
    }
    

    三、实验结果

    四类噪声下的灰度图像:
    在这里插入图片描述
    1、 均值滤波

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    2、 中值滤波
    在这里插入图片描述
    3、 自适应均值滤波
    在这里插入图片描述
    4、 自适应中值滤波
    在这里插入图片描述

    5、 彩色图像均值滤波
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 图像处理——去噪

    2019-06-27 21:35:52
    图像处理——去噪 图像去噪定义 图像去噪是指减少数字图像中噪声的过程称为图像去噪。现实中的数字图像在数字化和传输过程中常受到成像设备与外部环境噪声干扰等影响,称为含噪图像或噪声图像。 ...

    图像去噪定义

    图像去噪是指减少数字图像中噪声的过程称为图像去噪。现实中的数字图像在数字化和传输过程中常受到成像设备与外部环境噪声干扰等影响,称为含噪图像或噪声图像。

    噪声分类

    按照噪声组成来分

       f(x,y)表示给定原始图象,g(x,y)表示图象信号,n(x,y)表示噪声。

    (1)加性噪声,此类噪声与输入图象信号无关,含噪图象可表示为f(x,y)=g(x,y)+n(x,y),信道噪声及光导摄像管的摄像机扫描图象时产生的噪声就属这类噪声;典型的加性噪声有高斯噪声,

    (2)乘性噪声,此类噪声与图象信号有关,含噪图象可表示为f(x,y)=g(x,y)+n(x,y)g(x,y),飞点扫描器扫描图象时的噪声,电视图象中的相关噪声,胶片中的颗粒噪声就属于此类噪声;

    (3)量化噪声,此类噪声与输入图象信号无关,是量化过程存在量化误差,再反映到接收端而产生。

    按照噪声密度分布:

    (1)高斯噪声:指噪声服从高斯分布,即某个强度的噪声点个数最多,离这个强度越远噪声点个数越少,且这个规律服从高斯分布。高斯噪声是一种加性噪声,即噪声直接加到原图像上,因此可以用线性滤波器滤除。

    (2)椒盐噪声(脉冲噪声):类似把椒盐撒在图像上,因此得名,是一种在图像上出现很多白点或黑点的噪声,如电视里的雪花噪声等。椒盐噪声可以认为是一种逻辑噪声,用线性滤波器滤除的结果不好,一般采用中值滤波器滤波可以得到较好的结果。

    (3)均匀噪声:是指功率谱密度(信号功率在频域的分布状况)在整个频域内是常数的噪声。 所有频率具有相同能量密度的随机噪声称为白噪声。

    (4)瑞利噪声:噪声分布为瑞利分布。

    (5)指数噪声:噪声分布为指数分布。

    (6)伽马噪声:噪声分布为瑞利分布。

    (以下是对图像加入高斯,椒盐等噪声的python代码) 

     1 # -*- coding: utf-8 -*-
     2 """
     3 Created on Sat Mar  2 14:00:30 2019
     4 
     5 @author: Administrator
     6 """
     7 
     8 '''
     9 图像添加噪声,去除噪声
    10 '''
    11 import matplotlib.pyplot as plt 
    12 import numpy as np
    13 from skimage.util import random_noise
    14 from PIL import Image 
    15 
    16 img = plt.imread('F:/python编程/自己的博客园代码/picture_process/example.jpg')
    17 
    18 fig = plt.figure(figsize = (8.0,6.0))
    19 ax1 = fig.add_subplot(2,3,1)
    20 ##  show the original picture
    21 ax1.imshow(img)
    22 plt.title('original_picture')
    23 
    24 ## gray_picture
    25 gravity= np.array([0.299,0.587,0.114])
    26 #red*0.299+green*0.587+blue*0.114
    27 img_gravity=np.dot(img,gravity)
    28 ax2 = fig.add_subplot(2,3,2)
    29 ##  show the gray_picture
    30 ax2.imshow(img_gravity,cmap='gray')
    31 plt.title('gray_picture')
    32 
    33 
    34 img_gaussian =  random_noise(img, mode='gaussian', seed=100, clip=True)
    35 ax3 = fig.add_subplot(2,3,3)
    36 ax3.imshow(img_gaussian)
    37 plt.title('add_gaussian')
    38 
    39 
    40 img_salt =  random_noise(img, mode='salt', seed=100, clip=True)
    41 ax4 = fig.add_subplot(2,3,4)
    42 ax4.imshow(img_salt)
    43 plt.title('add_salt')
    44 
    45 
    46 img_pepper =  random_noise(img, mode='pepper', seed=100, clip=True)
    47 ax4 = fig.add_subplot(2,3,5)
    48 ax4.imshow(img_pepper)
    49 plt.title('add_pepper')
    50 
    51 
    52 img_sp =  random_noise(img, mode='s&p', seed=100, clip=True)
    53 ax4 = fig.add_subplot(2,3,6)
    54 ax4.imshow(img_sp)
    55 plt.title('add_sp')
    View Code

    去噪方法

    中值滤波:

      中值滤波法是一种非线性平滑技术,它将每一像素点的灰度值设置为该点某邻域窗口内的所有像素点灰度值的中值。

    高斯滤波:

      高斯滤波是一种线性平滑滤波,适用于消除高斯噪声,广泛应用于图像处理的减噪过程。通俗的讲,高斯滤波就是对整幅图像进行加权平均的过程,每一个像素点的值,都由其本身和邻域内的其他像素值经过加权平均后得到。高斯滤波的具体操作是:用一个模板(或称卷积、掩模)扫描图像中的每一个像素,用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。

    均值滤波:

      均值滤波也称为线性滤波,其采用的主要方法为邻域平均法。线性滤波的基本原理是用均值代替原图像中的各个像素值,即对待处理的当前像素点(x,y),选择一个模板,该模板由其近邻的若干像素组成,求模板中所有像素的均值,再把该均值赋予当前像素点(x,y),作为处理后图像在该点上的灰度g(x,y),即g(x,y)=1/m ∑f(x,y) m为该模板中包含当前像素在内的像素总个数。

    维纳滤波:

      维纳滤波(wiener filtering) 一种基于最小均方误差准则、对平稳过程的最优估计器。这种滤波器的输出与期望输出之间的均方误差为最小,因此,它是一个最佳滤波系统。它可用于提取被平稳噪声所污染的信号。

    傅里叶滤波简称fft,是通过对图片信号在频域里进行滤波,从而达到去噪效果。

     (以下是几种滤波方法(不一定全)在python代码中的应用)

     1 # -*- coding: utf-8 -*-
     2 """
     3 Created on Sat Mar  2 21:17:58 2019
     4 
     5 @author: Administrator
     6 """
     7 
     8 '''
     9 图像去除噪声
    10 '''
    11 import matplotlib.pyplot as plt 
    12 import numpy as np
    13 from skimage.util import random_noise
    14 from PIL import Image 
    15 import cv2
    16 
    17 img = plt.imread('F:/python编程/自己的博客园代码/picture_process/gaussian_picture.jpg')
    18 fig = plt.figure(figsize=(8.0,6.0))
    19 ax1 = fig.add_subplot(2,3,1)
    20 ax1.imshow(img)
    21 plt.title('blur_picture')
    22 
    23 ###  中值滤波
    24 median_filter_img = cv2.medianBlur(img, 3)
    25 ax2 = fig.add_subplot(2,3,2)
    26 ax2.imshow(median_filter_img)
    27 plt.title('median_filter')
    28 
    29 #### 高斯滤波
    30 Gaussian_filter_img = cv2.GaussianBlur(img, (3,3), 0)
    31 ax2 = fig.add_subplot(2,3,3)
    32 ax2.imshow(Gaussian_filter_img)
    33 plt.title('Gaussian_filter')
    34 
    35 #### 均值滤波
    36 mean_vaule_filter = cv2.blur(img, (5,5))
    37 ax2 = fig.add_subplot(2,3,4)
    38 ax2.imshow(mean_vaule_filter)
    39 plt.title('mean_vaule_filter')
    40 
    41 #### 双边滤波
    42 #9 邻域直径,两个 75 分别是空间高斯函数标准差,灰度值相似性高斯函数标准差
    43 blur = cv2.bilateralFilter(img,9,75,75)
    44 ax2 = fig.add_subplot(2,3,5)
    45 ax2.imshow(blur)
    46 plt.title('bilatral-filter')
    View Code

    效果图

     

    posted on 2019-03-03 15:42 E-Dreamer 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/E-Dreamer-Blogs/p/10458846.html

    展开全文
  • 图像去噪及Matlab实现

    2019-01-27 01:01:59
    图像去噪处理方法可分为空间域法和变换域法两大类。 基于离散余弦变换的图像去噪 一般而言,我们认为图像噪声在离散余弦变换结果中处在其高频部分,而高频部分的幅值一般很小,利用这一性质,就可以实现...

    Github个人博客:https://joeyos.github.io

    图像去噪常用方法

    图像去噪处理方法可分为空间域法和变换域法两大类。

    基于离散余弦变换的图像去噪

    一般而言,我们认为图像的噪声在离散余弦变换结果中处在其高频部分,而高频部分的幅值一般很小,利用这一性质,就可以实现去噪。然而,同时会失去图像的部分细节。

    %读取图像
    X=imread('wangshi.jpg'); 
    X=rgb2gray(X);
    %读取图像尺寸
    [m,n]=size(X); 
    %给图像加噪
    Xnoised=imnoise(X,'speckle',0.01); 
    %输出加噪图像
    subplot(121); 
    imshow(Xnoised);
    %DCT变换
    Y=dct2(Xnoised); 
    I=zeros(m,n);
    %高频屏蔽
    I(1:m/3,1:n/3)=1; 
    Ydct=Y.*I;
    %逆DCT变换
    Y=uint8(idct2(Ydct)); 
    %结果输出
    subplot(122);
    imshow(Y);
    
    

    这里写图片描述

    基于小波变换的图像去噪

    小波去噪是小波变换较为成功的一类应用,其去噪的基本思路为:含噪图像-小波分解-分尺度去噪-小波逆变换-恢复图像。含噪信号经过预处理,然后利用小波变换把信号分解到各尺度中,在每一尺度下把属于噪声的小波系数去掉,保留并增强属于信号的小波系数,最后再经过小波逆变换恢复检测信号。比基于傅里叶变换的去噪方法好。

    clear;                 
    X=imread('life.jpg');            
    X=rgb2gray(X);
    subplot(221);          
    imshow(X);             
    title('原始图像');                  
    % 生成含噪图像并图示
    init=2055615866;       
    randn('seed',init);      
    X=double(X);
    % 添加随机噪声
    XX=X+8*randn(size(X));  
    subplot(222);             
    imshow(uint8(XX));              
    title(' 含噪图像 ');       
    %用小波函数coif2对图像XX进行2层
    % 分解
    [c,l]=wavedec2(XX,2,'coif2'); 
    % 设置尺度向量
    n=[1,2];                  
    % 设置阈值向量 , 对高频小波系数进行阈值处理
    p=[10.28,24.08]; 
    nc=wthcoef2('h',c,l,n,p,'s');
    % 图像的二维小波重构
    X1=waverec2(nc,l,'coif2');   
    subplot(223);              
    imshow(uint8(X1));                
    %colormap(map);            
    title(' 第一次消噪后的图像 '); 
    %再次对高频小波系数进行阈值处理
    mc=wthcoef2('v',nc,l,n,p,'s');
    % 图像的二维小波重构
    X2=waverec2(mc,l,'coif2');  
    subplot(224);             
    imshow(uint8(X2));               
    title(' 第二次消噪后的图像 ');   
    

    这里写图片描述

    展开全文
  • 一、图像平滑  图像平滑的目的之一是消除噪声,二是模糊图像。  从信号频谱的角度来看,信号缓慢变化的部分在频率域表现为低频,迅速变化的部分表现为高频... 模板卷积是数字图像处理常用的一种邻域运算方式,...

    一、图像平滑

            图像平滑的目的之一是消除噪声,二是模糊图像。

            从信号频谱的角度来看,信号缓慢变化的部分在频率域表现为低频,迅速变化的部分表现为高频。图像在获取、储存、处理、传输过程中,会受到电气系统和外界干扰而存在一定程度的噪声,图像噪声使图像模糊,甚至淹没图像特征,给分析带来困难。

    二、模板卷积

            模板卷积是数字图像处理常用的一种邻域运算方式,模板卷积可以实现图像平滑、图像锐化、边缘检测等功能。

            模板可以是一小幅图像,也可以是一个滤波器。

            模板卷积的基本步骤:

         (1)模板在输入图像上移动,让模板中心依次与输入图像的每个像素重合;

          (2)模板系数与跟模板重合的输入图像的对应像素相乘,再将乘积相加;

          (3)把结果赋予输图像,其像素位置与模板中心在输入图像上的位置一致;

          具体过程如下图所示(原图像进行了边界扩展,目的是保持卷积后图像与原图像大小相同)

           图像边界问题:

         (1)当模板超出图像边界时不做处理;

         (2)扩充图像,可以复制原图像边界像素或利用常数填充图像边界。

          计算结果可能超出灰度范围,对于8位灰度图像,当计算结果超出 [0, 255] 时,可以简单的将其值置为0或255.

           常用模板有Box模板和高斯模板

    以下为均值滤波与高斯滤波代码

    
    #include <cv.h>
    #include <cxcore.h>
    #include <highgui.h>
    #include <stdio.h>
    #include <opencv2/opencv.hpp>
    
    int main()
    {
    	//smooth with GAUSS and BOX
    	const char *filename = "building.bmp";	
    	IplImage *inputimage = cvLoadImage(filename, -1);	//载入图片
    	IplImage *smoothimage = cvCreateImage(cvSize(inputimage->width, inputimage->height), IPL_DEPTH_8U, inputimage->nChannels);//声明去噪图片
    	IplImage *extensionimage = cvCreateImage(cvSize(inputimage->width+2, inputimage->height+2), IPL_DEPTH_8U, inputimage->nChannels);//声明边界扩展图片
    	cvCopyMakeBorder(inputimage, extensionimage, cvPoint(1, 1), IPL_BORDER_REPLICATE);	//进行边界扩展,原图像在新图像的(1,1)位置,IPL_BORDER_REPLICATE表示扩展为边界像素
    	
    
    	int gauss[3][3] = { 1,2,1,2,4,2,1,2,1 };	//声明高斯模板
    
    	int box[3][3] = { 1,1,1,1,1,1,1,1,1 };	//声明Box模板
    
    	//进行模板卷积
    	for (int i = 0; i < inputimage->height; i++)
    	{
    		for (int j = 0; j < inputimage->width; j++)
    		{
    			for (int k = 0; k < inputimage->nChannels; k++)
    			{
    				float temp = 0;
    				for (int m = 0; m < 3; m++)
    				{
    					for (int n = 0; n < 3; n++)	
    					{
    						temp += gauss[m][n] * (unsigned char)extensionimage->imageData[(i + m)*extensionimage->widthStep + (j + n)* extensionimage->nChannels + k];
    						//temp += box[m][n] * (unsigned char)extensionimage->imageData[(i + m)*extensionimage->widthStep + (j + n)* extensionimage->nChannels + k];
    					}
    				}
    				smoothimage->imageData[i*smoothimage->widthStep + j * smoothimage->nChannels + k] = temp / 16.0;	//gauss模板
    				//smoothimage->imageData[i*smoothimage->widthStep + j * smoothimage->nChannels + k] = temp / 9.0;	//box模板
    			}
    			
    		}
    	}
    
    	cv::Mat smooth = cv::cvarrToMat(smoothimage); 
    	cv::imwrite("buildingsmooth.bmp", smooth);	//将去噪后的图片保存到当前目录下
    	cvNamedWindow("inputimage", 1);
    	cvNamedWindow("smoothimage", 1);
    
    	cvShowImage("inputimage", inputimage);
    	cvShowImage("smoothimage", smoothimage);
    	cvWaitKey(0);
    
    	cvDestroyWindow("inputimage");
    	cvDestroyWindow("smoothimage");
    
    	cvReleaseImage(&inputimage);
    	cvReleaseImage(&smoothimage);
    }
    

    以下为程序运行结果,从左到右依次为:原噪声图像---均值滤波图像---高斯滤波图像


    三、中值滤波

           中值滤波是一种非线性滤波,它能在滤除噪声的同时很好的保持图像边缘

          中值滤波的原理:把以当前像素为中心的小窗口内的所有像素的灰度按从小到大排序,取排序结果的中间值作为该像素的灰度值。

    以下是具体实现代码:

    
    #include <cv.h>
    #include <cxcore.h>
    #include <highgui.h>
    #include <stdio.h>
    #include <opencv2/opencv.hpp>
    
    int median(int *input)	//中值函数,借助了简单的排序(起泡法)
    {
    	for (int i = 0; i < 8; i++)
    	{
    		for (int j = 0; j < 8 - i; j++)
    		{
    			if (input[j] > input[j + 1])
    			{
    				int k;
    				k = input[j];
    				input[j] = input[j + 1];
    				input[j + 1] = k;
    			}
    		}
    	}
    	return input[4];
    }
    
    
    int main()
    {
    	//smooth with median filter
    	const char *filename = "dinner.bmp";
    	IplImage *inputimage = cvLoadImage(filename, -1);
    	IplImage *smoothimage = cvCreateImage(cvSize(inputimage->width, inputimage->height), IPL_DEPTH_8U, inputimage->nChannels);
    	IplImage *extensionimage = cvCreateImage(cvSize(inputimage->width + 2, inputimage->height + 2), IPL_DEPTH_8U, inputimage->nChannels);
    	cvCopyMakeBorder(inputimage, extensionimage, cvPoint(1, 1), IPL_BORDER_REPLICATE);	//进行边界扩展,原图像在新图像的(1,1)位置,IPL_BORDER_REPLICATE表示扩展为边界像素
    
    	for (int i = 0; i < smoothimage->height; i++)
    	{
    		for (int j = 0; j < smoothimage->width; j++)
    		{
    			for (int k = 0; k < smoothimage->nChannels; k++)
    			{
    				int temp[9] = {};
    				int s = 0;
    				for (int m = 0; m < 3; m++)
    				{
    					for (int n = 0; n < 3; n++)
    					{
    						temp[s++] = (unsigned char)extensionimage->imageData[(i + m)*extensionimage->widthStep + (j + n)* extensionimage->nChannels + k];
    					}
    				}
    				int m;
    				m = median(temp);	//得到中值
    				smoothimage->imageData[i*smoothimage->widthStep + j * smoothimage->nChannels + k] = m;
    			}
    		}
    	}
    
    	cv::Mat smooth = cv::cvarrToMat(smoothimage);
    	cv::imwrite("dinnersmooth.jpg", smooth);	//将去噪后的图片保存到当前目录下
    
    	cvNamedWindow("inputimage", 1);
    	cvNamedWindow("smoothimage", 1);
    
    	cvShowImage("inputimage", inputimage);
    	cvShowImage("smoothimage", smoothimage);
    	cvWaitKey(0);
    
    	cvDestroyWindow("inputimage");
    	cvDestroyWindow("smoothimage");
    
    	cvReleaseImage(&inputimage);
    	cvReleaseImage(&smoothimage);
    }
    
    
    

    以下是实现结果,从左到右依次是 原噪声图像---中值滤波后图像

    四、双边滤波

            双边滤波不仅考虑了像素信息,也考虑到了像素位置信息

            具体公式如下:

                                   Wij = exp(-||Pij-Pi||^2/2\sigma1^2)* exp(-||Cij-Ci||^2/2\sigma2^2)

           Wij为当前像素权值,Pij为当前像素信息,Pi为当前像素邻域均值;Cij为当前像素位置信息,Ci为当前像素平均位置信息,\sigma1\sigma2分别为当前像素信息、当前像素位置的标准差。

    具体算法过程与上述算法类似,具体代码如下:

    #include <cv.h>
    #include <cxcore.h>
    #include <highgui.h>
    #include <stdio.h>
    #include<math.h>
    #include "opencv2/opencv.hpp"
    
    float avg(float *a)		//计算平均数
    {
    	float temp = 0.0;
    	for (int m = 0; m < 9; m++)
    	{
    		temp += a[m];
    	}
    	return temp;
    }
    
    float var(float *b,float c)		//计算方差
    {
    	float temp = 0.0;
    	for (int m = 0; m < 9; m++)
    	{
    		float a = 0;
    		a = b[m] > c ? (b[m] - c) : (c - b[m]);
    		temp = temp + a * a;
    	}
    	return temp / 9.0;
    }
    	
    int main()
    {
    	// bilateral filter
    	const char *filename = "building.bmp";
    	IplImage *inputimage = cvLoadImage(filename, -1);
    	IplImage *smoothimage = cvCreateImage(cvSize(inputimage->width, inputimage->height), IPL_DEPTH_8U, inputimage->nChannels);
    	IplImage *extensionimage = cvCreateImage(cvSize(inputimage->width + 2, inputimage->height + 2), IPL_DEPTH_8U, inputimage->nChannels);
    
    	
    	//边界扩展
    	int z = 0;
    	while (z <30)	//进行30次循环,进行一次双边滤波效果不大
    	{
    	//IplImage *extensionimage = cvCreateImage(cvSize(inputimage->width + 2, inputimage->height + 2), IPL_DEPTH_8U, inputimage->nChannels);
    	//IplImage *smoothimage = cvCreateImage(cvSize(inputimage->width, inputimage->height), IPL_DEPTH_8U, inputimage->nChannels);
    		cvCopyMakeBorder(inputimage, extensionimage, cvPoint(1, 1), IPL_BORDER_REPLICATE);	//进行边界扩展,原图像在新图像的(1,1)位置,IPL_BORDER_REPLICATE表示扩展为边界像素
    	
    		for (int i = 0; i < smoothimage->height; i++)
    		{
    			for (int j = 0; j < smoothimage->width; j++)
    			{
    				for (int k = 0; k < smoothimage->nChannels; k++)
    				{
    					float average, variance = 0;	
    					float shuzu[9] = {};
    					int pos = 0;
    					for (int m = -1; m < 2; m++)
    					{
    						for (int n = -1; n < 2; n++)
    						{
    							shuzu[pos++] = (unsigned char)extensionimage->imageData[(i + 1 + m)*extensionimage->widthStep + (j + 1 + n) * extensionimage->nChannels + k] / 9;
    						}
    					}
    					average = avg(shuzu);				//计算均值
    					variance = var(shuzu, average);		//计算方差
    					float root = sqrt(variance);
    					if (variance < 1)	//防止相似像素间的方差过小,造成错误
    					{
    						smoothimage->imageData[i*smoothimage->widthStep + j * smoothimage->nChannels + k]
    							= (unsigned char)extensionimage->imageData[(i + 1)*extensionimage->widthStep + (j + 1) * extensionimage->nChannels + k];
    						//printf("%f\n", variance);
    					}
    					else
    					{
    						float temp = 0.0;
    						float w = 0.0;
    
    						float num1[9] = { 1.414,1,1.414,1,0,1,1.414,1,1.414 };	//位置信息
    						int s = 0;
    
    						for (int m = -1; m < 2; m++)
    						{
    							for (int n = -1; n < 2; n++)
    							{
    								float e, e1, e2, den1, num2, den2;
    								//num1 = (m ^ 2 + n ^ 2) ^ (1/2);
    								den1 = 0.182;
    								e1 = exp(-num1[s++] / den1);
    								unsigned char x, y;
    								x = (unsigned char)extensionimage->imageData[(i + 1)*extensionimage->widthStep + (j + 1) * extensionimage->nChannels + k];
    								y = (unsigned char)extensionimage->imageData[(i + 1 + m)*extensionimage->widthStep + (j + 1 + n)* extensionimage->nChannels + k];
    								num2 = x < y ? (y - x) : (x - y);	//像素信息转换为无符号字符型0-255之间,保证差值为整数
    								num2 = pow(num2, 2);
    								den2 = variance;
    								e2 = exp(-num2 / (2 * den2));
    								e = e1 * e2;
    								w += e;
    								temp += e * (unsigned char)extensionimage->imageData
    									[(i + 1 + m)*extensionimage->widthStep + (j + 1 + n)* extensionimage->nChannels + k];
    							}
    						}
    
    						smoothimage->imageData[i*smoothimage->widthStep + j * smoothimage->nChannels + k] = temp / w;
    					}
    				}
    			}
    		}
    
    		for (int i = 0; i < smoothimage->height; i++)
    		{
    			for (int j = 0; j < smoothimage->width; j++)
    			{
    				for (int k = 0; k < smoothimage->nChannels; k++)
    				{
    					inputimage->imageData[i*inputimage->widthStep + j * inputimage->nChannels + k]
    						= smoothimage->imageData[i*smoothimage->widthStep + j * smoothimage->nChannels + k];
    				}
    			}
    		}
    		z++;
    	}
    	cvNamedWindow("inputimage", 1);
    	cvNamedWindow("smoothimage", 1);
    	
    	cvShowImage("inputimage", inputimage);
    	cvShowImage("smoothimage", smoothimage);
    	
    	cvWaitKey(0);
    
    	cv::Mat smooth = cv::cvarrToMat(smoothimage);
    	cv::imwrite("buildingsmooth.bmp", smooth);
    	/*const char *file = "G:\\flower_filter.bmp";
    	cvSaveImage(file, smoothimage);*/
    
    	cvDestroyWindow("inputimage");
    	cvDestroyWindow("smoothimage");
    
    	cvReleaseImage(&inputimage);
    	cvReleaseImage(&smoothimage);
    }

    具体实现效果如下,从左到右依次为 原噪声图像---双边滤波15次后的图像---双边滤波后30次的图像---双边滤波后40次的图像

    展开全文
  • 噪声分类及其消除方法3.1 高斯噪声及其消除方式3.1.1 如何确定一种噪声是高斯噪声3.1.2 高斯滤波消除高斯噪声3.1.3 高斯函数的重要性质3.2 瑞利噪声及其消除方式3.3 伽马(爱尔兰)噪声及其消除方式3.4 指数分布...
  • 图像噪声与去噪

    2020-05-15 10:28:34
     图像在生成和传输过程中常常因受到各种噪声的干扰和影响而是图像降质,这对后续图像处理图像视觉效应将产生不利影响。噪声种类很多,比如:电噪声,机械噪声,信道噪声和其他噪声。因此,为了抑制噪声,改善...
  • 图像处理去噪的方法

    2010-07-03 15:14:00
    一幅图象在实际应用中可能存在各种各样的噪声,这些噪声可能在传输中产生,也可能在量化等处理中产生。根据噪声和信号的关系可将其分为三种形式:(f(x,y)表示给定原始图象,g(x,y)表示图象信号,n(x,y)表示噪声。) 1...
  • 噪声分类: 高斯噪声 是随机噪声, 服从高斯分布 主要特点表现为:麻点 椒盐噪声 胡椒噪声、盐噪声 主要特点表现为:黑白点 噪声的描述 均方误差 MSE : MSE越大,失真率越大 峰值信噪比 PSNR:...
  • 噪声表现形式:噪声在图像上常表现为一引起较强视觉效果的孤立像素点或像素...另外,在图像处理的某些环节当输入的像对象并不如预想时也会在结果图像中引入噪声 噪声对数字图像的影响:对于数字图像信号,噪声表为或大
  • 图像噪声与滤波处理 二、实验目的 1.熟悉MATLAB软件的使用。 2.掌握图像噪声与滤波处理。 三、实验内容 1.对一张图片添加不同强度的高斯噪声、椒盐噪声 2.对图像进行不同模板的均值滤波、高斯加权滤波、中值滤波...
  • python数字图像处理-图像噪声与去噪算法图像噪声椒盐噪声概述: 椒盐噪声(salt & pepper noise)是数字图像的一个常见噪声,所谓椒盐,椒就是黑,盐就是白,椒盐噪声就是在图像上随机出现黑色白色的像素。椒盐噪声...
  • 噪声模型、噪声应用、相关函数、imnoise2、imnoise3、估计噪声参数
  • 图像噪声的由来多种多样,本文主要介绍由热噪声产生的高斯白噪声噪声服从正太分布,功率谱均匀)和开关不正常使用时产生的椒盐噪声处理。 高斯噪声 高斯噪声在日常生活中存在比较普遍,下面我将为图像添加高斯...
  • 噪声图像处理的影响很大,它影响图像处理的输入、采集和处理等各个环节以及输出结果。因此,在进行其它的图像处理前,需要对图像进行去噪处理。 从统计学的观点来看,凡是统计特征不随时间变化的噪声称为平稳噪声...
  • 图像噪声使图像在获取或是传输过程中收到随机信号干扰,妨碍人们对图像理解及分析处理的信号。很多时候将图像噪声看做多维随机过程,因而描述噪声的方法完全可以借用随机过程的描述,也就是使用随机过程的描述,也...
  • 图像噪声是图像在获取或传输的过程中受到随机信号干扰,妨碍人们对图像处理及分析处理的信号。很多时候将图像噪声看作多位随机过程,因而描述噪声的方法完全可以借用随机过程的描述,即使用其概率分布函数和二概率...
  • 图像处理 椒盐噪声

    2017-12-15 11:01:55
    椒盐噪声
  • 噪声建模,然后用模型实现各式各样的噪声。  实际生活中的各种照片的老化,都可以归结为以下老化模型。  这个模型很简单,也可以直接用以下公式来表达。 在频域内,用以下公式区表示。  根据以上式子,...
  • 傅立叶变换在图像处理中有非常重要的作用。因为不仅傅立叶分析涉及图像处理很多方面,傅立 叶改进算法,比如离散余弦变换,gabor与小波在图像处理中也有重要的分量。傅立叶变换在图像处理的重要作用:  1.图像增强...
1 2 3 4 5 ... 20
收藏数 54,868
精华内容 21,947