opencv03空域滤波

最新推荐文章于 2024-04-04 14:52:32 发布
最新推荐文章于 2024-04-04 14:52:32 发布
阅读量466 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： 数字图像处理 文章标签： opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43208303/article/details/88917334
本文介绍了一组图像处理实验，包括使用均值与高斯模板平滑灰度及彩色图像、利用Laplacian、Robert及Sobel算子进行边缘检测、采用高提升滤波算法增强图像等。通过OpenCV库实现了各种滤波器的应用，并展示了不同参数下的处理效果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

实验内容:

1、利用均值模板平滑灰度图像。
具体内容:利用 OpenCV 对图像像素进行操作，分别利用 33、55 和 9*9 尺寸的均值模板平滑灰度图像

2、利用高斯模板平滑灰度图像。
具体内容:利用 OpenCV 对图像像素进行操作，分别利用 33、55 和 9*9 尺寸的高斯模板平滑灰度图像

3、利用 Laplacian、Robert、Sobel 模板锐化灰度图像。
具体内容:利用 OpenCV 对图像像素进行操作，分别利用 Laplacian、Robert、Sobel 模板锐化灰度图像

4、利用高提升滤波算法增强灰度图像。
具体内容:利用 OpenCV 对图像像素进行操作，设计高提升滤波算法增强图像

5、利用均值模板平滑彩色图像。
具体内容:利用 OpenCV 分别对图像像素的 RGB 三个通道进行操作，利用 33、55 和 9*9 尺寸的均值模板平滑彩色图像

6、利用高斯模板平滑彩色图像。
具体内容:利用 OpenCV 分别对图像像素的 RGB 三个通道进行操作，分别利用 33、55 和 9*9 尺寸的高斯模板平滑彩色图像

7、利用 Laplacian、Robert、Sobel 模板锐化灰度图像。
具体内容:利用 OpenCV 分别对图像像素的 RGB 三个通道进行操作，分别利用 Laplacian、Robert、Sobel 模板锐化彩色图像

实验代码：

完整课程PPT和实验要求戳：https://github.com/MintLucas/Digital_image_process

（讲解用注释标注在代码中）

#include<iostream>
#include<string>
#include "Lab03_spacialFilter.hpp"
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/core/types_c.h>
#include <opencv2/core/core_c.h>

using namespace std;
using namespace cv;

int spacialFilter(vector<float> f)
{
    Mat image, res;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", IMREAD_COLOR); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    res.create(image.size(), image.type());//为输出图像分配内容
    
    /*拉普拉斯滤波核3*3
     0  -1   0
     -1   5  -1
     0  -1   0  */
    //处理除最外围一圈外的所有像素值
    
    for (int i = 1; i < image.rows - 1; i++)
    {
        const uchar * pre = image.ptr<const uchar>(i - 1);//前一行
        const uchar * cur = image.ptr<const uchar>(i);//当前行，第i行
        const uchar * next = image.ptr<const uchar>(i + 1);//下一行
        uchar * output = res.ptr<uchar>(i);//输出图像的第i行
        int ch = image.channels();//通道个数
        int startCol = ch;//每一行的开始处理点
        int endCol = (image.cols - 1)* ch;//每一行的处理结束点
        for (int j = startCol; j < endCol; j++)
        {
            //输出图像的遍历指针与当前行的指针同步递增, 以每行的每一个像素点的每一个通道值为一个递增量, 因为要
            
            //考虑到图像的通道数
            //saturate_cast<uchar>保证结果在uchar范围内
            if(f.size() == 9){
                //*output++ = saturate_cast<uchar>(5 * cur[j] - pre[j] - next[j] - cur[j - ch] - cur[j + ch]);
                *output++ = saturate_cast<uchar>(f[0]*pre[j-ch] + f[1]*pre[j] + f[2]*pre[j+ch] + f[3]*cur[j-ch] + f[4]*cur[j] + f[5]*cur[j+ch] + f[6]*next[j-ch] + f[7]*next[j] + f[8]*next[j+ch]);
            }
         
        }
    }
    //将最外围一圈的像素值设为0
    res.row(0).setTo(Scalar(0));
    res.row(res.rows - 1).setTo(Scalar(0));
    res.col(0).setTo(Scalar(0));
    res.col(res.cols - 1).setTo(Scalar(0));
    /*/或者也可以尝试将最外围一圈设置为原图的像素值
     image.row(0).copyTo(result.row(0));
     image.row(image.rows-1).copyTo(result.row(result.rows-1));
     image.col(0).copyTo(result.col(0));
     image.col(image.cols-1).copyTo(result.col(result.cols-1));*/
    namedWindow("拉普拉斯模板-手写", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("拉普拉斯模板-手写", res);                // Show our image inside it.
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}

int xGradient(Mat image, int x, int y)
{
    int gx;
    gx = image.at<uchar>(y-1,x+1) + 2*image.at<uchar>(y,x+1) + image.at<uchar>(y+1,x+1)
    - image.at<uchar>(y-1,x-1) - 2*image.at<uchar>(y,x-1) -image.at<uchar>(y-1,x-1);
    return gx;
}
int yGradient(Mat image, int x, int y)
{
    int gy;
    gy = image.at<uchar>(y-1,x+1) + 2*image.at<uchar>(y-1,x) + image.at<uchar>(y+1,x+1)
    - image.at<uchar>(y-1,x-1) - 2*image.at<uchar>(y+1,x) -image.at<uchar>(y-1,x-1);
    return gy;
}

int sobelXY()
{
    int Gx, Gy, sum;
    Mat img = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", 0);
    Mat dst = img.clone();
    if(!img.data)
        return -1;
    
    for ( int y = 0; y < img.rows; y++)
    {
        for( int x = 0; x < img.cols; x++)
        {
            dst.at<uchar>(y,x) = 0.0;
        }
    }
    
    for ( int y = 1; y < img.rows - 1; y++ )
    {
        for ( int x = 1; x < img.cols - 1 ; x++ )//错误原因，-1忘了，所以维数不匹配
        {
            Gx = xGradient(img, x, y);
            Gy = yGradient(img, x, y);
            sum = abs(Gx) + abs(Gy);
            sum = sum > 255 ? 255 : sum;
            sum = sum < 0 ? 0 : sum;
            dst.at<uchar>(y,x) = sum;
        }
    }
    
    imshow("Sobel",dst);
    waitKey(0);
    return 0;
    
}



int MeanFilter_Gray(int a,int b)
{
    Mat image, meanRes;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", 0); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    blur(image, meanRes, Size(a, b));            //均值滤波
    
    namedWindow("均值滤波", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("均值滤波", meanRes);                // Show our image inside it.
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}

int MeanFilter_Color(int a, int b)
{
    Mat image, meanRes;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", 1); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    blur(image, meanRes, Size(a, b));            //均值滤波
    
    namedWindow("均值滤波", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("均值滤波", meanRes);                // Show our image inside it.
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}

int GaussianFilter_Gray(int a, int b)
{
    Mat image, res;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", 0); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    GaussianBlur(image, res, Size(a, b), 1);
    
    namedWindow("高斯滤波", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("高斯滤波", res);                // Show our image inside it.
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}

int GaussianFilter_Color(int a, int b)
{
    Mat image, res;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", 1); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    GaussianBlur(image, res, Size(a, b), 1);
    
    namedWindow("高斯滤波", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("高斯滤波", res);                // Show our image inside it.
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}


int Sobel()
{
    Mat grad_x, grad_y;
    Mat abs_grad_x, abs_grad_y;
    Mat image, res;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", 0); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    Sobel(image, grad_x, image.depth(), 1, 0, 3, 1, 1, BORDER_DEFAULT);
    convertScaleAbs(grad_x, abs_grad_x);
    imshow("【效果图】 X方向Sobel", abs_grad_x);
    
    Sobel(image, grad_y, image.depth(), 0, 1, 3, 1, 1, BORDER_DEFAULT);
    convertScaleAbs(grad_y, abs_grad_y);
    imshow("【效果图】Y方向Sobel", abs_grad_y);
    
    //【5】合并梯度(近似)
    addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, res);
    imshow("【效果图】整体方向Sobel", res);
    
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}

int Sobel_Color()
{
    Mat grad_x, grad_y;
    Mat abs_grad_x, abs_grad_y;
    Mat image, res;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", 1); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    Sobel(image, grad_x, image.depth(), 1, 0, 3, 1, 1, BORDER_DEFAULT);
    convertScaleAbs(grad_x, abs_grad_x);
    imshow("【效果图】 X方向Sobel", abs_grad_x);
    
    Sobel(image, grad_y, image.depth(), 0, 1, 3, 1, 1, BORDER_DEFAULT);
    convertScaleAbs(grad_y, abs_grad_y);
    imshow("【效果图】Y方向Sobel", abs_grad_y);
    
    //【5】合并梯度(近似)
    addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, res);
    imshow("【效果图】整体方向Sobel", res);
    
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}

//拉普拉斯模板
int Laplacian_Color()
{
    Mat image, res;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", IMREAD_COLOR); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    Mat kernel = (Mat_<float>(3, 3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
    filter2D(image, res, image.depth(), kernel);
    
    namedWindow("拉普拉斯模板", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("拉普拉斯模板", res);                // Show our image inside it.
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}

int Laplacian_Gray()
{
    Mat image, res;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", 0); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    Mat kernel = (Mat_<float>(3, 3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
    filter2D(image, res, image.depth(), kernel);
    
    namedWindow("拉普拉斯模板", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("拉普拉斯模板", res);                // Show our image inside it.
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}


int Lap2()
{
    Mat image, res;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", IMREAD_COLOR); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    res.create(image.size(), image.type());//为输出图像分配内容
    
    /*拉普拉斯滤波核3*3
     0  -1   0
     -1   5  -1
     0  -1   0  */
    //处理除最外围一圈外的所有像素值
    
    for (int i = 1; i < image.rows - 1; i++)
    {
        const uchar * pre = image.ptr<const uchar>(i - 1);//前一行
        const uchar * cur = image.ptr<const uchar>(i);//当前行，第i行
        const uchar * next = image.ptr<const uchar>(i + 1);//下一行
        uchar * output = res.ptr<uchar>(i);//输出图像的第i行
        int ch = image.channels();//通道个数
        int startCol = ch;//每一行的开始处理点
        int endCol = (image.cols - 1)* ch;//每一行的处理结束点
        for (int j = startCol; j < endCol; j++)
        {
            //输出图像的遍历指针与当前行的指针同步递增, 以每行的每一个像素点的每一个通道值为一个递增量, 因为要
            
            //考虑到图像的通道数
            //saturate_cast<uchar>保证结果在uchar范围内
            *output++ = saturate_cast<uchar>(5 * cur[j] - pre[j] - next[j] - cur[j - ch] - cur[j + ch]);
        }
    }
    //将最外围一圈的像素值设为0
    res.row(0).setTo(Scalar(0));
    res.row(res.rows - 1).setTo(Scalar(0));
    res.col(0).setTo(Scalar(0));
    res.col(res.cols - 1).setTo(Scalar(0));
    /*/或者也可以尝试将最外围一圈设置为原图的像素值
     image.row(0).copyTo(result.row(0));
     image.row(image.rows-1).copyTo(result.row(result.rows-1));
     image.col(0).copyTo(result.col(0));
     image.col(image.cols-1).copyTo(result.col(result.cols-1));*/
    namedWindow("拉普拉斯模板-手写", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("拉普拉斯模板-手写", res);                // Show our image inside it.
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}

int Robert_RGB()
{
    Mat image, res;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", 1); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    
    res = image.clone();
    
    CvScalar t1, t2, t3, t4, t;
    IplImage res2 = IplImage(image);
    
    for (int i = 0; i < res2.height-1; i++)
    {
        for (int j = 0; j < res2.width-1; j++)
        {
            t1 = cvGet2D(&res2, i, j);
            t2 = cvGet2D(&res2, i+1, j+1);
            t3 = cvGet2D(&res2, i, j + 1);
            t4 = cvGet2D(&res2, i + 1, j);
            
            
            for (int k = 0; k < 3; k++)
            {
                int t7 = (t1.val[k] - t2.val[k])*(t1.val[k] - t2.val[k])+ (t4.val[k] - t3.val[k])*(t4.val[k] - t3.val[k]);
                t.val[k] = sqrt(t7);
            }
            cvSet2D(&res2, i, j, t);
        }
    }
    res = cvarrToMat(&res2);
    namedWindow("Robert_RGB滤波", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("Robert_RGB滤波", res);                // Show our image inside it.
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
}

int Robert_G()
{
    Mat image, res;
    image = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png", 0); // Read the file
    namedWindow("原图", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("原图", image);                // Show our image inside it.
    res = image.clone();
    
    for (int i = 0; i < image.rows - 1; i++) {
        for (int j = 0; j < image.cols - 1; j++) {
            //根据公式计算
            int t1 = (image.at<uchar>(i, j) -
                      image.at<uchar>(i + 1, j + 1))*
            (image.at<uchar>(i, j) -
             image.at<uchar>(i + 1, j + 1));
            int t2 = (image.at<uchar>(i + 1, j) -
                      image.at<uchar>(i, j + 1))*
            (image.at<uchar>(i + 1, j) -
             image.at<uchar>(i, j + 1));
            //计算g（x,y）
            res.at<uchar>(i, j) = (uchar)sqrt(t1 + t2);
        }
    }
    
    namedWindow("Robert_G滤波", WINDOW_AUTOSIZE); // Create a window for display.
    imshow("Robert_G滤波", res);                // Show our image inside it.
    waitKey(0); // Wait for a keystroke in the window
    destroyAllWindows();
    return 0;
    
}


void EnhanceFilter(Mat img, Mat &dst, double dProportion, int nTempH, int nTempW, int nTempMY, int nTempMX, float *pfArray, float fCoef)
{
    
    
    int i, j, nHeight = img.rows, nWidth = img.cols;
    vector<vector<int>> GrayMat1, GrayMat2, GrayMat3;//暂存按比例叠加图像，R,G,B三通道
    vector<int> vecRow1(nWidth, 0), vecRow2(nWidth, 0), vecRow3(nWidth, 0);
    for (i = 0; i < nHeight; i++)
    {
        GrayMat1.push_back(vecRow1);
        GrayMat2.push_back(vecRow2);
        GrayMat3.push_back(vecRow3);
    }
    
    //锐化图像，输出带符号响应，并与原图像按比例叠加
    for (i = nTempMY; i < nHeight - (nTempH - nTempMY) + 1; i++)
    {
        for (j = nTempMX; j < nWidth - (nTempW - nTempMX) + 1; j++)
        {
            float fResult1 = 0;
            float fResult2 = 0;
            float fResult3 = 0;
            for (int k = 0; k < nTempH; k++)
            {
                for (int l = 0; l < nTempW; l++)
                {
                    //分别计算三通道加权和
                    fResult1 += img.at<Vec3b>(i, j)[0] * pfArray[k*nTempW + 1];
                    fResult2 += img.at<Vec3b>(i, j)[1] * pfArray[k*nTempW + 1];
                    fResult3 += img.at<Vec3b>(i, j)[2] * pfArray[k*nTempW + 1];
                }
            }
            
            //三通道加权和分别乘以系数并限制响应范围，最后和原图像按比例混合
            fResult1 *= fCoef;
            if (fResult1 > 255)
                fResult1 = 255;
            if (fResult1 < -255)
                fResult1 = -255;
            GrayMat1[i][j] = dProportion * img.at<Vec3b>(i, j)[0] + fResult1 + 0.5;
            
            fResult2 *= fCoef;
            if (fResult2 > 255)
                fResult2 = 255;
            if (fResult2 < -255)
                fResult2 = -255;
            GrayMat2[i][j] = dProportion * img.at<Vec3b>(i, j)[1] + fResult2 + 0.5;
            
            fResult3 *= fCoef;
            if (fResult3 > 255)
                fResult3 = 255;
            if (fResult3 < -255)
                fResult3 = -255;
            GrayMat3[i][j] = dProportion * img.at<Vec3b>(i, j)[2] + fResult3 + 0.5;
        }
    }
    int nMax1 = 0, nMax2 = 0, nMax3 = 0;//三通道最大灰度和值
    int nMin1 = 65535, nMin2 = 65535, nMin3 = 65535;//三通道最小灰度和值
    //分别统计三通道最大值最小值
    for (i = nTempMY; i < nHeight - (nTempH - nTempMY) + 1; i++)
    {
        for (j = nTempMX; j < nWidth - (nTempW - nTempMX) + 1; j++)
        {
            if (GrayMat1[i][j] > nMax1)
                nMax1 = GrayMat1[i][j];
            if (GrayMat1[i][j] < nMin1)
                nMin1 = GrayMat1[i][j];
            
            if (GrayMat2[i][j] > nMax2)
                nMax2 = GrayMat2[i][j];
            if (GrayMat2[i][j] < nMin2)
                nMin2 = GrayMat2[i][j];
            
            if (GrayMat3[i][j] > nMax3)
                nMax3 = GrayMat3[i][j];
            if (GrayMat3[i][j] < nMin3)
                nMin3 = GrayMat3[i][j];
        }
    }
    //将按比例叠加后的三通道图像取值范围重新归一化到[0,255]
    int nSpan1 = nMax1 - nMin1, nSpan2 = nMax2 - nMin2, nSpan3 = nMax3 - nMin3;
    for (i = nTempMY; i < nHeight - (nTempH - nTempMY) + 1; i++)
    {
        for (j = nTempMX; j < nWidth - (nTempW - nTempMX) + 1; j++)
        {
            int br, bg, bb;
            if (nSpan1 > 0)
                br = (GrayMat1[i][j] - nMin1) * 255 / nSpan1;
            else if (GrayMat1[i][j] <= 255)
                br = GrayMat1[i][j];
            else
                br = 255;
            dst.at<Vec3b>(i, j)[0] = br;
            
            if (nSpan2 > 0)
                bg = (GrayMat2[i][j] - nMin2) * 255 / nSpan2;
            else if (GrayMat2[i][j] <= 255)
                bg = GrayMat2[i][j];
            else
                bg = 255;
            dst.at<Vec3b>(i, j)[1] = bg;
            
            if (nSpan3 > 0)
                bb = (GrayMat3[i][j] - nMin3) * 255 / nSpan3;
            else if (GrayMat3[i][j] <= 255)
                bb = GrayMat3[i][j];
            else
                bb = 255;
            dst.at<Vec3b>(i, j)[2] = bb;
        }
    }
}

int enhanceFilter()
{
    Mat img = imread("/Users/zhipeng/ustc_term2/Opencv/Opencv/Opencv/Digital_imgae_process/CSet12/lena.png");
    imshow("原图", img);
    Mat dst = img.clone();

    float Template_Laplacian2[9] = { -1, -1, -1, -1, 8, -1, -1, -1, -1 };//对45度各向同性
    /*************************************************************************************************************
     高提升滤波
     dProportion：高提升滤波中原图像的混合比例
     nTempH：模板高度，nTempW：模板宽度
     nTempMY：模板中心元素坐标，nTempMX：模板中心元素坐标
     fpArray：指向模板数组的指针，可以选取不同模板实现不同滤波的高提升版本
     fCoef：模板系数
     **************************************************************************************************************/
    EnhanceFilter(img, dst, 1.8, 3, 3, 1, 1, Template_Laplacian2, 1);
    
    imshow("高提升Laplacian", dst);
    waitKey(0);
    destroyAllWindows();
    return 0;
}

int Lab03()
{
    vector<float> Template_Smooth_Avg = { 1/9, 1/9, 1/9, 1/9, 1/9, 1/9, 1/9, 1/9, 1/9 };
    //Gauss平滑1/16
    vector<float> Template_Smooth_Gauss = { 1, 2, 1, 2, 4, 2, 1, 2, 1 };
    //Sobel垂直边缘检测
    vector<float> Template_Smooth_HSobel = { -1, 0, 1, -2, 0, 2, -1, 0, 1 };
    //Sobel水平边缘检测
    vector<float> Template_Smooth_VSobel = { -1, -2, -1, 0, 0, 0, 1, 2, 1 };
    //LOG边缘检测
    vector<float> Template_Log = { 0, 0, -1, 0, 0, 0, -1, -2, -1, 0, -1, -2, 16, -2, -1, 0, -1, -2, -1, 0, 0, 0, -1, 0, 0 };
    //Laplacian边缘检测
    vector<float> Template_Laplacian1 = { 0, -1, 0, -1, 5, -1, 0, -1, 0 };//对90度各向同性
    vector<float> Template_Laplacian2 = { -1, -1, -1, -1, 8, -1, -1, -1, -1 };//对45度各向同性
    
//    MeanFilter_Gray(3,3);
//    MeanFilter_Gray(5, 5);
//    MeanFilter_Gray(9, 9);
//    GaussianFilter_Gray(3,3);
//    GaussianFilter_Gray(5, 5);
//    GaussianFilter_Gray(9, 9);
//    Laplacian_Gray();
//    Robert_G();
    //Sobel();
    
    
    MeanFilter_Color(3, 3);
    MeanFilter_Color(5, 5);
    MeanFilter_Color(9, 9);
    GaussianFilter_Color(3, 3);
    GaussianFilter_Color(5, 5);
    GaussianFilter_Color(9, 9);
    sobelXY();
    spacialFilter(Template_Laplacian1);
    spacialFilter(Template_Laplacian2);
    Laplacian_Color();
    enhanceFilter();
    
    
//    Robert_RGB();
//    Sobel_Color();
    return 0;
}
OpenCV BLOB检测和过滤区域的实例(附完整代码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-26 634
OpenCV BLOB检测和过滤区域的实例OpenCV BLOB检测和过滤区域的实例 OpenCV BLOB检测和过滤区域的实例 #include <opencv2/core.hpp> #include <opencv2/imgproc.hpp> #include <opencv2/highgui.hpp> #include <opencv2/features2d.hpp> #include <vector> #include <map&gt
数字图像处理 opencv 实验三 图像的平滑
yzc66666的博客
07-11 1039
一.实验目的： 掌握opencv开发环境中对灰度图像及彩色图像中的像素的访问方法 掌握opencv中对图像进行处理的基本过程。 掌握均值平滑和中值滤波的基本原理。 二.实验内容： 打开一幅灰度图像，对图像进行3*3（包括中心点）的邻域平均处理。 对原图进行3*3（包括中心点）的中值滤波处理。 比较原图像与邻域平均的图像、中值滤波后的图像的差异。 #include <opencv2/opencv.hpp> #include <opencv2/highgui/highgui.hpp&g
基于opencv的图像空域滤波处理
11-30
一个图像滤波处理的演示程序 ，实现图像的几种空域模板方法，包括 均值滤波 ，中值滤波 ，高斯滤波 ，sobel算子，laplace算子，滤波参数可调 程序界面基于MFC,VC6.0 滤波函数基于opencv1.0 ps，程序存在bug,懒得改了....
我的OpenCV学习笔记（九）：空域滤波之中值滤波
java开发指南博客 【转载】
04-30 219
中值滤波就是将当前像素值替换为模板覆盖范围内的所有像素值中大小居中那一个：对于一个3*3的模板，第5大的就是中值： （10,15,20,20,20,20,20,25,100） 中值滤波使得那些更亮（或者更暗）的点更像他周围的值。所以它在滤除噪音的同时，可以较好地保留细节轮廓。 为了验证上述结论，我先给一幅图像加入椒盐噪声，然后用分别用中值滤波、均值滤波处理图像，进行对比： #include...
【OpenCv】(python)超大图像的二值化方法(空白过滤)
java_pythons的博客
08-09 666
超大图像的二值化方法 （1）.可以采用分块方法， （2）.先缩放处理就行二值化，然后还原大小 1、局部阈值、全局阈值 import cv2 as cv import numpy as np """ def big_image_binary(image): print(image.shape) #(4208, 2368, 3)　　#超大图像，屏幕无法显示完整 cw,ch = 256,256 h,w = image.shape[:2] gray = cv.cvtColor(i
【OpenCV】Chapter5.空间域图像滤波
兴趣使然的创作者
08-24 1372
最近想对OpenCV进行系统学习，看到网上这份教程写得不错，于是跟着来学习实践一下。
【Opencv-Python】数字图像处理(三)——空域图像处理(二)
weixin_64876095的博客
11-09 1033
通过本次实验，我深入了解了图像处理的基本原理和不同滤波器的特点和应用范围。我不仅掌握了如何使用均值滤波、高斯滤波和中值滤波对图像进行去噪和平滑处理，还学习了如何利用拉普拉斯模板对图像进行锐化处理。同时，我也了解了图像运算的基本概念和方法。在实验过程中，我通过观察和比较处理后的图像，发现不同滤波器在去噪效果和图像平滑效果方面有着不同的表现。均值滤波对消除图像中的随机噪声（特别是高斯噪声）有较好的效果，但会降低图像的清晰度。高斯滤波能更好地消除高斯噪声，但仍然会保留一部分噪声。
空域滤波算法对比分析报告
06-25
**空域滤波算法对比分析报告** 在图像处理领域，空域滤波是一种常见的方法，用于去除噪声，提升图像质量。本报告将深入探讨不同类型的空域滤波算法，包括椒盐噪声、高斯噪声以及对应的滤波技术，如均值滤波、中值...
06_图像实验3 - 空域滤波1
08-03
本实验将重点介绍在使用OpenCV库时如何应用空域滤波的两种主要方法——图像平滑和图像锐化。 在图像平滑中，我们主要关注于消除图像中的噪声以及减少图像的细节，这对于后续的图像分析尤为重要。噪声是图像获取过程...
OpenCV空域滤波
最新发布
12-31
### OpenCV 空域滤波实现方法及示例 #### 1. 高斯滤波 高斯滤波是一种常见的平滑技术，用于减少图像中的噪声。通过应用二维卷积核来计算像素的新值。 ```python import cv2 as cv import numpy as np # 加载图像 ...
OpenCV中滤波算法的归纳
weixin_46627194的博客
04-04 1573
在OpenCV中，滤波是一种常见的图像处理技术，用于去噪、平滑或锐化图像。不同的滤波方法有不同的特点和适用场景。
c++滤波程序，含有中值、高斯、平滑滤波
03-09
中值、高斯、平滑滤波，c++编写，已调试。中值、高斯、平滑滤波，c++编写，已调试。
采用3×3的窗口模板。实现了均值滤波的操作
04-08
采用3×3的窗口模板。实现了均值滤波的操作
数字图像处理（空域平滑）
09-16
数字图像四邻域平滑法，中值滤波法，阈值平均法，加权平均法
图像处理实验3:空域滤波
Tifa_Best的专栏
03-29 1455
要求 利用均值模板平滑灰度图像。 具体内容:利用 OpenCV 对图像像素进行操作,分别利用 33. 55 和 9*9 尺寸的均值模板平滑灰度图像 利用高斯模板平滑灰度图像。 具体内容:利用 OpenCV 对图像像素进行操作,分别利用 33. 55 和 9*9 尺寸的高斯模板平滑灰度图像 利用 Laplacian. Robert. Sobel 模板锐化灰度图像。 具体内容:利用 OpenCV...
opencv读取灰度图像
RobotFreak的博客
03-11 5338
本文记录了C++版opencv读取灰度图像的不同方式及区别
OpenCV图像处理-灰度处理
热门推荐
Code搬运工
06-24 1万+
OpenCV图像处理 灰度处理
【python】opencv总结
可乐大牛的博客
05-07 3123
目录简介基本操作 简介 安装：pip install opencv-python==3.4.2.17 测试： import cv2 # 读一个图片并进行显示(图片路径需自己指定) lena=cv2.imread("1.jpg") cv2.imshow("image",lena) cv2.waitKey(0) 利用SIFT和SURF进行特征提取的话，还需要pip install opencv-contrib-python==3.4.2.17 基础模块：core、highgui、imgproc core模
python图像灰度化_python3读取图片并灰度化图片的四种方法(OpenCV、PIL.Image、TensorFlow方法)总结...
weixin_39788960的博客
11-22 742
在处理图像的时候经常是读取图片以后把图片转换为灰度图。作为一个刚入坑的小白，我在这篇博客记录了四种处理的方法。首先导入包：import numpy as npimport cv2import tensorflow as tffrom PIL import Image方法一：在使用OpenCV读取图片的同时将图片转换为灰度图：img = cv2.imread(imgfile, cv2.IMREAD_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值