精华内容
下载资源
问答
  • 椭圆拟合python中的点
    千次阅读
    2021-03-06 14:43:24

    实际上有一个帖子与此非常相似,但提出的问题与5年前不同。在

    我有一组不是椭圆的点,我想用最小二乘法拟合椭圆。这些是我发现的用于计算的函数。我仔细检查了一下,但没有发现任何错误。在import numpy as np

    import numpy.linalg as linalg

    import matplotlib.pyplot as plt

    def fitEllipse(x,y):

    x = x[:,np.newaxis]

    y = y[:,np.newaxis]

    D = np.hstack((x*x, x*y, y*y, x, y, np.ones_like(x)))

    S = np.dot(D.T,D)

    C = np.zeros([6,6])

    C[0,2] = C[2,0] = 2; C[1,1] = -1

    E, V = linalg.eig(np.dot(linalg.inv(S), C))

    #print E

    n = np.argmax(np.abs(E))

    a = V[:,n]

    return a

    def ellipse_center(a):

    b,c,d,f,g,a = a[1]/2, a[2], a[3]/2, a[4]/2, a[5], a[0]

    num = b*b-a*c

    x0=(c*d-b*f)/num

    y0=(a*f-b*d)/num

    return np.array([x0,y0])

    def ellipse_angle_of_rotation( a ):

    b,c,d,f,g,a = a[1]/2, a[2], a[3]/2, a[4]/2, a[5], a[0]

    return 0.5*np.arctan(2*b/(a-c))

    def ellipse_axis_length( a ):

    b,c,d,f,g,a = a[1]/2, a[2], a[3]/2, a[4]/2, a[5], a[0]

    up = 2*(a*f*f+c*d*d+g*b*b-2*b*d*f-a*c*g)

    down1=(b*b-a*c)*( (c-a)*np.sqrt(1+4*b*b/((a-c)*(a-c)))-(c+a))

    down2=(b*b-a*c)*( (a-c)*np.sqrt(1+4*b*b/((a-c)*(a-c)))-(c+a))

    res1=np.sqrt(up/down1)

    res2=np.sqrt(up/down2)

    return np.array([res1, res2])

    我的问题是:我有一组地理空间数据,我需要将这些椭圆拟合到这些数据中。为了比较不同纬度的椭圆,我需要把它们投影到局部切面上。这很简单。

    但是:对于一组这样的数据样本,函数可以工作,并给出一个形状良好的椭圆。然而,当我做投影时,它给出了一个椭圆,它的长轴比短轴短,这使得计算一个非想象的偏心率变得困难:P($e=\sqrt{1-b/a}$)。在

    即使我的投影是错误的(事实并非如此),这些函数仍然能够获取这些点并生成拟合。我不明白为什么有些数据集会产生无意义的几何数据。有什么想法吗?在

    如果没有,有没有其他方法可以让椭圆适合python中的数据?在

    更多相关内容
  • 椭圆拟合(python)

    2020-12-04 22:39:02
    A[5]=A5 return A def normal_style(paras): print('计算标准椭圆位置.....') #solve_tuoyuan.return A paras=paras/paras[5] A,B,C,D,E=paras[:5] #椭圆中心 x0=(B*E-2*C*D)/(4*A*C-B**2) y0=(B*D-2*A*E)/(4*A*C-B*...

    import pandas as pd

    import numpy as np

    import matplotlib.pylab as plt

    from sympy.solvers import solve

    from sympy import Symbol

    import os

    def solve_tuoyuan(x,y):    #a*x**2 + b*x*y + c*y**2 + d*x + e*y + f

    print('拟合......')

    x0,y0 = x.mean(),y.mean()

    D1=np.array([(x-x0)**2,(x-x0)*(y-y0),(y-y0)**2]).T

    D2=np.array([x-x0,y-y0,np.ones(y.shape)]).T

    S1=np.dot(D1.T,D1)

    S2=np.dot(D1.T,D2)

    S3=np.dot(D2.T,D2)

    T=-1*np.dot(np.linalg.inv(S3),S2.T)

    M=S1+np.dot(S2,T)

    M=np.array([M[2]/2,-M[1],M[0]/2])

    lam,eigen=np.linalg.eig(M)

    cond=4*eigen[0]*eigen[2]-eigen[1]**2

    A1=eigen[:,cond>0]

    A=np.vstack([A1,np.dot(T,A1)]).flatten()

    A3=A[3]-2*A[0]*x0-A[1]*y0

    A4=A[4]-2*A[2]*y0-A[1]*x0

    A5=A[5]+A[0]*x0**2+A[2]*y0**2+A[1]*x0*y0-A[3]*x0-A[4]*y0

    A[3]=A3;A[4]=A4;A[5]=A5

    return A

    def normal_style(paras):

    print('计算标准椭圆位置.....')

    #solve_tuoyuan.return A

    paras=paras/paras[5]

    A,B,C,D,E=paras[:5]

    #椭圆中心

    x0=(B*E-2*C*D)/(4*A*C-B**2)

    y0=(B*D-2*A*E)/(4*A*C-B**2)

    #长短轴

    a= 2*np.sqrt((2*A*(x0**2)+2*C*(y0**2)+2*B*x0*y0-2)/(A+C+np.sqrt(((A-C)**2+B**2))))

    b= 2*np.sqrt((2*A*(x0**2)+2*C*(y0**2)+2*B*x0*y0-2)/(A+C-np.sqrt(((A-C)**2+B**2))))

    #长轴倾角

    q=0.5 * np.arctan(B/(A-C))

    #normal_style

    return x0,y0,a,b,q

    def tuoyuan(y,x,p):

    #用来计算

    return p[0]*x**2+p[1]*x*y+p[2]*y**2+p[3]*x + p[4]*y + p[5]

    def cal_fit_data(p,normal):

    print('计算拟合后的数据.....')

    ##,solve_tuoyuan,P

    ##normal_style,

    x=np.linspace(normal[0]-normal[2]/2,normal[0]+normal[2]/2,100)

    rx,ry=[],[]

    y=Symbol('y')

    for i in x:

    yi=solve(tuoyuan(y,i,p),y)

    if  'I' not in str(yi[0]):

    rx.append(i)

    ry.append(yi[0])

    if 'I' not in str(yi[1]):

    rx.append(i)

    ry.append(yi[1])

    return rx,ry

    def plots(x,y,fits,pfile):

    fig=plt.figure()

    ax=fig.add_subplot(111)

    ax.plot(x,y,'b*',label='origin')

    ax.plot(fits[0],fits[1],'r.',label='fits')

    plt.show()

    fig.savefig(pfile.replace('.txt','.png'))

    展开全文
  • 基于python与scipy拟合椭圆

    千次阅读 2021-06-23 11:00:29
    椭圆有个性质:椭圆上的点到椭圆两焦点的距离为常数。 令: 1、椭圆上的点到两焦点的距离之和为 LtargetL_{target}Ltarget​ 2、两焦点坐标为(xfocus,1 ,yfocus,1),(xfocus,2 ,yfocus,2)(x_{focus,1}\,,y_{focus,1...

    1.效果

    拟合圆在这里插入图片描述
    在这里插入图片描述在这里插入图片描述

    2. 原理

    椭圆有个性质:椭圆上的点到椭圆两焦点的距离之和为常数
    令:
    1、椭圆上的点到两焦点的距离之和为 L t a r g e t L_{target} Ltarget
    2、两焦点坐标为 ( x f o c u s , 1   , y f o c u s , 1 ) , ( x f o c u s , 2   , y f o c u s , 2 ) (x_{focus,1}\,,y_{focus,1}),(x_{focus,2}\,,y_{focus,2}) (xfocus,1,yfocus,1),(xfocus,2,yfocus,2)
    3、 n n n个样本点坐标为: ( x s a m p l e s , i   , y s a m p l e s , i )    i = 1 , 2 , 3 , . . . , n (x_{samples,i}\,,y_{samples,i})\;i=1,2,3,...,n (xsamples,i,ysamples,i)i=1,2,3,...,n

    则各样本点到椭圆两焦点的距离为:
    L s a m p l e s , i = ( x s a m p l e s , i − x f o c u s , 1 ) 2 + ( y s a m p l e s , i − y f o c u s , 1 ) 2 + ( x s a m p l e s , i − x f o c u s , 2 ) 2 + ( y s a m p l e s , i − y f o c u s , 2 ) 2 L_{samples,i}= \sqrt{(x_{samples,i}-x_{focus,1})^2+(y_{samples,i}-y_{focus,1})^2} + \\\sqrt{(x_{samples,i}-x_{focus,2})^2+(y_{samples,i}-y_{focus,2})^2} Lsamples,i=(xsamples,ixfocus,1)2+(ysamples,iyfocus,1)2 +(xsamples,ixfocus,2)2+(ysamples,iyfocus,2)2
    优化目标函数定义为 L s a m p l e s L_{samples} Lsamples L t a r g e t L_{target} Ltarget的方差:
    I = ∑ i = 0 n ( L s a m p l e s , i − L t a r g e t ) 2 n − 1 I= \sqrt{\frac{\sum_{i=0}^n({L_{samples,i}-L_{target})^2}}{n-1}} I=n1i=0n(Lsamples,iLtarget)2
    最后再使用任意方法(梯度下降,牛顿下山、狗腿等)对参数进行优化即可。此处使用了scipy的现成优化函数

    scipy.optimize.minimize(fun, x0, args=())
    

    具体使用方法参考scipy的api文档

    3. 程序

    import matplotlib.pyplot as plt
    import scipy.optimize as so
    import numpy as np
    
    def my_fun(parameters, x_samples, y_samples):
        # 两焦点坐标以及椭圆上的点到两焦点的距离的和作为优化参数
        x_focus_1,y_focus_1,x_focus_2,y_focus_2,sum_of_target_distance_between_edge_and_two_focus = parameters
        # 计算实际距离
        sum_of_actual_distance_between_edge_and_two_focus= \
            ((x_samples- x_focus_1) ** 2 + (y_samples-y_focus_1) ** 2) ** 0.5+\
              ((x_samples- x_focus_2) ** 2 + (y_samples-y_focus_2) ** 2) ** 0.5
    
        # print(np.average(sum_of_actual_distance_between_edge_and_two_focus))
        # 返回方差
        return np.sum(((sum_of_actual_distance_between_edge_and_two_focus
                        - sum_of_target_distance_between_edge_and_two_focus) ** 2)/(len(x_samples)-1))
    
    def fit_ellipse(x_samples, y_samples):
        # 归一化
        vmax= max(np.max(x_samples), np.max(y_samples))
        x_samples= x_samples / vmax
        y_samples= y_samples / vmax
        # 优化
        res_optimized = so.minimize(fun=my_fun, x0=np.array([-0.1,-0.05,0.1,0.1, 1.2]), args=(x_samples, y_samples))
        if res_optimized.success:
            print(res_optimized)
            x1_res, y1_res, x2_res, y2_res, l2_res = res_optimized.x
            # 依据优化得到的函数生成椭圆曲线
            # 计算椭圆偏角
            alpha_res= np.arctan((y2_res- y1_res)/(x2_res-x1_res))
            # 计算两焦点之间的距离
            l_ab= ((y2_res- y1_res)**2+ (x2_res-x1_res)**2)**0.5
            # 计算长(短)轴长度
            a_res= l2_res/2
            # 计算短(长)轴长度
            b_res=  ((l2_res/2)**2- (l_ab/2)**2)**0.5
    
            # 极坐标轴序列
            theta_res = np.linspace(0.0, 6.28, 100)
            # 生成椭圆上的点
            x_res = a_res * np.cos(theta_res) * np.cos(alpha_res) \
                    - b_res * np.sin(theta_res) * np.sin(alpha_res)
            y_res = b_res * np.sin(theta_res) * np.cos(alpha_res) \
                    + a_res * np.cos(theta_res) * np.sin(alpha_res)
    
            # plt.style.use("one")
            plt.axes([0.16, 0.15, 0.75, 0.75])
            plt.scatter(x_samples, y_samples, color="magenta", marker="+",
                        zorder=1, s=80, label="samples")
            plt.plot(x_res, y_res, color="deepskyblue", zorder=2,
                     label="fitted curve")
            plt.scatter(np.array([x1_res,x2_res]), np.array([y1_res,y2_res]),zorder=3,
                        color="r", label= "focus point")
            plt.xlabel("$x$")
            plt.ylabel("$y$")
            plt.legend()
            vmax = max(np.max(plt.xlim()), np.max(plt.ylim()))
            vmin = min(np.min(plt.xlim()), np.min(plt.ylim()))
            plt.ylim([1.1 * vmin - 0.1 * vmax, 1.1 * vmax - 0.1 * vmin])
            plt.xlim([1.25 * vmin - 0.25 * vmax, 1.25 * vmax - 0.25 * vmin])
            # plt.savefig("Figsave/a={:.3f};b={:.3f};theta={:.2f}deg.svg".format(a_res, b_res, alpha_res))
            plt.show()
    
    
    if __name__== "__main__":
        theta_samples = np.linspace(0, 20, 100)
        # 椭圆方位角
        alpha_samples = -45.0 / 180.0 * np.pi
        # 长轴长度
        a_samples = 1.0
        # 短轴长度
        b_samples = 2.0
        # 样本x 序列,并叠加正态分布的随机值
        x_samples = a_samples * np.cos(theta_samples) * np.cos(alpha_samples) \
                    - b_samples * np.sin(theta_samples) * np.sin(alpha_samples) \
                    + np.random.randn(100) * 0.05 * a_samples
        # 样本y 序列 ,并叠加正态分布的随机值
        y_samples = b_samples * np.sin(theta_samples) * np.cos(alpha_samples) \
                    + a_samples * np.cos(theta_samples) * np.sin(alpha_samples) \
                    + np.random.randn(100) * 0.05 * b_samples
        fit_ellipse(x_samples, y_samples)
    

    ps:真不错,markerdown编辑器真不错

    展开全文
  • retval = cv.fitEllipse(contours[1]) # 取其中一个轮廓拟合椭圆 img = cv.ellipse(im, retval, (0, 0, 255), thickness=2) # 在原图画椭圆 cv.imshow("mark_ellipse[1]", img) print(retval) # 这里可以查看下...

    直接放图放程序

    import cv2 as cv
    
    if __name__ == "__main__":
    
        im = cv.imread("image/circle_patten.jpg")    # 读图
        imgray = cv.cvtColor(im, cv.COLOR_BGR2GRAY)    # 转灰度图
        _, thresh = cv.threshold(imgray, 130, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)  # 二值化 
        image, contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)  # 轮廓查找
    
    
        retval = cv.fitEllipse(contours[1])  # 取其中一个轮廓拟合椭圆
        img = cv.ellipse(im, retval, (0, 0, 255), thickness=2) # 在原图画椭圆
        cv.imshow("mark_ellipse[1]", img)
        print(retval) # 这里可以查看下fitEllipse的返回值的结构
        cv.waitKey()

     fitEllipse

    ellipse

    注意到这里的形参box即是 fitEllipse的返回值

    其类型为RotatedRect

     

    RotatedRect

    在上面的程序中,print(retval)得到的值为:

    ((579.71240234375, 449.0208740234375), (49.17593765258789, 49.56596755981445), 96.06968688964844) 

    对应下图可知retval[0]为椭圆中心坐标,retval[1]是外接椭圆的矩形的高和宽,retval[2]为旋转角

    展开全文
  • 我正在使用matplotlib的补丁绘制椭圆,这确实很美,但绝对是代表圆锥曲线的更好解决方案。 重要的是,我将dogbox方法用于curve_fit,因为其他方法无法收敛。 有时椭圆形不匹配并且降低了添加的噪声(例如, rng....
  • )使用OpenCV的fitEllipse函数拟合椭圆后,会得到一个RotatedRect类型的返还值,首先介绍一下RotatedRect结构,这个参考的无左无右的博客:点击打开链接,嫌左右跳麻烦,所以直接贴过来classCV...
  • python-opencv椭圆拟合并求交点

    千次阅读 2022-04-06 20:19:11
    python-opencv进行椭圆拟合,然后求直线与曲线的交点
  • opencv椭圆拟合

    万次阅读 2018-04-08 17:35:18
    目标:通过椭圆拟合求出目标长短轴 思路:先用canny计算出待拟合椭圆的边界坐标,opencv中fitEllipse函数可通过最小二乘法来拟合一个椭圆使得点尽量在椭圆上。 如上图,右边是拖过canny计算出边界点信息,左图是...
  • 9.5.2椭圆模型拟合及案例 多元数据集存在偏离正常范围的“离群点”。一般在预处理数据环节,需检测出离群点,再进行处理。 离群点产生的原因可能是由数据中存在某些点来自于与总体分布不同的其它分布。具体而言,...
  • 函数cv2.boundingRect返回四个参数(x,y)为矩形左上角的坐标,(w,h)是矩形的宽和高。 函数cv2.rectangle是绘制矩形函数 函数cv2.minAreaRect返回的是一个 Box2D 结构,其中包含 矩形左上角角点的坐标(x,y...
  • 关于最小二乘法椭圆拟合的改进算法,属于计算机图形学范畴,可用于2D/3D椭圆绘制算法
  • 我发现了一些其他的问题(1,2)关于椭圆与一组数据点的拟合,它们都使用来自here的同一段代码。在进行装配时:def fitEllipse(x,y):x = x[:,np.newaxis]y = y[:,np.newaxis]D = np.hstack((x*x, x*y, y*y, x, y, np....
  • 用于拟合空间圆的代码 .py文件是python代码 拟合方式是一个一个的添加点进行拟合 .m是matlab代码 拟合方式是一下子赋予很多个点 然后一起出拟合的结果
  • 贝塞尔曲线拟合多边形,本来以为是很标准的算法,必然有Python的现成库存在,但搜了几天下来,竟然没有一个。 csdn上有一个版本,是基于某篇文章修改的python版本,但算法有错。 该文章的地址在此:...
  • 经常用到轮廓查找和多边形拟合等opencv操作,因此记录以备后续使用。本文代码中的阈值条件对图片没有实际意义,仅仅是为了测试。 原图为: 2、测试代码: import cv2 import numpy as np img = cv2.imread('/home...
  • Pythonpython曲线拟合

    万次阅读 2020-03-25 13:57:00
    python作为一款可以简单方便地进行科学计算的语言,进行曲线拟合自然是必备的功能之一了。本文就如何进行曲线拟合进行讲解。 本文需要进行拟合的数据为: x = np.arange(1, 31, 1) y = np.array([20, 23, 26, 29, 32...
  • 椭圆拟合-EllipseDirectFit.m 这是一个快速和非迭代椭圆拟合算法 . 用法:  A = EllipseDirectFit 输入: XY 数组是n个点的坐标  x=XY, y=XY 输出: A = [a b c d e f]' 时椭圆拟合的系数向量其方程方程为:...
  • 利用最小二乘法进行求解,首先引入拉格朗日乘子算法获得等式组,然后求解等式组得到最优的拟合椭圆。算法的优点:a、椭圆的特异性,在任何噪声或者遮挡的情况下都会给出一个有用的结果;b、不变性,对数据的...
  • Ransac拟合椭圆

    千次阅读 2021-05-09 11:13:34
    一、Ransac算法介绍 RANSAC(RAndom SAmple Consensus,随机采样一致)最早是由Fischler和Bolles在SRI上...除去“外点”后剩下的数据点则为“内点”,即符合拟合模型的数据点。RANSAC算法的主要处理思想就是通过不断的迭代
  • 主要介绍了Python实现霍夫圆和椭圆变换代码详解,具有一定借鉴价值,需要的朋友可以参考下
  • 主要的就是首先要安装Anaconda python库,然后来运用这些数学工具。 ###最小二乘法试验### import numpy as np import pymysql from scipy.optimize import leastsq from scipy import integrate ###绘图,看拟合...
  • 基于最小二乘法的椭圆拟合程序

    热门讨论 2012-08-19 12:09:39
    基于最小二乘法的椭圆拟合程序,参考文献:基于椭圆拟合的人工标志中心定位方法
  • 版本这么高,没想到做个椭圆拟合与绘制还有问题。 opencv的椭圆拟合函数有三个: cv2.fitEllipse() cv2.fitEllipseAMS() cv2.fitEllipseDirect() 函数细节见官方文档 椭圆绘制函数:cv2.ellipse() 详见参考...
  • 以下所有的点都围绕着圆的圆周噪声数据点:如何使用python中的最小二乘拟合找到圆的中心?data = [(2.2176383052987667, 4.218574252410221),(3.3041214516913033, 5.223500807396272),(4.280815855023374, 6....
  • python实现的贝塞尔曲线拟合,有测试数据
  • radius = int(radius) cv2.circle(img,center,radius,(0,255,0),2) 9 拟合椭圆 ellipse = cv2.fitEllipse(cnt) cv2.ellipse(img,ellipse,(0,255,0),2) 10 拟合直线 rows,cols = img.shape[:2] [vx,vy,x,y] = cv2....
  • dlib库的安装以及人脸特征点的识别分布分别在前两篇博文里面Dlib Python 检测人脸特征点 Face Landmark DetectionMac OSX下安装dlib (Python)这篇主要涉及 cv2.ellipse 和 cv2.fitEllipse 的用法import cv2import ...
  • python 拟合曲线并求参

    2020-11-23 19:37:01
    python的scipy.optimize包里的curve_fit函数来拟合曲线,当然还可以拟合很多类型的曲线。scipy.optimize提供了函数最小值(标量或多维)、曲线拟合和寻找等式的根的有用算法。import numpy as npimport matplotlib...
  • 主要介绍了Python图像处理之直线和曲线的拟合与绘制,结合实例形式分析了Python曲线拟合相关函数curve_fit()的使用技巧,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,658
精华内容 663
关键字:

python椭圆拟合

友情链接: plottxt.zip