[OpenCV]直线拟合

最新推荐文章于 2022-06-24 08:42:31 发布
最新推荐文章于 2022-06-24 08:42:31 发布
阅读量180 收藏
点赞数
文章标签： 人工智能

 OpenCV实现了直线的拟合。

CV_IMPL void
cvFitLine( const CvArr* array, int dist, double param,
           double reps, double aeps, float *line )
{
    cv::AutoBuffer<schar> buffer;

    schar* points = 0;
    union { CvContour contour; CvSeq seq; } header;
    CvSeqBlock block;
    CvSeq* ptseq = (CvSeq*)array;
    int type;

    if( !line )
        CV_Error( CV_StsNullPtr, "NULL pointer to line parameters" );

    if( CV_IS_SEQ(ptseq) )
    {
        type = CV_SEQ_ELTYPE(ptseq);
        if( ptseq->total == 0 )
            CV_Error( CV_StsBadSize, "The sequence has no points" );
        if( (type!=CV_32FC2 && type!=CV_32FC3 && type!=CV_32SC2 && type!=CV_32SC3) ||
            CV_ELEM_SIZE(type) != ptseq->elem_size )
            CV_Error( CV_StsUnsupportedFormat,
                "Input sequence must consist of 2d points or 3d points" );
    }
    else
    {
        CvMat* mat = (CvMat*)array;
        type = CV_MAT_TYPE(mat->type);
        if( !CV_IS_MAT(mat))
            CV_Error( CV_StsBadArg, "Input array is not a sequence nor matrix" );

        if( !CV_IS_MAT_CONT(mat->type) ||
            (type!=CV_32FC2 && type!=CV_32FC3 && type!=CV_32SC2 && type!=CV_32SC3) ||
            (mat->width != 1 && mat->height != 1))
            CV_Error( CV_StsBadArg,
            "Input array must be 1d continuous array of 2d or 3d points" );

        ptseq = cvMakeSeqHeaderForArray(
            CV_SEQ_KIND_GENERIC|type, sizeof(CvContour), CV_ELEM_SIZE(type), mat->data.ptr,
            mat->width + mat->height - 1, &header.seq, &block );
    }

    if( reps < 0 || aeps < 0 )
        CV_Error( CV_StsOutOfRange, "Both reps and aeps must be non-negative" );

    if( CV_MAT_DEPTH(type) == CV_32F && ptseq->first->next == ptseq->first )
    {
        /* no need to copy data in this case */
        points = ptseq->first->data;
    }
    else
    {
        buffer.allocate(ptseq->total*CV_ELEM_SIZE(type));
        points = buffer;
        cvCvtSeqToArray( ptseq, points, CV_WHOLE_SEQ );

        if( CV_MAT_DEPTH(type) != CV_32F )
        {
            int i, total = ptseq->total*CV_MAT_CN(type);
            assert( CV_MAT_DEPTH(type) == CV_32S );

            for( i = 0; i < total; i++ )
                ((float*)points)[i] = (float)((int*)points)[i];
        }
    }

    if( dist == CV_DIST_USER )
        CV_Error( CV_StsBadArg, "User-defined distance is not allowed" );

    if( CV_MAT_CN(type) == 2 )
    {
        IPPI_CALL( icvFitLine2D( (CvPoint2D32f*)points, ptseq->total,
                                 dist, (float)param, (float)reps, (float)aeps, line ));
    }
    else
    {
        IPPI_CALL( icvFitLine3D( (CvPoint3D32f*)points, ptseq->total,
                                 dist, (float)param, (float)reps, (float)aeps, line ));
    }
}

　　

 二维的直线拟合？

/* Takes an array of 2D points, type of distance (including user-defined
distance specified by callbacks, fills the array of four floats with line
parameters A, B, C, D, where (A, B) is the normalized direction vector,
(C, D) is the point that belongs to the line. */

static CvStatus  icvFitLine2D( CvPoint2D32f * points, int count, int dist,
                               float _param, float reps, float aeps, float *line )
{
    double EPS = count*FLT_EPSILON;
    void (*calc_weights) (float *, int, float *) = 0;
    void (*calc_weights_param) (float *, int, float *, float) = 0;
    float *w;                   /* weights */
    float *r;                   /* square distances */
    int i, j, k;
    float _line[6], _lineprev[6];
    float rdelta = reps != 0 ? reps : 1.0f;
    float adelta = aeps != 0 ? aeps : 0.01f;
    double min_err = DBL_MAX, err = 0;
    CvRNG rng = cvRNG(-1);

    memset( line, 0, 4*sizeof(line[0]) );

    switch (dist)
    {
    case CV_DIST_L2:
        return icvFitLine2D_wods( points, count, 0, line );

    case CV_DIST_L1:
        calc_weights = icvWeightL1;
        break;

    case CV_DIST_L12:
        calc_weights = icvWeightL12;
        break;

    case CV_DIST_FAIR:
        calc_weights_param = icvWeightFair;
        break;

    case CV_DIST_WELSCH:
        calc_weights_param = icvWeightWelsch;
        break;

    case CV_DIST_HUBER:
        calc_weights_param = icvWeightHuber;
        break;

    /*case CV_DIST_USER:
        calc_weights = (void ( * )(float *, int, float *)) _PFP.fp;
        break;*/

    default:
        return CV_BADFACTOR_ERR;
    }

    w = (float *) cvAlloc( count * sizeof( float ));
    r = (float *) cvAlloc( count * sizeof( float ));

    for( k = 0; k < 20; k++ )
    {
        int first = 1;
        for( i = 0; i < count; i++ )
            w[i] = 0.f;

        for( i = 0; i < MIN(count,10); )
        {
            j = cvRandInt(&rng) % count;
            if( w[j] < FLT_EPSILON )
            {
                w[j] = 1.f;
                i++;
            }
        }

        icvFitLine2D_wods( points, count, w, _line );
        for( i = 0; i < 30; i++ )
        {
            double sum_w = 0;

            if( first )
            {
                first = 0;
            }
            else
            {
                double t = _line[0] * _lineprev[0] + _line[1] * _lineprev[1];
                t = MAX(t,-1.);
                t = MIN(t,1.);
                if( fabs(acos(t)) < adelta )
                {
                    float x, y, d;

                    x = (float) fabs( _line[2] - _lineprev[2] );
                    y = (float) fabs( _line[3] - _lineprev[3] );

                    d = x > y ? x : y;
                    if( d < rdelta )
                        break;
                }
            }
            /* calculate distances */
            err = icvCalcDist2D( points, count, _line, r );
            if( err < EPS )
                break;

            /* calculate weights */
            if( calc_weights )
                calc_weights( r, count, w );
            else
                calc_weights_param( r, count, w, _param );

            for( j = 0; j < count; j++ )
                sum_w += w[j];

            if( fabs(sum_w) > FLT_EPSILON )
            {
                sum_w = 1./sum_w;
                for( j = 0; j < count; j++ )
                    w[j] = (float)(w[j]*sum_w);
            }
            else
            {
                for( j = 0; j < count; j++ )
                    w[j] = 1.f;
            }

            /* save the line parameters */
            memcpy( _lineprev, _line, 4 * sizeof( float ));

            /* Run again... */
            icvFitLine2D_wods( points, count, w, _line );
        }

        if( err < min_err )
        {
            min_err = err;
            memcpy( line, _line, 4 * sizeof(line[0]));
            if( err < EPS )
                break;
        }
    }

    cvFree( &w );
    cvFree( &r );
    return CV_OK;
}

 调用的函数

 1 static CvStatus icvFitLine2D_wods( CvPoint2D32f * points, int _count, float *weights, float *line )
 2 {
 3     double x = 0, y = 0, x2 = 0, y2 = 0, xy = 0, w = 0;
 4     double dx2, dy2, dxy;
 5     int i;
 6     int count = _count;
 7     float t;
 8 
 9     /* Calculating the average of x and y... */
10 
11     if( weights == 0 )
12     {
13         for( i = 0; i < count; i += 1 )
14         {
15             x += points[i].x;
16             y += points[i].y;
17             x2 += points[i].x * points[i].x;
18             y2 += points[i].y * points[i].y;
19             xy += points[i].x * points[i].y;
20         }
21         w = (float) count;
22     }
23     else
24     {
25         for( i = 0; i < count; i += 1 )
26         {
27             x += weights[i] * points[i].x;
28             y += weights[i] * points[i].y;
29             x2 += weights[i] * points[i].x * points[i].x;
30             y2 += weights[i] * points[i].y * points[i].y;
31             xy += weights[i] * points[i].x * points[i].y;
32             w += weights[i];
33         }
34     }
35 
36     x /= w;
37     y /= w;
38     x2 /= w;
39     y2 /= w;
40     xy /= w;
41 
42     dx2 = x2 - x * x;
43     dy2 = y2 - y * y;
44     dxy = xy - x * y;
45 
46     t = (float) atan2( 2 * dxy, dx2 - dy2 ) / 2;
47     line[0] = (float) cos( t );
48     line[1] = (float) sin( t );
49 
50     line[2] = (float) x;
51     line[3] = (float) y;
52 
53     return CV_NO_ERR;
54 }
icvFitLine2D_wods

权重计算方法

 1 static void icvWeightL1( float *d, int count, float *w )
 2 {
 3     int i;
 4 
 5     for( i = 0; i < count; i++ )
 6     {
 7         double t = fabs( (double) d[i] );
 8         w[i] = (float)(1. / MAX(t, eps));
 9     }
10 }
11 
12 static void icvWeightL12( float *d, int count, float *w )
13 {
14     int i;
15 
16     for( i = 0; i < count; i++ )
17     {
18         w[i] = 1.0f / (float) sqrt( 1 + (double) (d[i] * d[i] * 0.5) );
19     }
20 }
21 
22 
23 static void icvWeightHuber( float *d, int count, float *w, float _c )
24 {
25     int i;
26     const float c = _c <= 0 ? 1.345f : _c;
27 
28     for( i = 0; i < count; i++ )
29     {
30         if( d[i] < c )
31             w[i] = 1.0f;
32         else
33             w[i] = c/d[i];
34     }
35 }
36 
37 
38 static void icvWeightFair( float *d, int count, float *w, float _c )
39 {
40     int i;
41     const float c = _c == 0 ? 1 / 1.3998f : 1 / _c;
42 
43     for( i = 0; i < count; i++ )
44     {
45         w[i] = 1 / (1 + d[i] * c);
46     }
47 }
48 
49 static void icvWeightWelsch( float *d, int count, float *w, float _c )
50 {
51     int i;
52     const float c = _c == 0 ? 1 / 2.9846f : 1 / _c;
53 
54     for( i = 0; i < count; i++ )
55     {
56         w[i] = (float) exp( -d[i] * d[i] * c * c );
57     }
58 }

 

三维的直线拟合？

/* Takes an array of 3D points, type of distance (including user-defined
distance specified by callbacks, fills the array of four floats with line
parameters A, B, C, D, E, F, where (A, B, C) is the normalized direction vector,
(D, E, F) is the point that belongs to the line. */

static CvStatus
icvFitLine3D( CvPoint3D32f * points, int count, int dist,
              float _param, float reps, float aeps, float *line )
{
    double EPS = count*FLT_EPSILON;
    void (*calc_weights) (float *, int, float *) = 0;
    void (*calc_weights_param) (float *, int, float *, float) = 0;
    float *w;                   /* weights */
    float *r;                   /* square distances */
    int i, j, k;
    float _line[6]={0,0,0,0,0,0}, _lineprev[6]={0,0,0,0,0,0};
    float rdelta = reps != 0 ? reps : 1.0f;
    float adelta = aeps != 0 ? aeps : 0.01f;
    double min_err = DBL_MAX, err = 0;
    CvRNG rng = cvRNG(-1);

    switch (dist)
    {
    case CV_DIST_L2:
        return icvFitLine3D_wods( points, count, 0, line );

    case CV_DIST_L1:
        calc_weights = icvWeightL1;
        break;

    case CV_DIST_L12:
        calc_weights = icvWeightL12;
        break;

    case CV_DIST_FAIR:
        calc_weights_param = icvWeightFair;
        break;

    case CV_DIST_WELSCH:
        calc_weights_param = icvWeightWelsch;
        break;

    case CV_DIST_HUBER:
        calc_weights_param = icvWeightHuber;
        break;

    /*case CV_DIST_USER:
        _PFP.p = param;
        calc_weights = (void ( * )(float *, int, float *)) _PFP.fp;
        break;*/

    default:
        return CV_BADFACTOR_ERR;
    }

    w = (float *) cvAlloc( count * sizeof( float ));
    r = (float *) cvAlloc( count * sizeof( float ));

    for( k = 0; k < 20; k++ )
    {
        int first = 1;
        for( i = 0; i < count; i++ )
            w[i] = 0.f;

        for( i = 0; i < MIN(count,10); )
        {
            j = cvRandInt(&rng) % count;
            if( w[j] < FLT_EPSILON )
            {
                w[j] = 1.f;
                i++;
            }
        }

        icvFitLine3D_wods( points, count, w, _line );
        for( i = 0; i < 30; i++ )
        {
            double sum_w = 0;

            if( first )
            {
                first = 0;
            }
            else
            {
                double t = _line[0] * _lineprev[0] + _line[1] * _lineprev[1] + _line[2] * _lineprev[2];
                t = MAX(t,-1.);
                t = MIN(t,1.);
                if( fabs(acos(t)) < adelta )
                {
                    float x, y, z, ax, ay, az, dx, dy, dz, d;

                    x = _line[3] - _lineprev[3];
                    y = _line[4] - _lineprev[4];
                    z = _line[5] - _lineprev[5];
                    ax = _line[0] - _lineprev[0];
                    ay = _line[1] - _lineprev[1];
                    az = _line[2] - _lineprev[2];
                    dx = (float) fabs( y * az - z * ay );
                    dy = (float) fabs( z * ax - x * az );
                    dz = (float) fabs( x * ay - y * ax );

                    d = dx > dy ? (dx > dz ? dx : dz) : (dy > dz ? dy : dz);
                    if( d < rdelta )
                        break;
                }
            }
            /* calculate distances */
            if( icvCalcDist3D( points, count, _line, r ) < FLT_EPSILON*count )
                break;

            /* calculate weights */
            if( calc_weights )
                calc_weights( r, count, w );
            else
                calc_weights_param( r, count, w, _param );

            for( j = 0; j < count; j++ )
                sum_w += w[j];

            if( fabs(sum_w) > FLT_EPSILON )
            {
                sum_w = 1./sum_w;
                for( j = 0; j < count; j++ )
                    w[j] = (float)(w[j]*sum_w);
            }
            else
            {
                for( j = 0; j < count; j++ )
                    w[j] = 1.f;
            }

            /* save the line parameters */
            memcpy( _lineprev, _line, 6 * sizeof( float ));

            /* Run again... */
            icvFitLine3D_wods( points, count, w, _line );
        }

        if( err < min_err )
        {
            min_err = err;
            memcpy( line, _line, 6 * sizeof(line[0]));
            if( err < EPS )
                break;
        }
    }

    // Return...
    cvFree( &w );
    cvFree( &r );
    return CV_OK;
}

　　

 调用的方法

  1 static CvStatus icvFitLine3D_wods( CvPoint3D32f * points, int count, float *weights, float *line )
  2 {
  3     int i;
  4     float w0 = 0;
  5     float x0 = 0, y0 = 0, z0 = 0;
  6     float x2 = 0, y2 = 0, z2 = 0, xy = 0, yz = 0, xz = 0;
  7     float dx2, dy2, dz2, dxy, dxz, dyz;
  8     float *v;
  9     float n;
 10     float det[9], evc[9], evl[3];
 11 
 12     memset( evl, 0, 3*sizeof(evl[0]));
 13     memset( evc, 0, 9*sizeof(evl[0]));
 14 
 15     if( weights )
 16     {
 17         for( i = 0; i < count; i++ )
 18         {
 19             float x = points[i].x;
 20             float y = points[i].y;
 21             float z = points[i].z;
 22             float w = weights[i];
 23 
 24 
 25             x2 += x * x * w;
 26             xy += x * y * w;
 27             xz += x * z * w;
 28             y2 += y * y * w;
 29             yz += y * z * w;
 30             z2 += z * z * w;
 31             x0 += x * w;
 32             y0 += y * w;
 33             z0 += z * w;
 34             w0 += w;
 35         }
 36     }
 37     else
 38     {
 39         for( i = 0; i < count; i++ )
 40         {
 41             float x = points[i].x;
 42             float y = points[i].y;
 43             float z = points[i].z;
 44 
 45             x2 += x * x;
 46             xy += x * y;
 47             xz += x * z;
 48             y2 += y * y;
 49             yz += y * z;
 50             z2 += z * z;
 51             x0 += x;
 52             y0 += y;
 53             z0 += z;
 54         }
 55         w0 = (float) count;
 56     }
 57 
 58     x2 /= w0;
 59     xy /= w0;
 60     xz /= w0;
 61     y2 /= w0;
 62     yz /= w0;
 63     z2 /= w0;
 64 
 65     x0 /= w0;
 66     y0 /= w0;
 67     z0 /= w0;
 68 
 69     dx2 = x2 - x0 * x0;
 70     dxy = xy - x0 * y0;
 71     dxz = xz - x0 * z0;
 72     dy2 = y2 - y0 * y0;
 73     dyz = yz - y0 * z0;
 74     dz2 = z2 - z0 * z0;
 75 
 76     det[0] = dz2 + dy2;
 77     det[1] = -dxy;
 78     det[2] = -dxz;
 79     det[3] = det[1];
 80     det[4] = dx2 + dz2;
 81     det[5] = -dyz;
 82     det[6] = det[2];
 83     det[7] = det[5];
 84     det[8] = dy2 + dx2;
 85 
 86     /* Searching for a eigenvector of det corresponding to the minimal eigenvalue */
 87 #if 1
 88     {
 89     CvMat _det = cvMat( 3, 3, CV_32F, det );
 90     CvMat _evc = cvMat( 3, 3, CV_32F, evc );
 91     CvMat _evl = cvMat( 3, 1, CV_32F, evl );
 92     cvEigenVV( &_det, &_evc, &_evl, 0 );
 93     i = evl[0] < evl[1] ? (evl[0] < evl[2] ? 0 : 2) : (evl[1] < evl[2] ? 1 : 2);
 94     }
 95 #else
 96     {
 97         CvMat _det = cvMat( 3, 3, CV_32F, det );
 98         CvMat _evc = cvMat( 3, 3, CV_32F, evc );
 99         CvMat _evl = cvMat( 1, 3, CV_32F, evl );
100 
101         cvSVD( &_det, &_evl, &_evc, 0, CV_SVD_MODIFY_A+CV_SVD_U_T );
102     }
103     i = 2;
104 #endif
105     v = &evc[i * 3];
106     n = (float) sqrt( (double)v[0] * v[0] + (double)v[1] * v[1] + (double)v[2] * v[2] );
107     n = (float)MAX(n, eps);
108     line[0] = v[0] / n;
109     line[1] = v[1] / n;
110     line[2] = v[2] / n;
111     line[3] = x0;
112     line[4] = y0;
113     line[5] = z0;
114 
115     return CV_NO_ERR;
116 }
icvFitLine3D_wods

 

参考文献：

OpenCV 学习（直线拟合)

weixin_34126215
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
opencv中的直线拟合函数 cvFitLine
12-31 3万+
opencv中 2D 或 3D 点集的直线拟合 代码参考： http://hi.baidu.com/yuzaihuan/item/283d12f260513b43922af269 自己学习~ code： #include "stdafx.h" #include "cv.h" #include "highgui.h" #include int _tmain(int argc,
我的OpenCV学习笔记（19）：检测轮廓，直线，圆以及直线拟合
java开发指南博客 【转载】
05-25 1457
检测轮廓时我们使用canny边沿检测算法，这个算法其实也是基于梯度的。但是，与传统的梯度算法求边沿不同的是： 1.它可以精确的定位边沿的位置。通过沿幅角方向检测模值的极大值点，即边缘点，遍历8个方向图像像素，把每个像素偏导值与相邻像素的模值比较，取其MAX值为边缘点，置像素灰度值为0。这样做的结果使得边沿非常细。 2.双阈值检测。通常一个较小的阈值会保留很多边沿，他们中的一部分是没有用的；而一...
Opencv—— 拟合直线
baidu_35536188的博客
02-27 1909
概念 最小二乘法多项式直线拟合，根据给定的点，求出它的函数y=f(x)，当然求得准确的函数是不太可能的，但是我们能求出它的近似曲线y=φ(x) 原理 假设有点 , I = 1,2,3,……n,求近似曲线y=φ(x)，并且使得y=φ(x)与y=f(x)的平方偏差和最小，偏差 ...
OpenCV 直线拟合及应用
zhangxu
05-07 3898
直线拟合顾名思义就是根据多个有限个数的点确定一条直线。依据为： 其中为第i个点到直线的距离，p(d)则为确定最小值的函数。而不同的p(d)对应着不同的直线拟合方法：OpenCV提供了7种（-1为用户定义）直线拟合方法，如下：CV_DIST_USER =-1, /* User defined distance */ CV_DIST_L1 =1, /* distance =
OpenCV2马拉松第25圈——直线拟合与RANSAC算法
abcd1992719g的专栏
06-02 7829
计算机视觉讨论群162501053 转载请注明：http://blog.csdn.net/abcd1992719g/article/details/27979267 收入囊中 最小二乘法(least square)拟合Total least square 拟合RANSAC拟合 葵花宝典 关于least square拟合，我在http:/
Fitting-line.rar_opencv line fitting_opencv 直线拟合_opencv 边缘拟合_ope
07-14
在给定的“Fitting-line.rar”压缩包中，主要关注的是如何使用OpenCV进行图像的直线拟合以及边缘检测。直线拟合是图像分析中的关键步骤，尤其在识别图像中的结构或特征时。最小二值化方法是实现这一目标的一种技术。...
Opencv中查找轮廓，并用直线拟合，检测每个轮廓的线性程度
08-21
代码中利用canny边缘检测绘制并取得工程目录图片下的轮廓，对每个轮廓用直线进行拟合，计算每个轮廓中点到拟合直线的距离。以此来判断一个轮廓的线性程度。包括了霍夫变换检测图像中的直线和累计概率霍夫变换检测...
OpenCV3.3最小二乘法直线拟合
04-20
本主题聚焦于OpenCV3.3中的一个特定功能：最小二乘法直线拟合。最小二乘法是一种优化技术，常用于通过数据点找到最佳的直线或曲线拟合。这种拟合方法在图像分析、数据建模和许多其他科学应用中具有重要意义。 首先...
opencv椭圆拟合长短轴比
06-01
opencv椭圆拟合长短轴比opencv椭圆拟合长短轴比opencv椭圆拟合长短轴比opencv椭圆拟合长短轴比opencv椭圆拟合长短轴比opencv椭圆拟合长短轴比opencv椭圆拟合长短轴比opencv椭圆拟合长短轴比opencv椭圆拟合长短轴比...
opencv c++ 用直线拟合一组点代码
09-22
opencv c++ 用直线拟合一组点，获取直线的位置和方向的精确估计，解决直线拟合的问题。思想：用HoughlinesP检测直线，将直线保存在lines中，获取Canny图像并获取lines与canny图相交的点集，再用点集拟合直线代码
opencv线条拟合_[OpenCV]直线拟合
weixin_31560545的博客
01-14 981
OpenCV实现了直线的拟合。CV_IMPL voidcvFitLine( const CvArr* array, int dist, double param,double reps, double aeps, float *line ){cv::AutoBuffer buffer;schar* points = 0;union { CvContour contour; CvSeq seq; }...
Opencv-python 连通域拟合直线
廷益_飞鸟的博客
05-03 1095
代码 import numpy as np import cv2 as cv # 获取连通域直线 def get_contour_line(fit_contour): fit_line = [] if np.any(fit_contour): fit_line = cv.fitLine(fit_contour, cv.DIST_L2, 0, 0.1, 0.01) return fit_line # 显示图片 def show_img(name, image).
OpenCV下的直线拟合
zhuoyue08的专栏
09-23 9834
出处： http://blog.csdn.net/Tangyongkang/   OpenCV中 CvSeq 对象由以下语句生成   //创建 CvSeq的容器对象    CvMemStorage* storage = cvCreateMemStorage(0);
opencv之fitline直线拟合
热门推荐
五仁月饼哭了的博客
05-27 1万+
fitline拟合函数： CV_EXPORTS_W void fitLine( InputArray points, //待输入点集 OutputArray line, //输出点集（一个是方向向量，另一个是拟合直线上的点） int distType,//拟合方法 double param, //以下参数使用默认值 double reps, double aeps );拟合方法总结： CV
opencv线条拟合_[转载]opencv直线拟合
weixin_34863212的博客
01-14 227
// 创建CvMemStorage对象CvMemStorage* storage =cvCreateMemStorage(0);// 创建 CvSeq对象// 第一个参数 生成后的序列的标志// 第二个参数 队列(Sequence)头的Size// 第三个参数 节点的Size// 第四个参数 存储CvSeq的容器对象CvSeq* point_seq = cvCreateSeq(CV_32...
opencv线条拟合_iOS中使用OpenCV进行线性拟合(直线and曲线)
weixin_39552317的博客
01-28 392
线性拟合的应用领域比较广泛, 如运动轨迹计算、数据分析、图像处理等领域, 故在此写一篇学习相关文章.直线拟合在说直线拟合前我们先来复习一下直线方程. 直线方程的表达式有以下几种(引用自百度):一般式:Ax+By+C=0(A、B不同时为0)【适用于所有直线】A1/A2=B1/B2≠C1/C2←→两直线平行A1/A2=B1/B2=C1/C2←→两直线重合横截距a=-C/A纵截距b=-C/B点斜式:y...
java 椭圆拟合,OpenCV2马拉松第25圈——直线拟合与RANSAC算法
weixin_28998761的博客
03-14 270
最小二乘法(least square)拟合Total least square 拟合RANSAC拟合葵花宝典watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvYWJjZDE5OTI3MTln/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">终...
opencv-python 中直线拟合函数cv.fitLine()的2D直线拟合（适合小白观看）
lustyoung的博客
12-18 8914
在提取指静脉的过程中，我们需要提取有用的ROI区域。而这时候，我们会采取将手指两边中点拟合成一条直线，求得这个直线的直线方程，然后得到旋转的角度，以便对原来的图像进行旋转操作。当我们知道如何取得手指的边缘中点后，直接用fitLine函数可以方便的按我们想要的方式得到期望 的直线。 首先是官方文档上的函数原型： 然后我会通过实例来解释每一个参数的意义，代码十分简单： import cv...
OpenCV每日函数 结构分析和形状描述符(8) fitLine函数 拟合直线
学以致用 知行合一
06-24 1276
从 2D 或 3D 点集拟合到直线。函数 fitLine 通过最小化 将线拟合到 2D 或 3D 点集，其中 是第个点之间的距离，线和 是距离函数，以下之一： 该算法基于 M-estimator技术，该技术使用加权最小二乘算法迭代拟合线。 在每次迭代之后，权重 被调整为与 成反比。...
opencv直线拟合
最新发布
08-10
OpenCV提供了直线拟合的函数fitLine，它的函数原型如下： void fitLine(InputArray points, OutputArray line, int distType, double param, double reps, double aeps)。12<em>3 #### 引用[....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值