精华内容
下载资源
问答
  • 三次B样条曲线拟合算法

    万次阅读 多人点赞 2017-01-17 22:10:28
    三次B样条曲线方程B样条曲线分为近似拟合和插值拟合,所谓近似拟合就是不过特征点,而插值拟合就是通过特征点,但是插值拟合需要经过反算得到控制点再拟合出过特征点的B样条曲线方程。这里会一次介绍两种拟合算法。...

    1 三次B样条曲线方程

    B样条曲线分为近似拟合和插值拟合,所谓近似拟合就是不过特征点,而插值拟合就是通过特征点,但是插值拟合需要经过反算得到控制点再拟合出过特征点的B样条曲线方程。这里会一次介绍两种拟合算法。首先介绍B样条的曲线方程。
    B样条曲线的总方程为:P(t)=∑i=0nPiFi,k(t)P(t)=\sum_{i=0}^{n} P_{i}F_{i,k}(t)P(t)=i=0nPiFi,k(t) (1)
    其中PiP_iPi是控制曲线的特征点,Fi,k(u)F_{i,k}(u)Fi,k(u)则是K阶B样条基函数。
    1.1 三次B样条曲线方程中基函数为:
    Fi,k(t)=1k!∑m=0k−i(−1)m(mk+1)(t+k−m−j)kF_{i,k}(t)=\frac{1}{k!}\sum_{m=0}^{k-i}(-1)^{m}\binom{m}{k+1}(t+k-m-j)^kFi,k(t)=k!1m=0ki(1)m(k+1m)(t+kmj)k (2)
    其中(mk+1)\binom{m}{k+1}(k+1m)表示阶乘,化成看的明白的式子就是:

    这里写图片描述
    将图片上的基函数代入到方程(1)中,就是:
    P(t)=P0∗F0,3(t)+P1∗F1,3(t)+P2∗F2,3(t)+P3∗F3,3(t)P(t)= P_0*F_{0,3}(t)+P_1*F_{1,3}(t)+P_2*F_{2,3}(t)+P_3*F_{3,3}(t)P(t)=P0F0,3(t)+P1F1,3(t)+P2F2,3(t)+P3F3,3(t) (3)
    方程(3)就是三次B样条曲线方程。


    2019-04-18 更新

    有小伙伴提到上式(2)的j是什么意思,其实j就是控制点的索引值。这里我把书上的公式摘抄下来,可能看起来更为清晰。
    参考书籍:《计算机图形学 第3版》何援军 第13章
    三次B样条曲线计算
    F0,3(t)=13!∑j=03(−1)jC4j)(t+3−0−j)3F_{0,3}(t)=\frac{1}{3!}\sum_{j=0}^{3}(-1)^{j}C^{j}_{4})(t+3-0-j)^3F0,3(t)=3!1j=03(1)jC4j)(t+30j)3

    =16[(−1)0C40(t+3)3+(−1)1C41(t+2)3+(−1)2C42(t+1)3+(−1)3C43t3]=\frac{1}{6}[(-1)^{0}C^{0}_{4}(t+3)^{3}+(-1)^{1}C^{1}_{4}(t+2)^{3}+(-1)^{2} C^{2}_{4}(t+1)^{3}+(-1)^{3}C^{3}_{4}t^{3}]=61[(1)0C40(t+3)3+(1)1C41(t+2)3+(1)2C42(t+1)3+(1)3C43t3]

    =16(−t3+3t2−3t+1)=16(1−t)3=\frac{1}{6}(-t^{3}+3t^{2}-3t+1)=\frac{1}{6}(1-t)^{3}=61(t3+3t23t+1)=61(1t)3

    F1,3(t)=13!∑j=02(−1)jC4j)(t+3−1−j)3F_{1,3}(t)=\frac{1}{3!}\sum_{j=0}^{2}(-1)^{j}C^{j}_{4})(t+3-1-j)^3F1,3(t)=3!1j=02(1)jC4j)(t+31j)3

    =16[(−1)0C40(t+2)3+(−1)1C41(t+1)3+(−1)2C42t3]=\frac{1}{6}[(-1)^{0}C^{0}_{4}(t+2)^{3}+(-1)^{1}C^{1}_{4}(t+1)^{3}+(-1)^{2} C^{2}_{4}t^{3}]=61[(1)0C40(t+2)3+(1)1C41(t+1)3+(1)2C42t3]

    =16(3t3−6t2+4)=\frac{1}{6}(3t^{3}-6t^{2}+4)=61(3t36t2+4)

    F2,3(t)=13!∑j=01(−1)jC4j)(t+3−2−j)3F_{2,3}(t)=\frac{1}{3!}\sum_{j=0}^{1}(-1)^{j}C^{j}_{4})(t+3-2-j)^3F2,3(t)=3!1j=01(1)jC4j)(t+32j)3

    =16[(−1)0C40(t+1)3+(−1)1C41t3=\frac{1}{6}[(-1)^{0}C^{0}_{4}(t+1)^{3}+(-1)^{1}C^{1}_{4}t^{3}=61[(1)0C40(t+1)3+(1)1C41t3

    =16(−3t3+3t2+3t+1)=\frac{1}{6}(-3t^{3}+3t^{2}+3t+1)=61(3t3+3t2+3t+1)

    F3,3(t)=13!∑j=00(−1)jC4j)(t+3−3−j)3F_{3,3}(t)=\frac{1}{3!}\sum_{j=0}^{0}(-1)^{j}C^{j}_{4})(t+3-3-j)^3F3,3(t)=3!1j=00(1)jC4j)(t+33j)3

    =16[(−1)0C40t3=\frac{1}{6}[(-1)^{0}C^{0}_{4}t^{3}=61[(1)0C40t3

    =16t3=\frac{1}{6}t^{3}=61t3


    2 三次B样条曲线近似拟合

    近似拟合很简单。不需要求控制点,求得Fi,k(t)F_{i,k}(t)Fi,k(t),由上述方程(3),代入P0,P1,P2,P3P_0,P_1,P_2,P_3P0,P1,P2,P3就可以得到由这四个点近似拟合的一段三次B样条曲线,起始点在P0P_0P0,终点在P1P_1P1,对于闭合轮廓,最后一段可以取前两点做辅助,拟合实验结果我最后一块给出。这种近似拟合曲线光滑,但是最大不足就是不过特征点,也就是不过PiP_iPi,需要过点需要反求控制点再拟合。

    3 三次B样条插值拟合

    插值拟合较为复杂。其实也不算是很复杂,找资料过程和理解过程是一个复杂的过程。不过有了前面大神做工作,我们只是借用别人的成果写代码就好了。我给大家看一篇论文,大家可以百度或者去知网搜索,闭合 B 样条曲线控制点的快速求解算法及应用。文章讲解了反求控制点的具体步骤,写的非常详细,基本上贴近代码的那种。大家可以根据这篇论文反求控制点,拟合出来的三次B样条曲线是经过PiP_iPi的。代码就不放了,很多,可以根据我给的那篇论文直接编写相应代码,有问题可以私信我,知无不言。
    ##4 拟合结果
    这里写图片描述 原轮廓
    这里写图片描述 近似拟合轮廓。可以看到没过黑色特征点,只是近似拟合
    这里写图片描述 插值拟。可以看到曲线经过黑色特征点,不过有一些不足之处。

    ##5 总结
    三次B样条曲线拟合轮廓效果还是可以,较之Beizer(可以参考我博客三次Beizer曲线拟合算法),B样条将一些细节描述的很好,很多细节之处都贴近原轮廓,但是有一些不足之处,可以看到对直线拟合效果不是很好。两篇博客都是关于闭合轮廓的拟合,对于非闭合或者只是一段曲线拟合,还有一种曲线是很好的,《数值分析》提到过,叫三次样条插值拟合,拟合效果很好,我做过拟合一元三次方程曲线,拟合效果跟原曲线非常贴近,不过过程中需要用到追赶法,而追赶法需要满足一个条件,对于闭合曲线三次样条插值是不满足这个条件的,所以我没去深研究,大家可以去试一试。谢谢大家!

    -------------------------------------------------2018-10-30--------------------------------------------
    真的很感谢大家的支持,这一年都比较忙,找实习and找工作,而且这个东西是研一上学期搞的,现在看都毫无印象,对自己说一句:牛逼。我把代码放在网盘了(能运行,但现在没效果,大家可以检查下,之前是OK的),本来想上传到CSDN,好像要C币,而且要审核,太墨迹了。
    链接: https://pan.baidu.com/s/1mSQMmvL71gwEAqgiT6O9Gg 提取码: xv5f

    展开全文
  • 摘要 摘要 合技术己 地 工程 验 曲线拟 被广泛 应用于 图像处理 实 等领域 ...并在 基础 基 德森加 方法 此 于安 一 出 了 种快速的 样条拟合算法 样条曲线拟合曲线拟合中最常 性 性 见的方法 它具有局部 好 连续 好
  • % ref: 闭合 B 样条曲线控制点的快速求解算法及应用 % http://www.doc88.com/p-5714423317458.html % https://blog.csdn.net/liumangmao1314/article/details/54588155 ========================...

    在做相关项目需要解决B样条插值问题,记录如下

    感谢以下参考资料的帮助

    % ref: 闭合 B 样条曲线控制点的快速求解算法及应用
    % http://www.doc88.com/p-5714423317458.html
    % https://blog.csdn.net/liumangmao1314/article/details/54588155

    =============================

    %计算B样条曲线控制点

    function px = LU_B1(CPnum, V)   
        a = 1;
        b = 4;
        c = 1;
        d = 1;
        e = 1;
        
        f = zeros(CPnum-1,1);
        g = zeros(CPnum-2,1);
        h = zeros(CPnum,1);
        k = zeros(CPnum-1,1);

        % get h[] & f[]
        h(1) = b;
        for i=1:CPnum-2
            f(i) = a/h(i);
            h(i+1) = b - f(i)*c;
        end

        % get g[] & f[n-1]
        g(1) = d/h(1);
        for i=1:CPnum-3
            g(i+1) = -g(i)*c/h(i+1);
        end
        f(CPnum-1) = ( a-g(CPnum-2)*c )/h(CPnum-1);

        % get k[] & h[n]
        k(1) = e;
        for i=1:CPnum-3
            k(i+1) = -f(i)*k(i);
        end
        k(CPnum-1) = c - f(CPnum-2)*k(CPnum-2);

        gksum = 0;
        for i=1:CPnum-2
            gksum = gksum + g(i)*k(i);
        end
        h(CPnum) = b - gksum - f(CPnum-1)*c;

        % 矩阵求解过程,追的过程
        x = zeros(CPnum,1);   
        x(1) = 6*V(end);
        
        for i=1:CPnum-2      
            x(i+1) = 6*V(i) - f(i)*x(i);       
        end

        gxsum = 0;    

        for i=1:CPnum-2
            gxsum = gxsum + g(i)*x(i);        
        end
        
        x(CPnum) = 6*V(CPnum-1) - gxsum - f(CPnum-1)*x(CPnum-1);    
        
        % 赶的过程
        px = zeros(CPnum+2,1);    
        
        px(CPnum) = x(CPnum)/h(CPnum);
        px(CPnum-1) = ( x(CPnum-1)-k(CPnum-1)*px(CPnum) )/h(CPnum-1);
        
        for i=CPnum-2:-1:1
            px(i) = ( x(i)-c*px(i+1)-k(i)*px(CPnum) )/h(i);
        end
        px(CPnum+1) = px(1);
        px(CPnum+2) = px(2);    
    end


    % 插值计算三次周期性b样条曲线
    function p = Cubic_Bsp(u,x)
        b(1) = ((1-u)^3)/6;
        b(2) = (3*u^3-6*u^2+4)/6;
        b(3) = (-3*u^3+3*u^2+3*u+1)/6;
        b(4) = (u^3)/6;

        p = x*b';
    end


    %test.m 测试

    clear;clc
    x = [-1;-1;1;1;0.2];
    y = [1;-0.5;-1;1;0.8];
    z = zeros(6,1);
    z(3) = 1;

    CPnum = size(x,1);

    %x,y,z坐标分别计算B样条曲线控制点

    px = LU_B1(CPnum, x);
    py = LU_B1(CPnum, y);
    pz = LU_B1(CPnum, z);

    %首尾相连,曲线闭合

    x(CPnum+1) = x(1);
    y(CPnum+1) = y(1);
    z(CPnum+1) = z(1);

    figure;
    plot3(x,y,z,'ro-');
    hold on;
    for i=1:CPnum%用这个循环
        c=num2str(i);
        c=[' ',c];
        text(x(i),y(i),z(i),c)
        %text(x(i),y(i),c)
    end

    plot3(px,py,pz,'g-');
    for i=1:CPnum+1%用这个循环
        c=num2str(i);
        c=[' ',c];
        text(px(i),py(i),pz(i),c)
        plot3(px(i),py(i),pz(i),'*');
    end

    axis equal

    px(CPnum+3) = px(3);
    py(CPnum+3) = py(3);
    pz(CPnum+3) = pz(3);

    px(CPnum+4) = px(4);
    py(CPnum+4) = py(4);
    pz(CPnum+4) = pz(4);

    %两点之间对10个点进行插值计算

    nP = 10;
    delta = 1.0/nP;
    for j=1:CPnum
        u = 0.0;
        for i=1:nP
            
            p = px';
            Xi = p(j:j+3);
            xx(i+(j-1)*nP) = Cubic_Bsp(u,Xi);  
            p = py';
            Yi = p(j:j+3);
            yy(i+(j-1)*nP) = Cubic_Bsp(u,Yi);        
            
            p = pz';
            Zi = p(j:j+3);
            zz(i+(j-1)*nP) = Cubic_Bsp(u,Zi);        
            
            u = u + delta;
        end
    end
    xx(end+1) = x(1);
    yy(end+1) = y(1);
    zz(end+1) = z(1);
    plot3(xx,yy,zz,'b--')

     

    结果如图所示,红色为三维空间5个不共面点

    绿色为B样条曲线控制点

    蓝色为B样条拟合曲线

     

    展开全文
  • %hg为x和y拟合的系数,16行, %第1,2行分别为第一段x,y的系数,3,4为第二段,类推 plot(x,y) hold on plot([xx(i+1),xx(i+2)],[yy(i+1),yy(i+2)]) hold on end 结果 方程参数为hg 第一行所有为第一个方程横坐标x...

    参考

    https://blog.csdn.net/liumangmao1314/article/details/54588155?utm_source=blogxgwz0

    代码如下:

    clc
    clear
    xx=[6.852,5.934,5.317,4.617,3.924,3.232,2.525,1.882,0.999];
    yy=[1.399,1.399,1.226,0.859,0.212,0.339,-0.657,-0.892,-0.892];
    xx=[xx(1)-xx(2)+xx(1),xx,xx(end)-xx(end-1)+xx(end)];
    yy=[yy(1)-yy(2)+yy(1),yy,yy(end)-yy(end-1)+yy(end)];
    hg=[];
    for i=1:8
    t=(0:0.001:1);
    x0=xx(i);x1=xx(i+1);x2=xx(i+2);x3=xx(i+3);
    y0=yy(i);y1=yy(i+1);y2=yy(i+2);y3=yy(i+3);
    a0=(x0+4*x1+x2)/6;a1=-(x0-x2)/2;a2=(x0-2*x1+x2)/2;a3=-(x0-3*x1+3*x2-x3)/6;
    b0=(y0+4*y1+y2)/6;b1=-(y0-y2)/2;b2=(y0-2*y1+y2)/2;b3=-(y0-3*y1+3*y2-y3)/6;
    x=a0+a1*t+a2*t.^2+a3*t.^3;
    y=b0+b1*t+b2*t.^2+b3*t.^3;
    hg=[hg;a0,a1,a2,a3;b0,b1,b2,b3];%hg为x和y拟合的系数,16行,
                  %第1,2行分别为第一段x,y的系数,3,4为第二段,类推
    plot(x,y)
    hold on
    plot([xx(i+1),xx(i+2)],[yy(i+1),yy(i+2)])
    hold on
    end
    

    结果

    方程参数为hg

    第一行所有为第一个方程横坐标x的常数项、一次项、二次项、三次项。

    第二行所有为第一个方程纵坐标y的常数项、一次项、二次项、三次项。

    3、4为第二个方程。

    直到最后

    展开全文
  • b样条曲线拟合

    2019-03-31 15:53:54
    b样条曲线拟合,用着很好用
  • 针对这一问题,基于混沌蚂蚁群优化算法CASO,提出了一种新的B样条曲线拟合算法CASO-DF。该算法结合B样条曲线拟合原理,通过蚁群中蚂蚁个体的混沌行为,调整自由节点位置,通过蚁群的自组织行为自适应地调整内部节点...
  • 在工程上往往需要进行三维曲线拟合,该Matlab代码可以对三组离散数据进行三维B样条曲线拟合
  • B样条曲线拟合(B_Spline_Approximation)

    千次阅读 热门讨论 2020-07-06 23:44:24
    B样条曲线拟合主要是一个LSQ(least squares) 拟合问题,主要思想也是最小二乘法的思想,这与B-Spline曲线插值不同,拟合的曲线是尽量接近数据点,而不是完全通过。主要的方法可以参考cs3621 这里我定义了一个BS_...

    B_Spline_Approximation

    B样条曲线的拟合主要是一个LSQ(least squares) 拟合问题,主要思想也是最小二乘法的思想,这与B-Spline曲线插值不同,拟合的曲线是尽量接近数据点,而不是完全通过。主要的方法可以参考cs3621

    这里我定义了一个BS_curve类,类中的方法包括数据的参数化(parameterization),节点(knots)的生成,计算系数Ni,pN_{i,p},De_Boor算法以及最小二乘拟合(approximation),完整代码如下:

    
    
    import numpy as np
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    import math
    
    class BS_curve(object):
    
        def __init__(self,n,p,cp=None,knots=None):
            self.n = n # n+1 control points >>> p0,p1,,,pn
            self.p = p
            if cp:
                self.cp = cp
                self.u = knots
                self.m = knots.shape[0]-1 # m+1 knots >>> u0,u1,,,nm
            else:
                self.cp = None
                self.u = None
                self.m = None
    
            self.paras = None
    
    
        def check(self):
            if self.m == self.n + self.p + 1:
                return 1
            else:
                return 0
    
    
        def coeffs(self,uq):
            # n+1 control points >>> p0,p1,,,pn
            # m+1 knots >>> u0,u1,,,nm
            # algorithm is from https://pages.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/B-spline/bspline-curve-coef.html
        
            #N[] holds all intermediate and the final results
            # in fact N is longer than control points,this is just to hold the intermediate value
            # at last, we juest extract a part of N,that is N[0:n+1]
            N = np.zeros(self.m+1,dtype=np.float64) 
    
            # rule out special cases Important Properties of clamped B-spline curve
            if uq == self.u[0]:
                N[0] = 1.0
                return N[0:self.n+1]
            elif uq == self.u[self.m]:
                N[self.n] = 1.0
                return N[0:self.n+1]
    
            # now u is between u0 and um
            # first find k uq in span [uk,uk+1)
            check = uq - self.u
            ind = check >=0
            k = np.max(np.nonzero(ind))
            # sk >>> multiplicity of u[k]
            sk = np.sum(self.u==self.u[k])
    
            N[k] = 1.0 # degree 0
            # degree d goes from 1 to p
            for d in range(1,self.p+1):
                r_max = self.m - d - 1 # the maximum subscript value of N in degree d,the minimum is 0
                if k-d >=0:
                    if self.u[k+1]-self.u[k-d+1]:
                        N[k-d] = (self.u[k+1]-uq)/(self.u[k+1]-self.u[k-d+1])*N[k-d+1] #right (south-west corner) term only
                    else:
                        N[k-d] = (self.u[k+1]-uq)/1*N[k-d+1] #right (south-west corner) term only
    
                for i in range(k-d+1,(k-1)+1):
                    if i>=0 and i<=r_max:
                        Denominator1 = self.u[i+d]-self.u[i]
                        Denominator2 = self.u[i+d+1]-self.u[i+1]
                        # 0/0=0
                        if Denominator1 == 0:
                            Denominator1 = 1
                        if Denominator2 == 0:
                            Denominator2 = 1
    
                        N[i] = (uq-self.u[i])/(Denominator1)*N[i]+(self.u[i+d+1]-uq)/(Denominator2)*N[i+1]
    
                if k <= r_max:
                    if self.u[k+d]-self.u[k]:
                        N[k] = (uq-self.u[k])/(self.u[k+d]-self.u[k])*N[k]
                    else:
                        N[k] = (uq-self.u[k])/1*N[k]
    
            return N[0:self.n+1]
    
    
        def De_Boor(self,uq):
            # Input: a value u
            # Output: the point on the curve, C(u)
    
            # first find k uq in span [uk,uk+1)
            check = uq - self.u
            ind = check >=0
            k = np.max(np.nonzero(ind))
            
            # inserting uq h times
            if uq in self.u:
                # sk >>> multiplicity of u[k]
                sk = np.sum(self.u==self.u[k])
                h = self.p - sk
            else:
                sk = 0
                h = self.p
    
            # rule out special cases
            if h == -1:
                if k == self.p:
                    return np.array(self.cp[0])
                elif k == self.m:
                    return np.array(self.cp[-1])
    
    
            # initial values of P(affected control points) >>> Pk-s,0 Pk-s-1,0 ... Pk-p+1,0
            P = self.cp[k-self.p:k-sk+1]
            P = P.copy()
            dis = k-self.p # the index distance between storage loaction and varibale i
            # 1-h
            
            for r in range(1,h+1):
                # k-p >> k-sk
                temp = [] # uesd for Storing variables of the current stage
                for i in range(k-self.p+r,k-sk+1):
                    a_ir = (uq-self.u[i])/(self.u[i+self.p-r+1]-self.u[i])
                    temp.append((1-a_ir)*P[i-dis-1]+a_ir*P[i-dis])
                P[k-self.p+r-dis:k-sk+1-dis] = np.array(temp)
            # the last value is what we want
            return P[-1]
    
    
        def bs(self,us):
            y = []
            for x in us:
                y.append(self.De_Boor(x))
            y = np.array(y)
            return y
    
    
        def estimate_parameters(self,data_points,method="centripetal"):
            pts = data_points.copy()
            N = pts.shape[0]
            w = pts.shape[1]
            Li = []
            for i in range(1,N):
                Li.append(np.sum([pts[i,j]**2 for j in range(w)])**0.5)
            L = np.sum(Li)
    
            t= [0]
            for i in range(len(Li)):
                Lki = 0
                for j in range(i+1):
                    Lki += Li[j]
                t.append(Lki/L)
            t = np.array(t)
            self.paras = t
            ind = t>1.0
            t[ind] = 1.0
            return t
    
    
        def get_knots(self,method="average"):
    
            knots = np.zeros(self.p+1).tolist()
    
            paras_temp = self.paras.copy()
            # m = n+p+1
            self.m = self.n + self.p + 1
            # we only need m+1 knots
            # so we just select m+1-(p+1)-(p+1)+(p-1)+1+1  paras to average
            num = self.m - self.p  # select n+1 paras
    
            ind = np.linspace(0,paras_temp.shape[0]-1,num)
            ind = ind.astype(int)
            paras_knots = paras_temp[ind]
    
            for j in range(1,self.n-self.p+1):
                k_temp = 0
                # the maximun of variable i is n-1
                for i in range(j,j+self.p-1+1):
                    k_temp += paras_knots[i]
                k_temp /= self.p
                knots.append(k_temp)
    
            add = np.ones(self.p+1).tolist()
            knots = knots + add
            knots = np.array(knots)
            self.u = knots
            self.m = knots.shape[0]-1
            return knots
    
    
        def set_paras(self,parameters):
            self.paras = parameters
    
    
        def set_knots(self,knots):
            self.u = knots
    
    
        def approximation(self,pts):
            ## Obtain a set of parameters t0, ..., tn
            #pts_paras = self.estimate_parameters(pts)
            ## knot vector U;
            #knots = self.get_knots()
            num = pts.shape[0]-1 # (num+1) is the number of data points
    
            P = np.zeros((self.n+1,pts.shape[1]),dtype=np.float64) # n+1 control points
            P[0] = pts[0]
            P[-1] = pts[-1]
    
            # compute N
            N = []
            for uq in self.paras:
                N_temp = self.coeffs(uq)
                N.append(N_temp)
            N = np.array(N)
    
            Q = [0] # hold the location
            for k in range(1,num-1+1):
                Q_temp = pts[k] - N[k,0]*pts[0] - N[k,self.n]*pts[-1]
                Q.append(Q_temp)
    
            b = [0]
            for i in range(1,self.n-1+1):
                b_temp = 0
                for k in range(1,num-1+1):
                    b_temp += N[k,i]*Q[k]
                b.append(b_temp)
    
            b = b[1::]
            b = np.array(b)
    
            N = N[:,1:(self.n-1)+1]
            A = np.dot(N.T,N)
            cpm = np.linalg.solve(A,b)
            P[1:self.n] = cpm
            self.cp = P
            return P
    
    
    if __name__ =="__main__":
        bs = BS_curve(8,3)
        xx = np.linspace(0,4*np.pi,101)
        yy = np.sin(xx)+0.6*np.random.random(101)
        fig = plt.figure(figsize=(10,5))
        ax = fig.add_subplot(111)
        ax.scatter(xx,yy)
    
        data = np.array([xx,yy]).T
        paras = bs.estimate_parameters(data)
        knots = bs.get_knots()
        if bs.check():
            cp = bs.approximation(data)
    
        uq = np.linspace(0,1,101)
        y = bs.bs(uq)
        ax.plot(y[:,0],y[:,1],'-r')
        ax.plot(cp[:,0],cp[:,1],'-b*')
        plt.show()
    

    上面代码的结果如下图所示:
    LSQ_fittinf

    展开全文
  • 三次B样条曲线拟合C++

    千次阅读 2020-08-21 11:20:17
    三次B样条曲线拟合C++ B样条曲线的方程:P=∑i=0nPiFi,k(t)\sum_{i=0}^nP_iF_{i,k}(t)∑i=0n​Pi​Fi,k​(t) 其中Fi,k(t)F_{i,k}(t)Fi,k​(t)为基函数,三次B样条的基函数为: F0,3(t)=16(1−t)3F_{0,3}(t)=\...
  • 为解决数控系统进行连续微线段加工时加减速频繁、运行速度缓慢、加工路径不连续等问题,提出了最小二乘3次B样条曲线逼近拟合算法,采用该算法实现对连续微线段的逼近.文中通过分析连续微线段加工路径的几何特性,提出了...
  • 针对叶片型线的优化设计,提出采用自适应方法提取合适的节点来插值非均匀有理B样条(NURBS)曲线算法,实现了满足一定精度要求的数据点云拟合以及控制点的计算。该方法首先通过点云外形特征提取主特征点,把主特征点...
  • 图像二值化之后,可以用cv2.CHAIN_APPROX_NONE或者cv2....再对上面保存的csv文件读取,进行B样条曲线拟合。可以修改拟合点的数量。 import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d
  • 三次B样条曲线算法 计算机图形学 MFC 孔令德 代码 课件案例 习题答案 第七章 三次B样条曲线算法 计算机图形学 MFC 孔令德 代码 课件案例 习题答案 第七章
  • PCL 平面点云B样条曲线拟合

    万次阅读 2021-02-27 09:13:33
    平面点云B样条曲线拟合
  • PCL——B样条曲线曲面拟合

    千次阅读 2020-08-06 21:35:19
    B样条曲线 样条曲线,是B-样条基函数的线性组合,是贝塞尔曲线的一般化。 给定n+1个控制点,P0,P1, …, Pn以及一个节点向量U = { u0,u1, …, um }, p 次B-样条曲线由这些控制点和节点向量U 定义,设Ni,p(u)是第i个 p...
  • 三次Beizer曲线拟合算法

    万次阅读 2017-01-17 20:48:55
    最近用到轮廓拟合,所以用三次Beizer曲线效果还可以,有插值和近似拟合(插值就是曲线过点,近似拟合则不过点),就学习了一下。我是做的Beizer曲线插值,插值和近视拟合无非就是控制点选取不一样。 Beizer总方程为...
  • B样条曲线——de Boor递推算法实现

    千次阅读 2019-05-04 12:03:26
    B样条曲线——de Boor递推算法实现 1. 定义   为保留Bezier方法的优点,B样条曲线的方程定义为 P(t)=∑i=0nPiNi,k(t) P(t)=\sum_{i=0}^n P_i N_{i,k}(t) P(t)=i=0∑n​Pi​Ni,k​(t) 其中,Pi(i=0,1,…,n)P_i(i=0,...
  • 针对高空气象探测数据变化规律复杂、突变情况不可预测、数据量大等特点,采用基于遗传算法确定节点矢量的B样条曲线拟合方法,并提出优化染色体的产生方式,加速算法的收敛效率,实现了在给定误差要求下,用较少控制...
  • 对于B样条曲线,您可以从几种结和参数选择算法中进行选择,并且可以自由选择控制点的数量。 即使使用“误差极限设置”也可以找到误差最小的曲线。 另外,您需要为面板提供包含您的点的输入文件。 该文件必须为格式或...
  • 光滑曲线拟合算法

    千次阅读 2006-04-19 13:52:00
    /* 二次抛物线法绘制曲线函数 */ void paowuxian(int *x,int *y,int n,unsigned int k) { unsigned int i,j; float t1,t2,t3,t,a,b,c,d,tx,ty; *x=*(x+1);*(y)=*(y+1); *(x+n+1)=*(x+n);*(y+n+1)=*(y+n); t=0.5/k; ...
  • 对多个点组成的数组进行插值拟合,在折点处得到光滑的曲线
  • 通过对实际高速信号PCB(Printed Circuit Board)布线中走线结构的研究,针对高速数字化服务器主板系统设计中PCB布线路径平滑可控的需要,提出一种基于B样条曲线的动态拟合算法,该算法采用型值点分批重叠求交算法...
  • 该方法提取出标本叶片图像的角点作为特征点, 采用三次均匀B样条曲线进行初步插值拟合, 并根据拟合误差采用改进的节点插入算法进行反复迭代, 直到达到要求的拟合精度。与传统方法相比, 该方法能够更快地达到逼近精度,...
  • 闭合B样条曲线算法

    2012-11-12 13:52:26
    现在我有一些离散点,我需要利用...如果是非闭合的b样条曲线,网上可以找到现成的算法(http://paulbourke.net/geometry/spline/index2.html),但是闭合的曲线我实在找不到了。主要问题是闭合以后首位点的斜率不连续。
  • 1.B-样条曲线教程(B-spline Curves Notes)目录 2.运动规划——B样条曲线 3.B样条曲线(B-spline Curves) 4.基于B样条曲线的路径规划(含matlab代码) 5.B样条曲线拟合原理
  • 在OpenGL的基础上进行编写,绘制三次B样条曲线,可以通过鼠标设置控制点位置、拖动控制点观察曲线动态变化
  • 简单详细的均匀三次B样条曲线插值MATLAB代码,有注释
  • 针对B样条曲线的生成,采用deboor算法根据控制点生成相应的曲线上的坐标值。本资源包含了基函数的计算函数,节点向量的生成函数,一个简单的应用实例。
  • OpenCasCade与NURBS——B样条曲线

    千次阅读 2018-08-04 13:07:59
    NURBS是非均匀有理B样条的简称,NURBS是现在通用CAD软件中比较高级的建模方法,B样条在创建曲线或曲面时有很高的灵活性,会用并善用基本上能获得想要的任意“自然”、光滑的曲线。...B样条曲线是B...
  • B-Spline曲线拟合

    千次阅读 2020-05-15 11:00:04
    B-Spline曲线拟合 – Python实现 1.曲线定义 定义曲线为p阶样条曲线 给定n+1个控制点 P0,P1,...Pn 节点向量 U = {u0,u1....um},且m = n+p+1 B-Spline曲线定义如下: N(i,p)为样条基函数 P(i)为控制顶点 参数u...

空空如也

空空如也

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

b样条曲线拟合算法