[边缘检测算法] 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算子原理与实现
五仁月饼哭了的博客
07-15 15万+
一、原理： 首先介绍背景知识：    1)边缘：灰度或结构等信息的突变处，边缘是一个区域的结束，也是另一个区域的开始，利用该特征可以分割图像。    2)边缘点：图像中具有坐标[x，y]，且处在强度显著变化的位置上的点。    3)边缘段：对应于边缘点坐标[x，y]及其方位 ，边缘的方位可能是梯度角。        索贝尔算子（Sobeloperator）主要用作边缘
一种基于Sobel算子梯度增强的边缘检测算法
01-29
针对传统Sobel算子在图像边缘检测中存在的弱边缘提取较差及边缘较粗等不足，提出了一种局部梯度增强的检测算法。算法采用改进的Sobel算子卷积模板计算图像梯度；然后对梯度图像采用局部标准差方法增强局部弱边缘的...
灵活运用SIMD指令16倍提升Sobel边缘检测的速度（4000*3000的24位图像时间由480ms降低到30ms）
weixin_39450742的博客
07-11 470
本篇博文来自博主Imageshop，打赏或想要查阅更多内容可以移步至Imageshop。 转载自：https://www.cnblogs.com/Imageshop/p/7285564.html 侵删 　　这半年多时间，基本都在折腾一些基本的优化，有很多都是十几年前的技术了，从随大流的角度来考虑，研究这些东西在很多人看来是浪费时间了，即不能赚钱，也对工作能力提升无啥帮助。可我觉得人类所谓的幸福，可以分为物质档次的享受，还有更为复杂的精神上的富有，哪怕这种富有只是存在于短暂的自我满足中也是值得的。..
SSE图像算法优化系列九：灵活运用SIMD指令16倍提升Sobel边缘检测的速度（4000*3000的24位图像时间由480ms降低到30ms）。...
weixin_33881041的博客
08-04 300
　　这半年多时间，基本都在折腾一些基本的优化，有很多都是十几年前的技术了，从随大流的角度来考虑，研究这些东西在很多人看来是浪费时间了，即不能赚钱，也对工作能力提升无啥帮助。可我觉得人类所谓的幸福，可以分为物质档次的享受，还有更为复杂的精神上的富有，哪怕这种富有只是存在于短暂的自我满足中也是值得的。       闲话少说， SIMD指令集，这个古老的东西，从第一代开始算起，也快有近20年的历史了，...
Sobel边缘检测
最新发布
shenqijiji的博客
06-15 868
声明：学习过程中的知识总结，欢迎批评指正。
ZYNQ图像处理(7)——sobel边缘检测
qq_40995480的博客
09-13 7398
sobel边缘检测
sobel边缘检测
mxh3600的博客
02-21 3525
sobel边缘检测
Sobel算子
热门推荐
苦逼的程序猿
05-30 2万+
原理 Soble边缘检测算法比较简，实际应用中效率比canny边缘检测效率要高，但是边缘不如Canny检测的准确，但是很多实际应用的场合，sobel边缘却是首选，尤其是对效率要求较高，而对细纹理不太关心的时候。Soble边缘检测通常带有方向性，可以只检测竖直边缘或垂直边缘或都检测。 算子使用两个3*3的矩阵（图1）算子使用两个3*3的矩阵（图1）去和原始图片作...
sobel 算子
weixin_52130455的博客
04-25 670
sobel算子应用时进行给定图像的卷积操作，卷积为计算图像大矩阵周围像素和滤波器矩阵对应位置元素的乘积, 然后把结果相加到一起, 最终得到的值就作为该像素的新值, 这样就完成了一次。卷积，之后继续移动卷积核，直到把大矩阵每个位置都运算完毕，因为相邻像素卷积结果一般具有相似输出，会产生大量冗余信息，一般为减少输出值会进行求取最大小值或者平均值的池化操作。值得注意的是，一般卷积操作会伴随卷积核的翻转，而sobel却不需要翻转，因为绕中心点旋转180°，并不影响结果。A为原始图像，Gx，Gy分别代表水平和垂直。
sobel函数边缘检测_边缘检测_边缘检测；sobel算子_
09-28
sobel算子_”中，关键词“sobel函数”和“sobel算子”表明我们将探讨的是基于Sobel算子的边缘检测方法。 Sobel算子是一种在一维空间中定义的微分算子，被广泛应用于二维图像的梯度计算。它通过计算图像在水平和垂直...
Sobel_sobel算子边缘检测_sobel算子_边缘检测_sobel边缘检测_tipa79_
10-03
本文将深入探讨“Sobel算子”这一经典的边缘检测方法，以及如何利用该算子来实现对图像的边缘检测。 Sobel算子是一种基于微分运算的局部差分算子，用于估计图像的梯度强度和方向。它结合了水平和垂直方向的一阶导数...
Sobel图像边沿检测算法的优化设计与实现
10-16
针对Sobel算子用于图像边沿检测时出现的噪声大、边沿较粗等问题，提出了一种Sobel图像边沿检测的优化设计方案。在传统的Sobel边沿检测模块前增加快速中值滤波模块，提高了系统的抗噪能力。同时在Sobel边沿检测模块后采用非极大值抑制的方式对图像边沿进一步细化，既有效地保留了图像边沿，又提高了图像边沿的清晰度。与传统Sobel检测模块相比，优化后的方案不仅能够有效抑制噪声，而且得到的图像边沿更细，增强了实时图像处理的效果。该优化设计已成功应用于某图像识别系统。
sobel算子实现度图像的边缘提取，x和y方向叠加
07-17
sobel算子实现度图像的边缘提取，x和y方向叠加
八方向sobel算子matlab代码
11-10
一种改进的八方向的sobel算子，matlab源代码
改进的Sobel算子彩色图像边缘检测
10-17
为了解决传统灰度图像边缘检测中容易出现的边缘定位偏差、边缘丢失以及边缘不连续等问题，结合传统的Sobel梯度边缘检测方法和图像阈值分割技术，提出了一种改进的Sobel算子彩色图像边缘检测方法。通过对比试验结果表明，该方法可以有效地降低色彩边缘的误检率，一定程度上提高了边缘检测器的性能。
matlab图像边缘检测sobel算子梯度图像
05-09
本主题聚焦于使用MATLAB实现图像边缘检测，特别是通过Sobel算子来计算图像的梯度，进而找到图像的边界。Sobel算子是一种广泛应用的微分算子，用于估算图像的梯度强度和方向，从而有效地检测图像边缘。 首先，我们要...
sobel算子边缘检测_sobel_sobel算子_opencv4_边缘_drovecai_
10-02
Sobel算子是一种广泛应用的边缘检测算法，它结合了梯度强度和方向信息来确定图像的边缘。在这个项目中，我们将深入探讨Sobel算子的原理、OpenCV库的使用，以及如何在Visual Studio环境下利用OpenCV4.2实现Sobel算子...
（7-2）图像增强：锐化
码农三叔
03-08 2673
锐化滤波器（Sharpening filter）是一种常用的图像处理技术，用于增强图像的边缘和细节，以提高图像的清晰度和视觉效果。但是，如果原始图像的像素值范围本身已经是0到255之间，那么进行归一化可能会导致所有的像素值都变为0，从而得到一片黑色的图像。最后，将锐化后的图像像素值归一化到0到255范围内，并显示原始图像和锐化后的图像。实现了理想高通滤波器。基于梯度的锐化是一种图像增强技术，通过突出图像中的边缘和细节来增强图像的清晰度和锐度。该方法基于图像的梯度信息，利用梯度的变化来增强图像的边缘。
matlab图像边缘检测——sobel算子
anxinbuxinan的博客
09-11 5308
Sobel算子是一种常用的边缘检测算子，它可以通过计算像素点的梯度来检测图像中的边缘。该算子基于图像上某一点周围的像素值变化情况，通过卷积运算来计算水平方向和垂直方向上的梯度。Sobel算子使用两个3x3的模板进行卷积操作，分别对应水平方向和垂直方向的梯度计算。这两个模板分别称为Gx和Gy。通过将这两个模板与图像进行卷积操作，可以得到每个像素点在水平方向和垂直方向上的梯度值。然后，通过对这些梯度值取绝对值并取整数部分，可以得到每个像素点的梯度强度。
边缘检测算法sobel算子
08-08
Sobel算子是一种常用的边缘检测算法，它基于图像中像素灰度值的变化来检测边缘。Sobel算子分为水平和垂直两个方向，分别计算像素点的灰度值在水平和垂直方向上的梯度。 具体来说，Sobel算子使用一个3x3的模板...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值