[边缘检测算法] Sobel算子及其PC端优化提速20几倍

最新推荐文章于 2024-06-15 16:47:43 发布
最新推荐文章于 2024-06-15 16:47:43 发布
阅读量3.3k 收藏 32
点赞数 9
分类专栏： DIP C-Cpp 文章标签： c++ 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yz2zcx/article/details/114386667
版权
C-Cpp 同时被 2 个专栏收录
77 篇文章 7 订阅
订阅专栏
DIP
21 篇文章 3 订阅
订阅专栏

文章目录

前言

    Sobel是图像处理中非常常见的一种边缘检测算法，本文基于C++和OpenCV对Sobel进行了实现，并对代码进行优化。

一、Sobel算子

    Sobel算子是图像处理中的一个离散微分算子，经典的Sobel算子包含了一个33的矩阵(OpenCV中的Sobel是包含其它尺寸的，本文只实现33及其优化)，其结构如下图所示：
在这里插入图片描述
在这里插入图片描述
如上图所示，一个是X轴方向的算子，一个是Y轴方向的算子。实际上，这两个算子都可以拆分为两个向量的卷积，这两个向量分别是Sobel平滑算子与Sobel差分算子，也就是说X轴方向的Sobel算子是可以拆分为：
在这里插入图片描述
而Y轴方向算子可以拆分为：
在这里插入图片描述
其中的[1 2 1]是3阶的非归一化的Sobel平滑算子，而[1 0 -1]是一个差分算子。

二、实现与优化

    以下内容为对Sobel算子的实现和优化过程，测试图像是一张10000*7002的工业图像。

1.原始版本

    最初版本，我对Sobel的实现代码如下：

unsigned char Table[65026];
    for (int Y = 0; Y < 65026; Y++) Table[Y] = (sqrtf(Y + 0.0f) + 0.5f);
    for (int i = 0; i < nRows; i++)
    {
        for (int j = 0; j < nCols; j++)
        {
            for (int k = 0; k < nChan; k++)
            {
                int n1Pos = (i*(nCols + 2) + j)*nChan + k;
                int n2Pos = (i*(nCols + 2) + j + 1)*nChan + k;
                int n3Pos = (i*(nCols + 2) + j + 2)*nChan + k;
                int n4Pos = ((i + 1)*(nCols + 2) + j)*nChan + k;
                int n5Pos = (i*nCols + j)*nChan + k;
                int n6Pos = ((i + 1)*(nCols + 2) + j + 2)*nChan + k;
                int n7Pos = ((i + 2)*(nCols + 2) + j)*nChan + k;
                int n8Pos = ((i + 2)*(nCols + 2) + j + 1)*nChan + k;
                int n9Pos = ((i + 2)*(nCols + 2) + j + 2)*nChan + k;
                int nX = abs((pSrcData[n3Pos] - pSrcData[n1Pos]
                    + 2 * (pSrcData[n6Pos] - pSrcData[n4Pos])
                    + pSrcData[n9Pos] - pSrcData[n7Pos]));
                int nY = abs((pSrcData[n7Pos] - pSrcData[n1Pos]
                    + 2 * (pSrcData[n8Pos] - pSrcData[n2Pos])
                    + pSrcData[n9Pos] - pSrcData[n3Pos]));
                pDstData[n5Pos] = Table[min(nX * nX + nY * nY, 65025)];
            }
        }
    }

测试时间如下：
在这里插入图片描述

2.第一版优化

    可以看到初步版本有很多中间计算，如n1Pos -n9Pos ，很多计算都是重复的，且与内部循环没有联系，是可以移到for循环外面的，因此有了第一版优化，代码：

uchar* pSrcData1 = NULL;
    uchar* pSrcData4 = NULL;
    uchar* pSrcData7 = NULL;
    unsigned char Table[65026];
    for (int Y = 0; Y < 65026; Y++) Table[Y] = (sqrtf(Y + 0.0f) + 0.5f);
    for (int i = 0; i < nRows; i++)
    {
        int nLine1 = i*(nCols + 2);
        int nLine4 = nLine1 + (nCols + 2);
        int nLine7 = nLine4 + (nCols + 2);
        for (int j = 0; j < nCols; j++)
        {
            pSrcData1 = pSrcData + (nLine1 + j)*nChan;
            pSrcData4 = pSrcData + (nLine4 + j)*nChan;
            pSrcData7 = pSrcData + (nLine7 + j)*nChan;
            int n5Pos = (i*nCols + j)*nChan;
            for (int k = 0; k < nChan; k++)
            {
                int nX = abs(*(pSrcData1 + 2 * nChan + k) - *(pSrcData1 + k)
                    + ((*(pSrcData4 + 2 * nChan + k) - *(pSrcData4 + k)) << 1)
                    + *(pSrcData7 + 2 * nChan + k) - *(pSrcData7 + k));
                int nY = abs(*(pSrcData7 + k) - *(pSrcData1 + k)
                    + ((*(pSrcData7 + nChan + k) - *(pSrcData1 + nChan + k)) << 1)
                    + *(pSrcData7 + 2 * nChan + k) - *(pSrcData1 + 2 * nChan + k));
                pDstData[n5Pos + k] = Table[min(nX * nX + nY * nY, 65025)];
            }
        }
    }

优化之后时间提升了170ms左右：
在这里插入图片描述

3.第二版优化

    可以看到里面还是有冗余计算，就是Sobel算子的矩阵第1、2、3层之间的间隔关系是只跟图像的step有关系，所以不管i、j递进到第几行第几列，这个关系是不变的，那就没必要根据i、j来计算下一个计算步骤的起始点，而是直接加上间隔关系即可，并且也没必要计算第2、3行的起始点，只要计算第一行的起始点就可以，然后根据step推算出第2、3行的起始点即可。所以又进一步优化

    int nChan2 = nChan * 2;
    int nSrcStep = (nCols + 2)*nChan;
    int nDstStep = nCols*nChan;
    unsigned char Table[65026];
    for (int Y = 0; Y < 65026; Y++) Table[Y] = (sqrtf(Y + 0.0f) + 0.5f);
    uchar* pSrcData1 = pSrcData;
    uchar* pSrcData4 = pSrcData1 + nSrcStep;
    uchar* pSrcData7 = pSrcData4 + nSrcStep;
    uchar* pDstData4 = pDstData;
    for (int i = 0; i < nRows; i++)
    {
        for (int j = 0; j < nCols*nChan; j++)
        {
            int nX = (pSrcData1[j + nChan2] - pSrcData1[j]
                + ((pSrcData4[j + nChan2] - pSrcData4[j]) << 1)
                + pSrcData7[j + nChan2] - pSrcData7[j]);
            int nY = (pSrcData7[j] - pSrcData1[j]
                + ((pSrcData7[j + nChan] - pSrcData1[j + nChan]) << 1)
                + pSrcData7[j + nChan2] - pSrcData1[j + nChan2]);
            pDstData4[j] = Table[min(nX * nX + nY * nY, 65025)];
        }
        pSrcData1 += nSrcStep;
        pSrcData4 += nSrcStep;
        pSrcData7 += nSrcStep;
        pDstData4 += nDstStep;
    }

优化后时间加速了接近240ms左右：
在这里插入图片描述

4.第三版优化

    看到有技术大佬用SSE来加速，我也抄袭了一波，实现代码如下：

    int nChan2 = nChan * 2;
    int nSrcStep = (nCols + 2)*nChan;
    int nDstStep = nCols*nChan;
    int nBlockSize = 8;
    int nBlock = nDstStep / nBlockSize;
    unsigned char Table[65026];
    for (int Y = 0; Y < 65026; Y++) Table[Y] = (sqrtf(Y + 0.0f) + 0.5f);
    uchar* pSrcData1 = pSrcData;
    uchar* pSrcData4 = pSrcData1 + nSrcStep;
    uchar* pSrcData7 = pSrcData4 + nSrcStep;
    uchar* pDstData4 = pDstData;
    __m128i Zero = _mm_setzero_si128();
    for (int i = 0; i < nRows; i++)
    {
        for (int j = 0; j < nBlock * nBlockSize; j += nBlockSize)
        {
            __m128i FirstP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData1
                + j)), Zero);
            __m128i FirstP1 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData1
                + j + nChan)), Zero);
            __m128i FirstP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData1
                + j + nChan2)), Zero);
            __m128i SecondP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)
                (pSrcData4 + j)), Zero);
            __m128i SecondP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)
                (pSrcData4 + j + nChan2)), Zero);
            __m128i ThirdP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData7
                + j)), Zero);
            __m128i ThirdP1 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData7
                + j + nChan)), Zero);
            __m128i ThirdP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData7
                + j + nChan2)), Zero);
            __m128i GX16 = _mm_abs_epi16(_mm_add_epi16(_mm_add_epi16(_mm_sub_epi16
            (FirstP0, FirstP2), _mm_slli_epi16(_mm_sub_epi16(SecondP0, SecondP2),
                1)), _mm_sub_epi16(ThirdP0, ThirdP2)));
            __m128i GY16 = _mm_abs_epi16(_mm_sub_epi16(_mm_add_epi16(_mm_add_epi16
            (FirstP0, FirstP2), _mm_slli_epi16(_mm_sub_epi16(FirstP1, ThirdP1),
                1)), _mm_add_epi16(ThirdP0, ThirdP2)));
            __m128i GX32L = _mm_unpacklo_epi16(GX16, Zero);
            __m128i GX32H = _mm_unpackhi_epi16(GX16, Zero);
            __m128i GY32L = _mm_unpacklo_epi16(GY16, Zero);
            __m128i GY32H = _mm_unpackhi_epi16(GY16, Zero);
            __m128i ResultL = _mm_cvtps_epi32(_mm_sqrt_ps(_mm_cvtepi32_ps
            (_mm_add_epi32(_mm_mullo_epi32(GX32L, GX32L), _mm_mullo_epi32(GY32L,
                GY32L)))));
            __m128i ResultH = _mm_cvtps_epi32(_mm_sqrt_ps(_mm_cvtepi32_ps
            (_mm_add_epi32(_mm_mullo_epi32(GX32H, GX32H), _mm_mullo_epi32(GY32H,
                GY32H)))));
            _mm_storel_epi64((__m128i *)(pDstData4 + j), _mm_packus_epi16
            (_mm_packus_epi32(ResultL, ResultH), Zero));
        }
        for (int j = nBlock * nBlockSize; j < nDstStep; j++)
        {
            int nX = (pSrcData1[j + nChan2] - pSrcData1[j]
                + ((pSrcData4[j + nChan2] - pSrcData4[j]) << 1)
                + pSrcData7[j + nChan2] - pSrcData7[j]);
            int nY = (pSrcData7[j] - pSrcData1[j]
                + ((pSrcData7[j + nChan] - pSrcData1[j + nChan]) << 1)
                + pSrcData7[j + nChan2] - pSrcData1[j + nChan2]);
            pDstData4[j] = Table[min(nX * nX + nY * nY, 65025)];
        }
        pSrcData1 = pSrcData1 + nSrcStep;
        pSrcData4 = pSrcData4 + nSrcStep;
        pSrcData7 = pSrcData7 + nSrcStep;
        pDstData4 = pDstData4 + nDstStep;
    }

这里用的是SSE1，在内部计算的时候用8个SSE变量记录8个连续的像素值，每个像素值用16位的数据来表达，这里可以使用_mm_loadl_epi64配合_mm_unpacklo_epi8来实现。
最终的运行时间如下，提升了100多ms：
在这里插入图片描述

5.第四版优化

    上一版本是用SSE1指令集来优化，这一版试试SSE2指令集，代码如下：

    int nChan2 = nChan * 2;
    int nSrcStep = (nCols + 2)*nChan;
    int nDstStep = nCols*nChan;
    int nBlockSize = 8;
    int nBlock = nDstStep / nBlockSize;
    unsigned char Table[65026];
    for (int Y = 0; Y < 65026; Y++) Table[Y] = (sqrtf(Y + 0.0f) + 0.5f);
    uchar* pSrcData1 = pSrcData;
    uchar* pSrcData4 = pSrcData1 + nSrcStep;
    uchar* pSrcData7 = pSrcData4 + nSrcStep;
    uchar* pDstData4 = pDstData;
    __m128i Zero = _mm_setzero_si128();
    for (int i = 0; i < nRows; i++)
    {
        for (int j = 0; j < nBlock * nBlockSize; j += nBlockSize)
        {
            __m128i FirstP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData1
                + j)), Zero);
            __m128i FirstP1 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData1
                + j + nChan)), Zero);
            __m128i FirstP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData1
                + j + nChan2)), Zero);
            __m128i SecondP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)
                (pSrcData4 + j)), Zero);
            __m128i SecondP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)
                (pSrcData4 + j + nChan2)), Zero);
            __m128i ThirdP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData7
                + j)), Zero);
            __m128i ThirdP1 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData7
                + j + nChan)), Zero);
            __m128i ThirdP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData7
                + j + nChan2)), Zero);
            __m128i GX16 = _mm_abs_epi16(_mm_add_epi16(_mm_add_epi16(_mm_sub_epi16
            (FirstP0, FirstP2), _mm_slli_epi16(_mm_sub_epi16(SecondP0, SecondP2),
                1)), _mm_sub_epi16(ThirdP0, ThirdP2)));
            __m128i GY16 = _mm_abs_epi16(_mm_sub_epi16(_mm_add_epi16(_mm_add_epi16
            (FirstP0, FirstP2), _mm_slli_epi16(_mm_sub_epi16(FirstP1, ThirdP1),
                1)), _mm_add_epi16(ThirdP0, ThirdP2)));
            __m128i GXYL = _mm_unpacklo_epi16(GX16, GY16);
            __m128i GXYH = _mm_unpackhi_epi16(GX16, GY16);
            __m128i ResultL = _mm_cvtps_epi32(_mm_sqrt_ps(_mm_cvtepi32_ps
            (_mm_madd_epi16(GXYL, GXYL))));
            __m128i ResultH = _mm_cvtps_epi32(_mm_sqrt_ps(_mm_cvtepi32_ps
            (_mm_madd_epi16(GXYH, GXYH))));
            _mm_storel_epi64((__m128i *)(pDstData4 + j), _mm_packus_epi16
            (_mm_packus_epi32(ResultL, ResultH), Zero));
        }
        for (int j = nBlock * nBlockSize; j < nDstStep; j++)
        {
            int nX = (pSrcData1[j + nChan2] - pSrcData1[j]
                + ((pSrcData4[j + nChan2] - pSrcData4[j]) << 1)
                + pSrcData7[j + nChan2] - pSrcData7[j]);
            int nY = (pSrcData7[j] - pSrcData1[j]
                + ((pSrcData7[j + nChan] - pSrcData1[j + nChan]) << 1)
                + pSrcData7[j + nChan2] - pSrcData1[j + nChan2]);
            pDstData4[j] = Table[min(nX * nX + nY * nY, 65025)];
        }
        pSrcData1 = pSrcData1 + nSrcStep;
        pSrcData4 = pSrcData4 + nSrcStep;
        pSrcData7 = pSrcData7 + nSrcStep;
        pDstData4 = pDstData4 + nDstStep;
    }

时间上有了8ms左右的提升：
在这里插入图片描述

6.第五版优化

    然后我还想再榨干CPU，所以再优化了一版本，利用C++的多线程又实现了一波提升，代码如下：

int nChan2 = nChan * 2;
    int nSrcStep = (nCols + 2)*nChan;
    int nDstStep = nCols*nChan;
    int nBlockSize = 8;
    int nBlock = nDstStep / nBlockSize;
    int nThreadSize = 64;
    int nThreadBlock = nRows / nThreadSize;
    uchar Table[65026];
    for (int Y = 0; Y < 65026; Y++) Table[Y] = (sqrtf(Y + 0.0f) + 0.5f);
    uchar* pSrcData1 = pSrcData;
    uchar* pSrcData4 = pSrcData1 + nSrcStep;
    uchar* pSrcData7 = pSrcData4 + nSrcStep;
    uchar* pDstData4 = pDstData;
    auto _func = [](uchar* pSrcData1, uchar* pSrcData4, uchar* pSrcData7, uchar*
        pDstData4,
        int nBlock, int nBlockSize, int nChan, int nChan2, int nCols, __m128i Zero,
        uchar* Table)
    {
        for (int j = 0; j < nBlock * nBlockSize; j += nBlockSize)
        {
            __m128i FirstP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData1
                + j)), Zero);
            __m128i FirstP1 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData1
                + j + nChan)), Zero);
            __m128i FirstP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData1
                + j + nChan2)), Zero);
            __m128i SecondP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)
                (pSrcData4 + j)), Zero);
            __m128i SecondP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)
                (pSrcData4 + j + nChan2)), Zero);
            __m128i ThirdP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData7
                + j)), Zero);
            __m128i ThirdP1 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData7
                + j + nChan)), Zero);
            __m128i ThirdP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(pSrcData7
                + j + nChan2)), Zero);
            __m128i GX16 = _mm_abs_epi16(_mm_add_epi16(_mm_add_epi16(_mm_sub_epi16
            (FirstP0, FirstP2), _mm_slli_epi16(_mm_sub_epi16(SecondP0, SecondP2),
                1)), _mm_sub_epi16(ThirdP0, ThirdP2)));
            __m128i GY16 = _mm_abs_epi16(_mm_sub_epi16(_mm_add_epi16(_mm_add_epi16
            (FirstP0, FirstP2), _mm_slli_epi16(_mm_sub_epi16(FirstP1, ThirdP1),
                1)), _mm_add_epi16(ThirdP0, ThirdP2)));
            __m128i GXYL = _mm_unpacklo_epi16(GX16, GY16);
            __m128i GXYH = _mm_unpackhi_epi16(GX16, GY16);
            __m128i ResultL = _mm_cvtps_epi32(_mm_sqrt_ps(_mm_cvtepi32_ps
            (_mm_madd_epi16(GXYL, GXYL))));
            __m128i ResultH = _mm_cvtps_epi32(_mm_sqrt_ps(_mm_cvtepi32_ps
            (_mm_madd_epi16(GXYH, GXYH))));
            _mm_storel_epi64((__m128i *)(pDstData4 + j), _mm_packus_epi16
            (_mm_packus_epi32(ResultL, ResultH), Zero));
        }
        for (int j = nBlock * nBlockSize; j < nCols*nChan; j++)
        {
            int nX = (pSrcData1[j + nChan2] - pSrcData1[j]
                + ((pSrcData4[j + nChan2] - pSrcData4[j]) << 1)
                + pSrcData7[j + nChan2] - pSrcData7[j]);
            int nY = (pSrcData7[j] - pSrcData1[j]
                + ((pSrcData7[j + nChan] - pSrcData1[j + nChan]) << 1)
                + pSrcData7[j + nChan2] - pSrcData1[j + nChan2]);
            pDstData4[j] = Table[min(nX * nX + nY * nY, 65025)];
        }
    };
    std::vector<std::future<void>> fut(nThreadSize);
    __m128i Zero = _mm_setzero_si128();
    for (int i = 0; i < nThreadBlock; i++)
    {
        for (int j = 0; j < nThreadSize; j++)
        {
            int index_ = i*nThreadSize + j;
            fut[j] = std::async(std::launch::async, _func, pSrcData1, pSrcData4,
                pSrcData7, pDstData4, nBlock, nBlockSize, nChan, nChan2, nCols, Zero,
                Table);
            pSrcData1 = pSrcData + nSrcStep * index_;
            pSrcData4 = pSrcData1 + nSrcStep;
            pSrcData7 = pSrcData4 + nSrcStep;
            pDstData4 = pDstData + nDstStep * index_;
        }
        for (int j = 0; j < nThreadSize; j++)
        {
            fut[j].wait();
        }
    }
    if (nThreadBlock*nThreadSize < nRows - 1)
    {
        for (int i = nThreadBlock*nThreadSize; i < nRows; i++)
        {
            _func(pSrcData1, pSrcData4, pSrcData7, pDstData4, nBlock, nBlockSize,
                nChan, nChan2, nCols, Zero, Table);
            pSrcData1 = pSrcData1 + nSrcStep;
            pSrcData4 = pSrcData4 + nSrcStep;
            pSrcData7 = pSrcData7 + nSrcStep;
            pDstData4 = pDstData4 + nDstStep;
        }
    }

运行时间又提高了16ms左右：
在这里插入图片描述

总结

    本文主要是采用C++实现了3*3的Sobel算子，并通过代码优化、SSE指令集和多线程技术等方式对算法进行优化，速度从原始版本的600ms，提升到了最后的22ms，速度还是比较可以的，但是最后一版多线程的优化，如果图像不是很大的时候，其实作用不大…
    更多图像处理算法和优化技术，还有待学习，路漫漫…

曾经沧海难为水，除却巫山不是云。
取次花丛懒回顾，半缘修道半缘君。
    ——   元稹 《离思五首·其四》

熊叫大雄
关注
  • 9
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
一种基于Sobel算子梯度增强的边缘检测算法
01-29
针对传统Sobel算子在图像边缘检测中存在的弱边缘提取较差及边缘较粗等不足，提出了一种局部梯度增强的检测算法。算法采用改进的Sobel算子卷积模板计算图像梯度；然后对梯度图像采用局部标准差方法增强局部弱边缘的...
sobel加速器实现
10-09
sobel加速器设计与实现，以及前仿真工程，quartus综合工程。可以直接下载使用。
灵活运用SIMD指令16倍提升Sobel边缘检测的速度（4000*3000的24位图像时间由480ms降低到30ms）
weixin_39450742的博客
07-11 469
本篇博文来自博主Imageshop，打赏或想要查阅更多内容可以移步至Imageshop。 转载自：https://www.cnblogs.com/Imageshop/p/7285564.html 侵删 　　这半年多时间，基本都在折腾一些基本的优化，有很多都是十几年前的技术了，从随大流的角度来考虑，研究这些东西在很多人看来是浪费时间了，即不能赚钱，也对工作能力提升无啥帮助。可我觉得人类所谓的幸福，可以分为物质档次的享受，还有更为复杂的精神上的富有，哪怕这种富有只是存在于短暂的自我满足中也是值得的。..
SSE图像算法优化系列九：灵活运用SIMD指令16倍提升Sobel边缘检测的速度（4000*3000的24位图像时间由480ms降低到30ms）。...
weixin_33881041的博客
08-04 299
　　这半年多时间，基本都在折腾一些基本的优化，有很多都是十几年前的技术了，从随大流的角度来考虑，研究这些东西在很多人看来是浪费时间了，即不能赚钱，也对工作能力提升无啥帮助。可我觉得人类所谓的幸福，可以分为物质档次的享受，还有更为复杂的精神上的富有，哪怕这种富有只是存在于短暂的自我满足中也是值得的。       闲话少说， SIMD指令集，这个古老的东西，从第一代开始算起，也快有近20年的历史了，...
Sobel边缘检测
最新发布
shenqijiji的博客
06-15 859
声明：学习过程中的知识总结，欢迎批评指正。
ZYNQ图像处理(7)——sobel边缘检测
qq_40995480的博客
09-13 7378
sobel边缘检测
sobel边缘检测
mxh3600的博客
02-21 3518
sobel边缘检测
sobel 算子
qq_55025358的博客
04-13 3万+
索伯算子（sobel operator）常用于边缘检测，在粗精度下，是最常用的边缘检测算子，以广泛应用几十年。sobel算子由两个3X3的卷积核构成，分别用于计算中心像素邻域的灰度加权差。分为垂直方向和水平方向的索伯滤波器Gx and Gy。 sobel 算子的用途主要为: 边缘检测时: Gx用于检测纵向边缘, Gy用于检测横向边缘. 计算法线时: Gx用于计算法线的横向偏移, Gy用于计算法线的纵向偏移. sobel算子应用时进行给定图像的卷积操作，卷积为计算图像大矩阵周围像素和滤波.
Sobel算子
热门推荐
GoodShot的专栏
08-22 7万+
幻灯片1 Sobel算子  幻灯片2 一、Sobel边缘检测算子 l 在讨论边缘算子之前，首先给出一些术语的定义： l (1)边缘：灰度或结构等信息的突变处，边缘是一个区域的结束，也是另一个区域的开始，利用该特征可以分割图像。 l (2)边缘点：图像中具有坐标[x，y]，且处在强度显著变化的位置上的点。 l (3)边缘段：对应于边缘点坐标[x，y]及其方位 ，边缘的方位可能是梯度角。
Sobel边缘检测算法
绯雨千叶的博客
02-21 4835
Sobel边缘检测算法，包含与canny，laplace的对比
sobel函数边缘检测_边缘检测_边缘检测；sobel算子_
09-28
sobel算子_”中，关键词“sobel函数”和“sobel算子”表明我们将探讨的是基于Sobel算子的边缘检测方法。 Sobel算子是一种在一维空间中定义的微分算子，被广泛应用于二维图像的梯度计算。它通过计算图像在水平和垂直...
Sobel_sobel算子边缘检测_sobel算子_边缘检测_sobel边缘检测_tipa79_
10-03
本文将深入探讨“Sobel算子”这一经典的边缘检测方法，以及如何利用该算子来实现对图像的边缘检测。 Sobel算子是一种基于微分运算的局部差分算子，用于估计图像的梯度强度和方向。它结合了水平和垂直方向的一阶导数...
matlab图像边缘检测sobel算子梯度图像
05-09
本主题聚焦于使用MATLAB实现图像边缘检测，特别是通过Sobel算子来计算图像的梯度，进而找到图像的边界。Sobel算子是一种广泛应用的微分算子，用于估算图像的梯度强度和方向，从而有效地检测图像边缘。 首先，我们要...
sobel算子边缘检测_sobel_sobel算子_opencv4_边缘_drovecai_
10-02
Sobel算子是一种广泛应用的边缘检测算法，它结合了梯度强度和方向信息来确定图像的边缘。在这个项目中，我们将深入探讨Sobel算子的原理、OpenCV库的使用，以及如何在Visual Studio环境下利用OpenCV4.2实现Sobel算子...
索伯（Sobel）算子原理讲解和实现
weixin_52668444的博客
05-29 1万+
文章目录边缘检测 边缘检测 边缘检测是常用的数字图像处理方法之一。 具体的边缘检测方法可以使用sobel(索伯)来做。 索伯算子是一种多用于边缘检测的离散性差分算子。索伯算子有两组不同的卷积因子，可以多一张图片做横向以及纵向的平面卷积。详细的讲就是，假设要对一张图中的（x，y）这个点使用索伯算子。首先用两个卷积因子分别对该点做卷积，从而可得出该点在这两个方向上的亮度差分近似值。将xy两个方向的亮度近似值进行结合之后，即可得到该点亮度。 得到的是一个数，如果这个值大于了阈值，那么这个点就可以被考虑成边缘点。
OpenCV——Sobel边缘检测
点云侠的博客
10-17 3万+
OpenCV——Sobel边缘检测C++及python代码实现。
图像处理边缘检测算法————sobel算法
weixin_48988753的博客
08-17 4522
图像边缘检测大幅度地减少了数据量，并且剔除了可以认为不相关的信息，保留了图像重要的结构属性。常用的边缘检测模板有Laplacian算子、Roberts算子、Sobel算子、log（Laplacian-Gauss）算子、Kirsch算子和Prewitt算子等。Sobel算子是常用的边缘检测模板，算法比较简单，实际应用中效率比 canny 边缘检测效率要高，但是边缘不如 Canny 检测的准确.计算 Gx 为水平横向梯度幅值（左右两列求和），Gy为垂直方向梯度幅值（上下两行求和）的绝对值，原图像A 进行卷积。
58.Sobel边缘检测算子
twnkie的博客
08-09 3201
注：在梯度运算中，很可能会出现负的灰度值，我们不能再采用uint8类型作为像素的数据类型，而是采用了CV_16S或者CV_32F这种有负数范围的类型，运算结果里的负数也不能不处理，否则在显示的时候就会被截断为0，这样就会丢失边界信息。如下图所示，对中心像素Z5求取多个方向的灰度差分，对于Z5的8邻域，分为4个方向，即对角线和水平垂直4个方向对：(z1, z9) ，(z2, z8)， (z3, z7)， (z6, z4) 给定邻域方向梯度矢量g的幅度为：|g| = <像素灰度差分>/<相邻像素的距离>。
sobel算子原理与实践
libocao的博客
04-01 1万+
索贝尔算子（Sobeloperator）主要用于获得数字图像的一阶梯度，是一种离散性差分算子。它是prewitt算子的改进形式，改进之处在于sobel算子认为，邻域的像素对当前像素产生的影响不是等价的，所以距离不同的像素具有不同的权值，对算子结果产生的影响也不同。一般来说，距离越远，产生的影响越小。 图像处理中认为，灰度值变化剧烈的地方就是边缘。那么如何判断灰度值变化...
边缘检测算法sobel算子
08-08
Sobel算子是一种常用的边缘检测算法，它基于图像中像素灰度值的变化来检测边缘。Sobel算子分为水平和垂直两个方向，分别计算像素点的灰度值在水平和垂直方向上的梯度。 具体来说，Sobel算子使用一个3x3的模板...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值