亚像素检测算法

最新推荐文章于 2023-12-30 13:41:32 发布
最新推荐文章于 2023-12-30 13:41:32 发布
阅读量1.3k 收藏 4
点赞数
文章标签： opencv 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39011713/article/details/104609335
版权

short int iCEdgeMatch::iGetTemplateEdgeInfo1(int nIndex)
{
DV_FUNCNAME(“iCEdgeMatch::iGetTemplateEdgeInfo1”);

DvReturn nReturn = DV_StsOk;

Mat pEdgeGrdMatX;
Mat pEdgeGrdMatY;//K = dy / dx 矩阵
Mat pEdgeGrdKMat;

Mat dx;
Mat dy;
Mat dxy;
Mat pEdgeImg;

//
//
#if SECURITY_DOG
BOOL bResult = FALSE;
ELE_DEVICE_CONTEXT eleContext = {0};
unsigned long ulShareMode = 0;
unsigned long ulRet = 0;
unsigned long ulRealLen = 0;
char ModuleName[16] = {0};
unsigned long ulModuleNameLen = 16;
unsigned long ulIndex = 0;

unsigned char InputBuffer[8] = {0x80, 0x4A, 0xF1, 0xDD, 0xC7, 0xA3, 0xD2, 0xC4};
unsigned long ulInputLen = 8;
unsigned char OutputBuffer[32] = {0};
unsigned long ulOutputLen = 32;

#endif

__DV_BEGIN__;

//检验是否符合计算要求
//if ( !(m_nLayersEnableFlag[nIndex] & BZV_THREE_LAYERS)) return;

// cvNamedWindow(“edge1”);

Size size;
int nWidth, nHeight, nImgStep;
nWidth = m_pTemplateImg1[nIndex].cols;
nHeight = m_pTemplateImg1[nIndex].rows;
nImgStep = m_pTemplateImg1[nIndex].step;
unsigned char *pImgData = (unsigned char *)(m_pTemplateImg1[nIndex].data);
size.width = nWidth;
size.height = nHeight;
//计算图像的归一化梯度向量
//边缘点梯度方向数组
pEdgeGrdMatX = Mat( nHeight, nWidth, CV_32FC1 );
pEdgeGrdMatY = Mat( nHeight, nWidth, CV_32FC1 );
pEdgeGrdKMat = Mat( nHeight, nWidth, CV_32FC1 ); //K = dy / dx 矩阵

float *pEdgeGrdX = pEdgeGrdMatX.ptr<float>(0);
float *pEdgeGrdY = pEdgeGrdMatY.ptr<float>(0);
float *pEdgeGrdK = pEdgeGrdKMat.ptr<float>(0);
int nMatStep = pEdgeGrdMatX.step / sizeof(float);

for (int h = 1; h < nHeight - 1; h++) {  //逐行变化
    int s = nImgStep;//一行元素的字节数
    float *pGrdX = pEdgeGrdX + h * nMatStep;
    float *pGrdY = pEdgeGrdY + h * nMatStep;
    float *pGrdK = pEdgeGrdK + h * nMatStep;
    const unsigned char *pd = pImgData + h * nImgStep;
    for (int w = 1; w < nWidth - 1; w++) {//每行元素变化  sobel方法求的，相当于【1,0，-1,2,0，-2,1,0，-1】
        double kx = ( (pd - s)[w + 1] + pd[w + 1] + pd[w + 1] + (pd + s)[w + 1] )
                    - ( (pd - s)[w - 1] + pd[w - 1] + pd[w - 1] + (pd + s)[w - 1] );
        double ky = ( (pd + s)[w - 1] + (pd + s)[w] + (pd + s)[w] + (pd + s)[w + 1] )
                    - ( (pd - s)[w - 1] + (pd - s)[w] + (pd - s)[w] + (pd - s)[w + 1] );
        double kxy2 = sqrt(kx * kx + ky * ky) + 0.5;//防止除0
        pGrdX[w] = (float)(kx / kxy2);      //归一化梯度向量X方向
        pGrdY[w] = (float)(ky / kxy2);      //归一化梯度向量Y方向
        pGrdK[w] = (float)(ky / (kx + 0.1));    //斜率系数(+0.1防止除零)
    }
}

//Canny边缘检测
pEdgeImg = Mat(size.height, size.width, CV_8UC1);
int nLowThreshold = (int)(m_fCannyLowThd[nIndex] + 0.5);
int nHighThreshold = (int)(m_fCannyHighThd[nIndex] + 0.5);
int nThreshold = iCanny(m_pTemplateImg1[nIndex], pEdgeImg, m_fCannyThdRatio[nIndex]);
m_fAutoCannyThd[nIndex] = nThreshold;

dx  = Mat(nHeight, nWidth, CV_16SC1);
dy  = Mat(nHeight, nWidth, CV_16SC1);
dxy = Mat(nHeight, nWidth, CV_16SC1);

Sobel(m_pTemplateImg1[nIndex], dx, CV_16SC1, 1, 0, 3); //计算x方向梯度
Sobel(m_pTemplateImg1[nIndex], dy, CV_16SC1, 0, 1, 3); //计算y方向梯度

//统计像素级边缘点个数, 计算梯度值结果将结果存至dxy中
unsigned char  *pEdge = (unsigned char *)pEdgeImg.data;
unsigned char  *pMask = (unsigned char *)m_pMaskImg1[nIndex].data;
short *pdx  = (short *)dx.ptr<short>(0);
short *pdy  = (short *)dy.ptr<short>(0);
short *pdxy = (short *)dxy.ptr<short>(0);
int nWidthStep = pEdgeImg.step;
int ndxyStep = dxy.step / sizeof(short);
int nEdgePtsCounter = 0;
for (int h = 0; h < nHeight; h++) {
    const unsigned char *pData = pEdge + h * nWidthStep;
    const unsigned char *pMaskData = pMask + h * nWidthStep;
    const short *px = pdx + h * ndxyStep;
    const short *py = pdy + h * ndxyStep;
    short *pxy = pdxy + h * ndxyStep;
    for (int w = 0; w < nWidth; w++) {
        if ((pData[w] > 128) && (pMaskData[w] >= 128)) nEdgePtsCounter++;//求得mask内的边缘点数
        pxy[w] = (short)sqrt((double)(px[w] * px[w] + py[w] * py[w]));//求得x,y的梯度值
    }
}

//
//
#if SECURITY_DOG

//打开精锐E设备
ulShareMode = ELE_SHARE_MODE;
eleContext.ulSize = sizeof(ELE_DEVICE_CONTEXT);

bResult = EleOpenFirstDevice(NULL, NULL, NULL, ulShareMode, &eleContext);
if (!bResult)   __DV_EXIT__;

bResult = EleGetFirstModuleName(&eleContext, ModuleName, ulModuleNameLen, &ulRealLen, &ulIndex);
if (!bResult)   __DV_EXIT__;

bResult = EleExecute(&eleContext, ModuleName, InputBuffer, ulInputLen, OutputBuffer, ulOutputLen, &ulRealLen);
if (!bResult)   __DV_EXIT__;

if ( (OutputBuffer[0] != 'D') || (OutputBuffer[1] != 'I')) {
    __DV_EXIT__;
}

if ( OutputBuffer[2] != OutputBuffer[3]) {
    __DV_EXIT__;
}
EleClose(&eleContext);
if ( (OutputBuffer[4] != 'E') || (OutputBuffer[5] != 'R')) {
    __DV_EXIT__;
}
int n2, n3, n6, n_true;
n2 = OutputBuffer[8];
n3 = OutputBuffer[9];
n6 = OutputBuffer[10];
n_true = OutputBuffer[11];
if ( (2 != n2) || (n3 != 3) ) {
    __DV_EXIT__;
}

if (!n_true) {
    nEdgePtsCounter = 0;
}

#endif
//
//

// cout<<"Template’s pixel edge points Num[1/1] = "<<nEdgePtsCounter<<endl;

//边缘点个数为零
if (0 == nEdgePtsCounter) {
    nReturn = DV_MchTemplateIsBad;
    __DV_EXIT__;
}

ReleaseMatrix(m_pEdgePtsX1[nIndex]);
ReleaseMatrix(m_pEdgePtsY1[nIndex]);
ReleaseMatrix(m_pEdgeGrdX1[nIndex]);
ReleaseMatrix(m_pEdgeGrdY1[nIndex]);

ReleaseMatrix(m_pEdgePtsRotX1[nIndex]);
ReleaseMatrix(m_pEdgePtsRotY1[nIndex]);
ReleaseMatrix(m_pEdgeGrdRotX1[nIndex]);
ReleaseMatrix(m_pEdgeGrdRotY1[nIndex]);

ReleaseMatrix(m_pTarSubGrdX1[nIndex]);
ReleaseMatrix(m_pTarSubGrdY1[nIndex]);
ReleaseMatrix(m_pTarSubDxy1[nIndex]);
ReleaseMatrix(m_pTarSubFlag1[nIndex]);
ReleaseMatrix(m_pTarSubEdgeX1[nIndex]);
ReleaseMatrix(m_pTarSubEdgeY1[nIndex]);

int nWH = (int)(9.6 + 1.2 * sqrt((double)(nWidth * nWidth + nHeight * nHeight)));
if ( ((nWH + 1) / 2) > (nWH / 2) )  nWH += 1; //判断是否为奇数
m_pTarSubGrdX1[nIndex]  = Mat(nWH, nWH, CV_32FC1);
m_pTarSubGrdY1[nIndex]  = Mat(nWH, nWH, CV_32FC1);
m_pTarSubDxy1[nIndex]   = Mat(nWH, nWH, CV_16SC1);
m_pTarSubFlag1[nIndex]  = Mat(nWH, nWH, CV_8UC1);
m_pTarSubEdgeX1[nIndex] = Mat(nWH, nWH, CV_32FC1);
m_pTarSubEdgeY1[nIndex] = Mat(nWH, nWH, CV_32FC1);

//临时存储亚像素边缘点的坐标
m_pEdgePtsX1[nIndex]    = Mat(1, nEdgePtsCounter, CV_32FC1);
m_pEdgePtsY1[nIndex]    = Mat(1, nEdgePtsCounter, CV_32FC1);
m_pEdgePtsRotX1[nIndex] = Mat(1, nEdgePtsCounter, CV_32SC1);
m_pEdgePtsRotY1[nIndex] = Mat(1, nEdgePtsCounter, CV_32SC1);

//边缘点的归一化梯度向量
m_pEdgeGrdX1[nIndex]    = Mat(1, nEdgePtsCounter, CV_32FC1);
m_pEdgeGrdY1[nIndex]    = Mat(1, nEdgePtsCounter, CV_32FC1);
m_pEdgeGrdRotX1[nIndex] = Mat(1, nEdgePtsCounter, CV_32FC1);
m_pEdgeGrdRotY1[nIndex] = Mat(1, nEdgePtsCounter, CV_32FC1);

float *pEPtsSubX = (float *)m_pEdgePtsX1[nIndex].ptr<float>(0);
float *pEPtsSubY = (float *)m_pEdgePtsY1[nIndex].ptr<float>(0);
float *pEGrdSubX = (float *)m_pEdgeGrdX1[nIndex].ptr<float>(0);
float *pEGrdSubY = (float *)m_pEdgeGrdY1[nIndex].ptr<float>(0);

//cvShowImage(“edge1”, pEdgeImg);
//cvWaitKey(0);

double fx0, fy0; // 图像的中心坐标
fx0 = (m_nTemplateWidth[nIndex] - 1) / 2.0;    
fy0 = (m_nTemplateHeight[nIndex] - 1) / 2.0;   
nMatStep = pEdgeGrdMatX.step / sizeof(float);
nEdgePtsCounter = 0;    //清零，统计真正有效的亚像素边缘点个数
for (int h = 1; h < nHeight - 1; h++) {
    int ds = ndxyStep;
    const float *pGrdX = pEdgeGrdX + h * nMatStep;
    const float *pGrdY = pEdgeGrdY + h * nMatStep;
    const float *pGrdK = pEdgeGrdK + h * nMatStep;
    unsigned char *pData = pEdge + h * nWidthStep;
    const unsigned char *pMaskData = pMask + h * nWidthStep;
    const short *pxy = pdxy + h * ndxyStep;
    for (int w = 1; w < nWidth - 1; w++) {
        if ((pData[w] < 128) || (pMaskData[w] < 128))   continue;
        if (DV_MCH_EN_FAST_MODE == m_nIsEnableMchAcc[nIndex]) {
            for (int j = -1; j <= 1; j++) {
                for (int i = -1; i <= 1; i++) {
                    int nv = (pEdge + (h + j) * nWidthStep)[w + i];
                    if (nv > 100)   (pEdge + (h + j) * nWidthStep)[w + i] = 120;
                }
            }
        }
        pData[w] = 0;
        double k = pGrdK[w];
        double t1, t2, t3, t4, t5, t6;
        double k1, k2, k3, k4, k5;
        //计算中间参数
        t1 = (pxy - ds)[w + 1] + pxy[w + 1] + (pxy + ds)[w + 1];
        t2 = (pxy - ds)[w - 1] + pxy[w - 1] + (pxy + ds)[w - 1];
        t3 = (pxy + ds)[w - 1] + (pxy + ds)[w] + (pxy + ds)[w + 1];
        t4 = (pxy - ds)[w - 1] + (pxy - ds)[w] + (pxy - ds)[w + 1];
        t5 = (pxy - ds)[w] + pxy[w] + (pxy + ds)[w];
        t6 = (pxy - ds)[w - 1] - (pxy - ds)[w + 1] - (pxy + ds)[w - 1] + (pxy + ds)[w + 1];
        //计算拟合多项式系数
        k1 = 0.5 * (t1 + t2) - 0.3333333 * (t1 + t2 + t5);
        k2 = 0.5 * (t3 + t4) - 0.3333333 * (t1 + t2 + t5);
        k3 = 0.25 * t6;
        k4 = 0.16666667 * (t1 - t2);
        k5 = 0.16666667 * (t3 - t4);
        //计算亚像素坐标
        if ( fabs(k1 + k2 * k * k + k3 * k) < 0.0001 ) continue;

        //计算边缘点的亚像素坐标
        double fdx = -(k4 + k * k5) / (2 * (k1 + k2 * k * k + k3 * k));
        double fdy = k * fdx;
        //判断拟合的亚像素坐标的有效性
        if (( fabs(fdx) < 1.0 ) && ( fabs(fdy) < 1.0 )) {
            pEPtsSubX[nEdgePtsCounter] = (float)(fdx + w - fx0);
            pEPtsSubY[nEdgePtsCounter] = (float)(fdy + h - fy0);
            pEGrdSubX[nEdgePtsCounter] = pGrdX[w];
            pEGrdSubY[nEdgePtsCounter] = pGrdY[w];
            nEdgePtsCounter++;
        }
    }
}

for (int h = 1; h < nHeight - 1; h++) {//逐行操作, pEdgeGrdKK = dy / dx 矩阵
    int ds = ndxyStep;
    const float *pGrdX = pEdgeGrdX + h * nMatStep; 
    const float *pGrdY = pEdgeGrdY + h * nMatStep;
    const float *pGrdK = pEdgeGrdK + h * nMatStep;
    unsigned char *pData = pEdge + h * nWidthStep;
    const unsigned char *pMaskData = pMask + h * nWidthStep;
    const short *pxy = pdxy + h * ndxyStep;
    
    for (int w = 1; w < nWidth - 1; w++) { //每一行元素操作
        if ((pData[w] < 100) || (pMaskData[w] < 128))   continue;

        pData[w] = 0;//边缘灰度>=100且mask >= 128
        double k = pGrdK[w];
        double t1, t2, t3, t4, t5, t6;
        double k1, k2, k3, k4, k5;
        //计算中间参数
        t1 = (pxy - ds)[w + 1] + pxy[w + 1] + (pxy + ds)[w + 1];
        t2 = (pxy - ds)[w - 1] + pxy[w - 1] + (pxy + ds)[w - 1];
        t3 = (pxy + ds)[w - 1] + (pxy + ds)[w] + (pxy + ds)[w + 1];
        t4 = (pxy - ds)[w - 1] + (pxy - ds)[w] + (pxy - ds)[w + 1];
        t5 = (pxy - ds)[w] + pxy[w] + (pxy + ds)[w];
        t6 = (pxy - ds)[w - 1] - (pxy - ds)[w + 1] - (pxy + ds)[w - 1] + (pxy + ds)[w + 1];
        //计算拟合多项式系数
        k1 = 0.5 * (t1 + t2) - 0.3333333 * (t1 + t2 + t5);
        k2 = 0.5 * (t3 + t4) - 0.3333333 * (t1 + t2 + t5);
        k3 = 0.25 * t6;
        k4 = 0.16666667 * (t1 - t2);
        k5 = 0.16666667 * (t3 - t4);
        //计算亚像素坐标
        if ( fabs(k1 + k2 * k * k + k3 * k) < 0.0001 ) continue;

        //计算边缘点的亚像素坐标
        double fdx = -(k4 + k * k5) / (2 * (k1 + k2 * k * k + k3 * k));
        double fdy = k * fdx;
        //判断拟合的亚像素坐标的有效性
        if (( fabs(fdx) < 1.0 ) && ( fabs(fdy) < 1.0 )) {
            pEPtsSubX[nEdgePtsCounter] = (float)(fdx + w - fx0);
            pEPtsSubY[nEdgePtsCounter] = (float)(fdy + h - fy0);
            pEGrdSubX[nEdgePtsCounter] = pGrdX[w];
            pEGrdSubY[nEdgePtsCounter] = pGrdY[w];
            nEdgePtsCounter++;
        }
    }
}

double fMaxRadius = 0.0;
for (int i = 0; i < nEdgePtsCounter; i++) {
    double fdx = pEPtsSubX[i];
    double fdy = pEPtsSubY[i];
    double fDis = 1.2 * sqrt(fdx * fdx + fdy * fdy);
    if (fDis > fMaxRadius) {//求最大半径
        fMaxRadius = fDis;
    }
    (pEdge + ((int)(fdy + fy0 + 0.5)) * nWidthStep)[(int)(fdx + fx0 + 0.5)] = 64; //添加边缘
}

for (int h = 0; h < nHeight; h++) {  //删除蒙版外的点
    unsigned char *pData = pEdge + h * nWidthStep;
    const unsigned char *pMaskData = pMask + h * nWidthStep;
    for (int w = 0; w < nWidth; w++) {
        if (pMaskData[w] < 128) pData[w] = 0;
    }
}

// cout<<"Template’s sub-pixel edge points Num[1/1] = "<<nEdgePtsCounter<<endl;
// cvShowImage(“edge1”, pEdgeImg);

if (0 == nEdgePtsCounter) {
    nReturn = DV_MchTemplateIsBad;
    __DV_EXIT__;
}

m_nEdgePtsNum1[nIndex] = nEdgePtsCounter;


int nMinWH = (int)(9.1 + 2 * ceil(fMaxRadius));
//判断是否为奇数
if ( ((nMinWH + 1) / 2) > (nMinWH / 2) )    nMinWH += 1;
m_nTarSubImgWH1[nIndex] = nMinWH;

__DV_END__;

//释放临时分配的内存空间
ReleaseImage(pEdgeImg);
ReleaseMatrix(pEdgeGrdMatX);
ReleaseMatrix(pEdgeGrdMatY);
ReleaseMatrix(pEdgeGrdKMat);
ReleaseMatrix(dx);
ReleaseMatrix(dy);
ReleaseMatrix(dxy);

return nReturn;

}

wondron
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
亚像素精度圆检测算法.rar
07-16
附件为亚像素精度的圆检测方面的几篇算法论文，里面详细介绍了高精度圆检测算法原理，如果下载后不知如何实现请告知。
sigmoid函数拟合的亚像素边缘
春有百花秋有月，夏有凉风冬有雪！
12-16 5781
亚像素边缘检测技术是采用图像处理软件算法来提高检测精度的有效途径，该文章采用 Sigmoid函数拟合边缘模型。 欢迎关注微信公众号“智能算法”。
OpenCV学习笔记（二十二）之亚像素级别角点检测
开发小鸽
06-10 914
亚像素级别角点检测 提高检测精度 理论与现实的差别，实际情况下几乎所有的角点不会是一个准确的整数像素点。 亚像素定位 插值方法 基于图像矩计算 曲线拟合方法（高斯曲面，多项式，椭圆曲面） TermCriteria模板类 先介绍一下TermCriteria模板类，这个类是作为迭代算法的终止条件的。这个类的变量需要3个参数，第一个是终止条件类型，第二个参数为迭代的最大次数，最后一个是特定的阈值。 终止条件类型： cv::TerCriteria::MAX_ITER ：迭代终止条件为达到最大迭代次数终
opencv 椭圆拟合_OpenCV学习笔记（二十二）之亚像素级别角点检测
weixin_39872123的博客
12-21 405
一. 亚像素级别角点检测(一).提高检测精度 　　由于理论与现实的差别，实际情况下几乎所有的角点不会是一个准确的整数像素点。所以我们需要进行亚像素定位： 1. 插值方法 2. 基于图像矩计算 3. 曲线拟合方法（高斯曲面，多项式，椭圆曲面）二. TermCriteria模板类 　　先介绍一下TermCriteria模板类，这个类是作为迭代算法的终止条件的。这个类...
一种使用灰度值矩拟合亚像素精度圆的方法
weixin_50640987的博客
01-25 3261
图像矩 对于图像III，位置(x,y)(x,y)(x,y)处的图像灰度值表示为I(x,y)I(x,y)I(x,y)，则图像的(i,j)(i,j)(i,j)阶矩m(i,j)m_{(i,j)}m(i,j)​表示为： m(i,j)=∑x∑yxiyjI(x,y)(1) m_{(i,j)}=\sum_{x}\sum_{y}x^{i}y^{j}I(x,y)\tag{1} m(i,j)​=x∑​y∑​xiyjI(x,y)(1) 比如对于m0,0=∑x∑yI(x,y)m_{0,0}=\sum_{x}\sum_{y}I(x,
亚像素边缘检测算法
11-24
亚象素边缘提取技术， 比较实用。在分析Tabatabai提出的灰度矩亚像素边缘检测算法的基础上，指出灰度矩算法存在 边缘判断条件不够完善和未能考虑模板效应的问题，提出了改进方法，考虑Tabatabai的灰度矩算 法产生很多虚假边缘，改进算法分析了各参数对结果的影响，对边缘判断条件进行完善。实验结果 表明，所改进算法具有抗干扰性、边缘细化能力强，定位准确的特点，分辨精度可达0．06～O．08个 像素。
亚像素边缘检测评述
热门推荐
Hao_09的专栏
04-10 1万+
转载请注明出处：http://blog.csdn.net/lsh_2013 1 引言 数字图像的边缘检测是图像分割、目标识别、区域形状提取等图像处理领域的重要基础。在进行图像理解和分析时，第一步往往是边缘检测。目前边缘检测已经成为机器视觉领域最活跃的课题之一，其研究具有非常重要的理论意义和实际应用价值。传统的边缘检测方法的检测精度最高只能达到一个像素级，但是，随着科学技术的飞速发展，工业检
《A Sub-Pixel Edge Detector: an Implementation of the Canny/Devernay Algorithm》
满城风絮
12-01 1万+
论文《A Sub-Pixel Edge Detector: an Implementation of theCanny/Devernay Algorithm》提出了一种基于canny算法进行亚像素级边缘提取的算法，这里简要翻译一下：
[毕设系列--参考文献内容整理] 亚像素边缘检测器：Canny/Devernay算法的实现
努力学习
02-23 2211
该文章描述了一种产生亚像素精度链状边缘点的图像边缘检测器。该方法结合了经典的Canny和Devernay算法的主要思想。分析表明，对原始公式稍加修改可以提高边缘点的亚像素精度。本文介绍了一种亚像素精度图像边缘检测器的实现方法。该方法基于经典的Canny和Devernay算法，分析了该算法的精度，提出了改进算法以提高亚像素精度，通过各种实例，包括自然图像和合成图像，说明了该方法的方式，实验也证明了这三个参数的有效性。
数字图像处理——亚像素边缘的轮廓提取
最新发布
知来者逆的博客
12-30 2286
着对精度要求的不断提高，提高硬件分辨率是一种直接的方法，但这往往伴随着昂贵的代价。亚像素技术的应用成为解决这一问题的关键方法，因为它能够在相同或更高级别的硬件水平下实现更高的精度。该技术通过进行摄像机几何标定以及处理透视失真等步骤，弥补硬件分辨率不足的缺陷，使得在相同硬件水平下也能获得更高的测量和配准精度。
基于 Sigmoid函数拟合的亚像素边缘检测方法
12-16
亚像素边缘检测技术是采用图像处理软件算法来提高检测精度的有效途径, 文中对矩法、拟合法和插值法等常用的亚像素边缘检测算法的原理、优点和不足进行了分析 ,提出了Sigmoid函数拟合的亚像素边缘定位算法.该算法采用 Sigmoid函数拟合边缘模型,利用图像边缘灰度信息对模型进行非线性最小二乘拟合 , 求得边缘的亚像素位置 .理论分析和实验结果表明 , 基于 Sigmoid函数拟合的亚像素边缘定位算法的定位精度为 0.045像素 ,但检测的速度比灰度矩提高了一个数量级 ,比空间矩 、Zernike矩和插值法提高了两个数量级 .此算法能较好地满足影像测量的稳定可靠 、高精度及强实时性要求。
亚像素边缘检测源代码
07-29
本压缩包包括一个亚像素边缘检测源代码，以及一个测试图片，从亚像素的角度去解决边缘检测问题，并且与Canny算子做比较，效果显著！
灰度距亚像素边缘检测
06-15
基于灰度矩的亚像素边缘检测，精确度可以达到0.1-0.2个像素，内附源代码及主要参考文献，仅供学习参考！
一种快速亚像素边缘检测算法.pdf
06-08
一种快速亚像素边缘检测算法的实现的理论，可以快速实现亚像素的算法，在时间上有一定的优势，先看理论，然后自己通过理论用C++实现
亚像素级别的边缘检测和获取
03-16
利用opencv的亚像素级别的边缘检测和获取，添加了原有程序的包含文件和库，可以直接调试运行，个边参数可以根据实际情形修改
亚像素检测算法比较
01-04
比较详细的描述了几种亚像素检测算法的特点和应用场合，对图像检测和图像测量非常有用。
一种新的漫射边缘亚像素检测算法* (2010年)
05-15
分析了漫射边缘的特征及其在亚像素边缘检测中存在的主要问题，针对目前亚像素边缘检测算法不适于漫射边缘的亚像素检测的问题，提出了一种新的针对漫射边缘的亚像素边缘检测算法。该算法充分利用了漫射边缘中的有效...
halcon 亚像素定义以及测量拟合
weixin_39354845的博客
03-01 3850
一、edges_sub_pix 边缘提取算子 edges_sub_pix (ImageROI, Edges, 'lanser2', 0.3, 10, 30) 利用Deriche、Lanser、Shen和Canny滤波器提取亚像素精度边缘 提取图像精确边缘 (精确边缘就是亚像素边缘) 一阶导数 （10,30,这两个越小，边缘越多，越细腻，越大，边缘越少) Image: // 输入图像 Edges： //输出边缘轮廓 Filter： //边缘提取算法的名称 (can.
光斑质心检测之曲线拟合求亚像素位置的三种方式
Mrweng1996的博客
08-07 5984
光斑质心检测进行图像卷积之后，需对计算结果矩阵进行曲线拟合，以求出质心的亚像素坐标。 拟合的目的在于找出图像中灰度值最高的亚像素点的位置，Xmax，Ymax； 例：对图像中相邻的三点（x1 , gray1）、（x2, gray2）、（x3, gray3）进行拟合，x代表横坐标值，gray代表该位置的灰度值，gray2是检测图像的最大灰度值（也就是说质心就在（x2, gray2）这个点附近...
matlab亚像素边缘检测
03-28
Matlab中常用的亚像素边缘检测方法有以下几种： 1. Canny算子：在Matlab中可直接调用Canny函数进行边缘检测。Canny算子对于亚像素边缘的检测效果较好，但可能会出现断裂的情况。 2. Sobel算子：在Matlab中可通过调用imgradient函数得到Sobel算子的梯度图像。Sobel算子也可以检测亚像素边缘，但对于噪声较多的图像效果可能不佳。 3. Laplacian算子：在Matlab中可通过调用imfilter函数进行Laplacian算子的边缘检测。Laplacian算子可以检测亚像素边缘，但对于噪声较多的图像效果可能较差。 4. LoG算子：在Matlab中可通过调用fspecial函数生成LoG算子的卷积核，再使用imfilter函数对图像进行卷积操作。LoG算子可以有效地检测亚像素边缘，但对于大尺度图像可能会导致计算量较大。 以上几种算子都可以用于亚像素边缘检测，具体使用时需要根据图像的特点和需求选择合适的算子。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值